larkin 0.4.2 → 0.4.6

package/dist/runtime/runtime-host.mjs

@@ -8,7 +8,7 @@ import { buildStrictProviderErrorInput, classifyStrictProviderError } from "./pr
 import { classifyRuntimePrerequisite, providerAuthenticationFailureReadiness, RuntimePrerequisiteError, } from "./runtime-readiness.mjs";
 import { resolveOfficialLarkCli } from "../app/official-lark-cli.mjs";
 import { assertAgentWorkspaceBound, managedLarkCliEnv } from "../app/agent-lark-cli-workspace.mjs";
-import { PiCompactionBreaker, PiCompactionRecoveryMachine } from "./pi-compaction-recovery.mjs";
+import { isPiNativeCompactionRequired, PiCompactionBreaker, PiCompactionRecoveryMachine, } from "./pi-compaction-recovery.mjs";
 export class RuntimeSessionResetError extends Error {
     code;
     pendingCount;
@@ -388,18 +388,22 @@ export function createRuntimeHost(options) {
     };
     const resultFor = (agent, record, result) => {
         if (result.status === "accepted") {
-            delete record.reason;
+            if (record.errorCategory !== "context_window") {
+                delete record.reason;
+                delete record.errorCategory;
+            }
             delete record.retryable;
-            delete record.errorCategory;
             const finalRecord = setRecord(agent, record, "accepted");
             if (finalRecord.status !== "consumed")
                 emit({ type: "delivery", agentId: agent.config.agentId,
                     deliveryId: record.deliveryId, messageId: record.messageId, status: "accepted" });
             return { status: "accepted", deliveryId: record.deliveryId };
         }
-        delete record.errorCategory;
+        if (record.errorCategory !== "context_window")
+            delete record.errorCategory;
         const retryable = result.status === "deferred" || result.retryable;
-        record.reason = result.reason;
+        if (record.errorCategory !== "context_window")
+            record.reason = result.reason;
         record.retryable = retryable;
         const finalRecord = setRecord(agent, record, retryable ? "pending" : "error");
         if (finalRecord.status === "consumed")
@@ -411,6 +415,22 @@ export function createRuntimeHost(options) {
             : { status: "error", deliveryId: record.deliveryId, reason: result.reason, retryable: false };
     };
     const submit = async (agent, record, busy) => {
+        const proactive = agent.piProactiveCompaction
+            && agent.piProactiveCompactionGeneration === agent.generation
+            && agent.piProactiveCompactionSession === agent.session
+            ? agent.piProactiveCompaction : null;
+        if (proactive && await proactive === "failed") {
+            return { status: "deferred", deliveryId: record.deliveryId, reason: "Pi proactive compaction failed for the current session generation" };
+        }
+        if (agent.adapter.id === "pi" && agent.piProactiveCompactionFailedGeneration === agent.generation) {
+            return { status: "deferred", deliveryId: record.deliveryId, reason: "Pi proactive compaction failed for the current session generation" };
+        }
+        if (agent.adapter.id === "pi" && !busy && !agent.busy && !agent.turnInProgress && agent.session) {
+            const idleGate = proactivelyCompactPiAtIdle(agent, agent.session);
+            if (idleGate && await idleGate === "failed") {
+                return { status: "deferred", deliveryId: record.deliveryId, reason: "Pi proactive compaction failed for the current session generation" };
+            }
+        }
         agent.submitting = true;
         if (!busy)
             agent.busy = true; // Reserve the turn before prompt() can yield.
@@ -450,9 +470,11 @@ export function createRuntimeHost(options) {
             if (!busy)
                 agent.busy = false;
             const reason = error instanceof Error ? error.message : String(error);
-            record.reason = reason;
+            if (record.errorCategory !== "context_window") {
+                record.reason = reason;
+                delete record.errorCategory;
+            }
             record.retryable = true;
-            delete record.errorCategory;
             setRecord(agent, record, "pending");
             emit({ type: "delivery", agentId: agent.config.agentId, deliveryId: record.deliveryId, messageId: record.messageId, status: "deferred", reason });
             return { status: "deferred", deliveryId: record.deliveryId, reason };
@@ -466,16 +488,41 @@ export function createRuntimeHost(options) {
         }
     };
     const retryPending = async (agent) => {
-        reconcileExternalConsumption(agent);
-        if (agent.submitting) {
-            agent.retryAfterSubmit = true;
-            return;
+        if (agent.retryPendingInFlight)
+            return agent.retryPendingInFlight;
+        const run = (async () => {
+            reconcileExternalConsumption(agent);
+            const proactive = agent.piProactiveCompaction
+                && agent.piProactiveCompactionGeneration === agent.generation
+                && agent.piProactiveCompactionSession === agent.session
+                ? agent.piProactiveCompaction : null;
+            if (proactive && await proactive === "failed")
+                return;
+            if (agent.submitting || agent.starting) {
+                agent.retryAfterSubmit = true;
+                return;
+            }
+            if (agent.adapter.id === "pi" && agent.piProactiveCompactionFailedGeneration === agent.generation)
+                return;
+            if (agent.busy || agent.turnInProgress || !agent.session)
+                return;
+            if (agent.adapter.id === "pi") {
+                const idleGate = proactivelyCompactPiAtIdle(agent, agent.session);
+                if (idleGate && await idleGate === "failed")
+                    return;
+            }
+            const record = [...agent.records.values()].find((candidate) => candidate.status === "pending" || candidate.status === "submitting");
+            if (record)
+                await submit(agent, record, false);
+        })();
+        agent.retryPendingInFlight = run;
+        try {
+            await run;
+        }
+        finally {
+            if (agent.retryPendingInFlight === run)
+                agent.retryPendingInFlight = null;
         }
-        if (agent.busy || agent.turnInProgress || !agent.session)
-            return;
-        const record = [...agent.records.values()].find((candidate) => candidate.status === "pending" || candidate.status === "submitting");
-        if (record)
-            await submit(agent, record, false);
     };
     const scheduleRecreate = (agent, reason) => {
         if (agent.stopped || agent.retryTimer || agent.starting || agent.session)
@@ -493,8 +540,12 @@ export function createRuntimeHost(options) {
             agent.retryTimer = null;
             if (agent.stopped)
                 return;
-            void ensureSession(agent).then(() => {
-                return retryPending(agent);
+            void ensureSession(agent).then(async () => {
+                const session = agent.session;
+                const proactive = session ? proactivelyCompactPiAtIdle(agent, session) : null;
+                if (proactive && await proactive === "failed")
+                    return;
+                await retryPending(agent);
             }).catch((error) => {
                 const readiness = error instanceof RuntimePrerequisiteError ? error.readiness
                     : classifyRuntimePrerequisite(agent.adapter.id, error);
@@ -605,7 +656,6 @@ export function createRuntimeHost(options) {
                     machine.retrySubmitted();
                     record.status = "pending";
                     record.retryable = true;
-                    record.reason = "Pi manual compaction succeeded; retrying the same delivery input";
                     record.updatedAt = now();
                     persist(agent);
                     queueMicrotask(() => { if (!agent.stopped)
@@ -614,14 +664,19 @@ export function createRuntimeHost(options) {
                 else if (action === "fresh_session_fallback") {
                     agent.busy = false;
                     agent.turnInProgress = false;
-                    if (record.status !== "error") {
-                        record.reason = machine.recordSnapshot.fallbackReason || "Pi compaction recovery fallback";
+                    const recoveryReason = machine.recordSnapshot.fallbackReason || "Pi compaction recovery fallback";
+                    // Delivery proof must remain the exact provider-classified context error.
+                    // Generic Pi recovery text belongs only in the breaker and logs.
+                    if (record.errorCategory === "context_window" && typeof record.reason === "string") {
                         record.retryable = false;
-                        record.errorCategory = "context_window";
                         setRecord(agent, record, "error");
+                        if (!agent.compactionRecoveryInFlight.has(key)) {
+                            agent.compactionRecoveryInFlight.add(key);
+                            void recoverContextOverflowInternal(agent.config.agentId, key, recoveryReason, key)
+                                .catch((error) => log("Pi context fallback failed", String(error)))
+                                .finally(() => agent.compactionRecoveryInFlight.delete(key));
+                        }
                     }
-                    void recoverContextOverflowInternal(agent.config.agentId, key, machine.recordSnapshot.fallbackReason || "Pi compaction recovery fallback", key)
-                        .catch((error) => log("Pi context fallback failed", String(error)));
                 }
             },
         });
@@ -656,6 +711,8 @@ export function createRuntimeHost(options) {
         });
     };
     const recoverStalePiCompaction = async (agent) => {
+        if (!agent.stateStore)
+            return;
         const breaker = agent.compactionBreaker;
         if (!breaker)
             return;
@@ -670,14 +727,59 @@ export function createRuntimeHost(options) {
             || candidate.input.inputId === stale.inputId);
         if (!record)
             return;
-        record.reason = stale.fallbackReason || "Pi compaction recovery resumed after restart";
+        const recoveryReason = stale.fallbackReason || "Pi compaction recovery resumed after restart";
+        if (record.errorCategory !== "context_window" || typeof record.reason !== "string")
+            return;
         record.retryable = false;
-        record.errorCategory = "context_window";
         setRecord(agent, record, "error");
-        breaker.forceFallback(stale.key, record.reason);
+        breaker.forceFallback(stale.key, recoveryReason);
         agent.busy = false;
         agent.turnInProgress = false;
-        await recoverContextOverflowInternal(agent.config.agentId, stale.key, record.reason, stale.key);
+        await recoverContextOverflowInternal(agent.config.agentId, stale.key, recoveryReason, stale.key);
+    };
+    const proactivelyCompactPiAtIdle = (agent, session) => {
+        if (agent.adapter.id !== "pi" || session.piPolicyManaged === false
+            || !session.getContextUsage || !session.compact)
+            return null;
+        if (agent.session !== session || agent.stopped || agent.busy || agent.turnInProgress || agent.submitting || agent.starting
+            || agent.compactionRecoveryInFlight.size > 0
+            || agent.compactionMachines.size > 0 || agent.piOverflowCompactionFailed.size > 0)
+            return null;
+        if (agent.piProactiveCompactionFailedGeneration === agent.generation)
+            return null;
+        const generation = agent.generation;
+        if (agent.piProactiveCompaction && agent.piProactiveCompactionGeneration === generation
+            && agent.piProactiveCompactionSession === session)
+            return agent.piProactiveCompaction;
+        const task = (async () => {
+            const before = await session.getContextUsage();
+            if (!before || agent.session !== session || agent.stopped || agent.busy || agent.turnInProgress || agent.submitting
+                || agent.compactionRecoveryInFlight.size > 0 || agent.compactionMachines.size > 0
+                || agent.piOverflowCompactionFailed.size > 0)
+                return "noop";
+            if (!isPiNativeCompactionRequired(before.tokens, before.contextWindow))
+                return "noop";
+            await session.compact();
+            const after = await session.getContextUsage();
+            if (!after || after.contextWindow !== before.contextWindow || after.tokens >= before.tokens) {
+                throw new Error("Pi proactive compaction did not reduce the verified context usage");
+            }
+            return "succeeded";
+        })();
+        const tracked = task.catch((error) => {
+            agent.piProactiveCompactionFailedGeneration = generation;
+            emit({ type: "agent-status", agentId: agent.config.agentId, status: "error",
+                error: "Pi proactive compaction failed; the current session generation is degraded" });
+            log("Pi proactive compaction failed", String(error));
+            return "failed";
+        }).finally(() => {
+            if (agent.piProactiveCompaction === tracked)
+                agent.piProactiveCompaction = null;
+        });
+        agent.piProactiveCompactionGeneration = generation;
+        agent.piProactiveCompactionSession = session;
+        agent.piProactiveCompaction = tracked;
+        return tracked;
     };
     const observe = (agent, session, event) => {
         if (agent.session !== session)
@@ -719,7 +821,6 @@ export function createRuntimeHost(options) {
             agent.config.sessionId = event.sessionId;
             emit({ type: "session", agentId: agent.config.agentId, runtime: agent.adapter.id, sessionId: event.sessionId, launchId: agent.launchId,
                 ...(event.model ? { model: event.model } : {}), ...(event.reasoningEffort ? { reasoningEffort: event.reasoningEffort } : {}) });
-            void retryPending(agent);
         }
         else if (event.type === "turn-start") {
             agent.busy = true;
@@ -755,7 +856,11 @@ export function createRuntimeHost(options) {
                 };
                 emit({ type: "agent-status", agentId: agent.config.agentId, status: "active", readiness: agent.readiness });
             }
-            void retryPending(agent);
+            const proactive = proactivelyCompactPiAtIdle(agent, session);
+            void (proactive ?? Promise.resolve("noop")).then((outcome) => {
+                if (outcome !== "failed")
+                    return retryPending(agent);
+            });
         }
         else if (event.type === "activity") {
             if (agent.turnInProgress && event.activity !== "internal")
@@ -781,8 +886,13 @@ export function createRuntimeHost(options) {
                 if (agent.piOverflowCompactionFailed.has(record.input.inputId)) {
                     agent.busy = false;
                     agent.turnInProgress = false;
-                    void recoverContextOverflowInternal(agent.config.agentId, `${record.deliveryId}:${record.input.inputId}`, "native Pi overflow compaction failed", `${record.deliveryId}:${record.input.inputId}`)
-                        .catch((error) => log("Pi native compaction fallback failed", String(error)));
+                    const recoveryKey = `${record.deliveryId}:${record.input.inputId}`;
+                    if (!agent.compactionRecoveryInFlight.has(recoveryKey)) {
+                        agent.compactionRecoveryInFlight.add(recoveryKey);
+                        void recoverContextOverflowInternal(agent.config.agentId, recoveryKey, "native Pi overflow compaction failed", recoveryKey)
+                            .catch((error) => log("Pi native compaction fallback failed", String(error)))
+                            .finally(() => agent.compactionRecoveryInFlight.delete(recoveryKey));
+                    }
                     return;
                 }
                 // Pi emits this terminal error only after agent_settled; release the
@@ -967,7 +1077,6 @@ export function createRuntimeHost(options) {
                     continue;
                 candidate.status = "pending";
                 candidate.retryable = true;
-                candidate.reason = "context-window recovery rearmed the retained Inbox delivery";
                 candidate.updatedAt = now();
             }
         };
@@ -1013,7 +1122,11 @@ export function createRuntimeHost(options) {
         }
         emit({ type: "agent-status", agentId, status: "active", readiness });
         await oldSession.close("Pi context fallback committed").catch((error) => log("previous Pi session close after fallback failed", String(error)));
-        void retryPending(agent);
+        const proactive = proactivelyCompactPiAtIdle(agent, fresh);
+        void (proactive ?? Promise.resolve("noop")).then((outcome) => {
+            if (outcome !== "failed")
+                return retryPending(agent);
+        });
         return { generationChanged: true, sessionChanged: oldSessionId !== fresh.sessionId, turns: 0,
             runtimeReady: true, pendingCount: remainingPendingCount, rearmedCount,
             replayStatus: remainingPendingCount > 0 ? "pending" : "consumed", sessionId: fresh.sessionId };
@@ -1325,7 +1438,6 @@ export function createRuntimeHost(options) {
                             continue;
                         record.status = "pending";
                         record.retryable = true;
-                        record.reason = "context-window recovery rearmed the retained Inbox delivery";
                         record.updatedAt = now();
                     }
                 });
@@ -1340,7 +1452,11 @@ export function createRuntimeHost(options) {
                 durableRollback = null;
                 await oldSession.close("context-window recovery committed")
                     .catch((error) => log("previous runtime close after context-window recovery failed", String(error)));
-                void retryPending(agent);
+                const proactive = proactivelyCompactPiAtIdle(agent, fresh);
+                void (proactive ?? Promise.resolve("noop")).then((outcome) => {
+                    if (outcome !== "failed")
+                        return retryPending(agent);
+                });
                 return { generationChanged: true, sessionChanged: oldSessionId !== fresh.sessionId, turns: 0,
                     runtimeReady: true, pendingCount: rearmed.remainingPendingCount, rearmedCount: rearmed.rearmedCount,
                     replayStatus: rearmed.remainingPendingCount > 0 ? "pending" : "consumed", sessionId: fresh.sessionId };
@@ -1408,16 +1524,19 @@ export function createRuntimeHost(options) {
                     : readDeliveryFile(config.stateDir ? path.join(config.stateDir, "runtime-deliveries.json") : null);
                 const agent = { config, adapter: options.adapterFor(config.runtime), session: null,
                     launchId: crypto.randomUUID(), busy: false, submitting: false, starting: null, retryAfterSubmit: false,
+                    retryPendingInFlight: null,
                     records: new Map(persisted.records.map((record) => [record.deliveryId, record])),
                     byMessage: new Map(persisted.records.map((record) => [record.messageId, record.deliveryId])),
                     generation: 0, poller: null, retryTimer: null, recreateAttempts: 0,
                     stabilityTimer: null, recreateReason: null, stopped: false, disabledReason: null,
                     configurationRecovery: null, stateStore,
-                    compactionBreaker: config.runtime === "pi"
+                    compactionBreaker: config.runtime === "pi" && stateStore
                         ? new PiCompactionBreaker(config.stateDir ?? path.join(config.workspaceDir, ".larkin", "agents", config.agentId), {
-                            withLock: stateStore ? (operation) => stateStore.withInboxTransaction(operation) : undefined,
+                            withLock: (operation) => stateStore.withInboxTransaction(operation),
                         }) : undefined,
-                    compactionMachines: new Map(), piOverflowCompactionFailed: new Set(), readiness: null,
+                    compactionMachines: new Map(), compactionRecoveryInFlight: new Set(), piOverflowCompactionFailed: new Set(),
+                    piProactiveCompaction: null, piProactiveCompactionGeneration: null, piProactiveCompactionSession: null,
+                    piProactiveCompactionFailedGeneration: null, readiness: null,
                     turnInProgress: false, turnHadFailure: false, turnHadAuthenticatedOutput: false, authFailureActive: false };
                 const startupConsumed = [];
                 const startupQuarantined = [];
@@ -1450,8 +1569,12 @@ export function createRuntimeHost(options) {
                 try {
                     await ensureSession(agent);
                     await recoverStalePiCompaction(agent);
+                    const startupSession = agent.session;
+                    const proactive = startupSession ? proactivelyCompactPiAtIdle(agent, startupSession) : null;
+                    const proactiveOutcome = proactive ? await proactive : "noop";
                     activeCount += 1;
-                    await retryPending(agent);
+                    if (proactiveOutcome !== "failed")
+                        await retryPending(agent);
                 }
                 catch (error) {
                     const reason = error instanceof Error ? error.message : String(error);

package/dist/runtime/runtime-readiness.cjs

@@ -45,6 +45,7 @@ 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");
+const process_boundary_trace_js_1 = require("../platform/process-boundary-trace.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;
@@ -122,8 +123,8 @@ function selectedCommand(options) {
         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 });
+function executableVersion(executable, env, commandArgs = []) {
+    const result = (0, node_child_process_1.spawnSync)(executable, [...commandArgs, "--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;
@@ -139,6 +140,7 @@ async function probeNativeRuntimeReadiness(options) {
             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。" };
         }
@@ -153,11 +155,11 @@ async function probeNativeRuntimeReadiness(options) {
                 ? "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);
+    const version = executableVersion(executable, env, options.commandArgs);
     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 });
+            await discoverPiModelCatalog({ cwd: options.cwd, command: executable, commandArgs: options.commandArgs, env });
         }
         else if (options.runtime === "codex") {
             const { discoverCodexModelCatalog } = await Promise.resolve().then(() => __importStar(require("./codex-model-catalog.cjs")));

package/dist/runtime/runtime-readiness.mjs

@@ -2,6 +2,7 @@ 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";
+import { traceProcessBoundary } from "../platform/process-boundary-trace.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;
@@ -78,8 +79,8 @@ function selectedCommand(options) {
         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 });
+function executableVersion(executable, env, commandArgs = []) {
+    const result = spawnSync(executable, [...commandArgs, "--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;
@@ -95,6 +96,7 @@ export async function probeNativeRuntimeReadiness(options) {
             return { runtime: "pi", state: "ready", executable: process.execPath, version: `official-pi ${BUNDLED_PI_VERSION} (bundled)` };
         }
         catch (error) {
+            traceProcessBoundary(env, "readiness:builtin-pi-failure", { configDir: env.LARKIN_CONFIG_DIR, agentId: options.agentId, targetDir: options.agentId && env.LARKIN_CONFIG_DIR ? 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。" };
         }
@@ -109,11 +111,11 @@ export async function probeNativeRuntimeReadiness(options) {
                 ? "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);
+    const version = executableVersion(executable, env, options.commandArgs);
     try {
         if (options.runtime === "pi") {
             const { discoverPiModelCatalog } = await import("./pi-model-catalog.mjs");
-            await discoverPiModelCatalog({ cwd: options.cwd, command: executable, env });
+            await discoverPiModelCatalog({ cwd: options.cwd, command: executable, commandArgs: options.commandArgs, env });
         }
         else if (options.runtime === "codex") {
             const { discoverCodexModelCatalog } = await import("./codex-model-catalog.mjs");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "larkin",
-  "version": "0.4.2",
+  "version": "0.4.6",
   "private": false,
   "larkinPackageRole": "npm-published",
   "files": [
@@ -84,14 +84,14 @@
     "test:live:agent-cli-routing-codex": "bun run build && LARKIN_RUN_AGENT_CLI_ROUTING_CODEX_LIVE=1 bun test --max-concurrency 1 test/live/agent-cli-routing-codex-live.test.mjs"
   },
   "dependencies": {
-    "@earendil-works/pi-coding-agent": "0.83.0",
-    "@tintinweb/pi-subagents": "0.14.3",
+    "@earendil-works/pi-coding-agent": "0.84.2",
     "@larksuite/channel": "^0.4.0",
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/resources": "^2.10.0",
     "@opentelemetry/sdk-trace-base": "^2.10.0",
     "@opentelemetry/sdk-trace-node": "^2.10.0",
     "@radix-ui/react-dialog": "^1.1.21",
+    "@tintinweb/pi-subagents": "0.14.3",
     "lucide-react": "^1.26.0",
     "proper-lockfile": "4.1.2",
     "qrcode-terminal": "^0.12.0",