larkin 0.4.1 → 0.4.5

package/dist/runtime/runtime-host.cjs

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RuntimeSessionResetError = void 0;
+exports.RuntimeSessionRecoveryError = exports.RuntimeSessionResetError = void 0;
 exports.createRuntimeHost = createRuntimeHost;
 const node_crypto_1 = __importDefault(require("node:crypto"));
 const node_fs_1 = __importDefault(require("node:fs"));
@@ -11,9 +11,11 @@ const node_path_1 = __importDefault(require("node:path"));
 const agent_cli_capabilities_js_1 = require("../agent/agent-cli-capabilities.cjs");
 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 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");
 class RuntimeSessionResetError extends Error {
     code;
     pendingCount;
@@ -25,6 +27,17 @@ class RuntimeSessionResetError extends Error {
     }
 }
 exports.RuntimeSessionResetError = RuntimeSessionResetError;
+class RuntimeSessionRecoveryError extends Error {
+    code;
+    pendingCount;
+    constructor(code, message, pendingCount = 0) {
+        super(message);
+        this.code = code;
+        this.pendingCount = pendingCount;
+        this.name = "RuntimeSessionRecoveryError";
+    }
+}
+exports.RuntimeSessionRecoveryError = RuntimeSessionRecoveryError;
 const MAX_DELIVERIES = 2048;
 const now = () => new Date().toISOString();
 const isActiveDelivery = (status) => ["pending", "submitting", "accepted"].includes(status);
@@ -114,6 +127,9 @@ function createRuntimeHost(options) {
     const listeners = new Set();
     const log = options.log ?? (() => { });
     const telemetry = options.telemetry;
+    const compactTimeoutMs = options.compactTimeoutMs ?? 120_000;
+    if (!Number.isFinite(compactTimeoutMs) || compactTimeoutMs <= 0)
+        throw new Error("compactTimeoutMs must be positive");
     const retryPolicy = {
         baseDelayMs: options.retryPolicy?.baseDelayMs ?? 250,
         maxDelayMs: options.retryPolicy?.maxDelayMs ?? 10_000,
@@ -242,6 +258,7 @@ function createRuntimeHost(options) {
         scrubQuarantinedInput(record, reason);
         record.reason = reason;
         record.retryable = false;
+        delete record.errorCategory;
         const finalRecord = setRecord(agent, record, "error");
         if (finalRecord.status === "consumed")
             return { status: "accepted", deliveryId: record.deliveryId };
@@ -380,7 +397,10 @@ 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;
             const finalRecord = setRecord(agent, record, "accepted");
             if (finalRecord.status !== "consumed")
@@ -388,8 +408,11 @@ function createRuntimeHost(options) {
                     deliveryId: record.deliveryId, messageId: record.messageId, status: "accepted" });
             return { status: "accepted", deliveryId: record.deliveryId };
         }
+        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")
@@ -401,6 +424,22 @@ 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.
@@ -440,7 +479,10 @@ 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;
             setRecord(agent, record, "pending");
             emit({ type: "delivery", agentId: agent.config.agentId, deliveryId: record.deliveryId, messageId: record.messageId, status: "deferred", reason });
@@ -455,16 +497,41 @@ 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)
@@ -482,8 +549,12 @@ 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 runtime_readiness_js_1.RuntimePrerequisiteError ? error.readiness
                     : (0, runtime_readiness_js_1.classifyRuntimePrerequisite)(agent.adapter.id, error);
@@ -568,6 +639,157 @@ function createRuntimeHost(options) {
         })();
         agent.configurationRecovery = recovery;
     };
+    let recoverContextOverflowInternal;
+    const beginPiManualCompaction = (agent, session, record, nativeWillRetry = false) => {
+        if (agent.adapter.id !== "pi" || !session.compact || !agent.compactionBreaker)
+            return;
+        const existing = agent.compactionMachines.get(record.input.inputId);
+        if (existing) {
+            existing.agentEnd({ exactOverflow: true, willRetry: nativeWillRetry });
+            return;
+        }
+        const key = `${record.deliveryId}:${record.input.inputId}`;
+        const prior = agent.compactionBreaker.get(key);
+        if (prior && prior.manualAttempt >= 1 && ["manual_sent", "manual_ambiguous", "manual_failed", "native_failed"].includes(prior.state)) {
+            agent.busy = false;
+            agent.turnInProgress = false;
+            void recoverContextOverflowInternal(agent.config.agentId, key, "validated Pi compaction breaker state after restart", key)
+                .catch((error) => log("Pi restart fallback failed", String(error)));
+            return;
+        }
+        const machine = new pi_compaction_recovery_js_1.PiCompactionRecoveryMachine({
+            breaker: agent.compactionBreaker, key, messageId: record.messageId, deliveryId: record.deliveryId,
+            inputId: record.input.inputId, sessionGeneration: agent.generation,
+            onAction: (action) => {
+                if (action === "retry_input") {
+                    machine.retrySubmitted();
+                    record.status = "pending";
+                    record.retryable = true;
+                    record.updatedAt = now();
+                    persist(agent);
+                    queueMicrotask(() => { if (!agent.stopped)
+                        void submit(agent, record, false); });
+                }
+                else if (action === "fresh_session_fallback") {
+                    agent.busy = false;
+                    agent.turnInProgress = false;
+                    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;
+                        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));
+                        }
+                    }
+                }
+            },
+        });
+        agent.compactionMachines.set(record.input.inputId, machine);
+        machine.agentEnd({ exactOverflow: true, willRetry: nativeWillRetry });
+        if (nativeWillRetry)
+            return;
+        machine.agentSettled();
+        const deadline = new Date(Date.now() + compactTimeoutMs).toISOString();
+        machine.manualCompactSent(deadline);
+        let compactSettled = false;
+        const compactTimer = setTimeout(() => {
+            if (compactSettled)
+                return;
+            compactSettled = true;
+            machine.compactTimeout();
+        }, compactTimeoutMs);
+        compactTimer.unref?.();
+        void session.compact().then(() => {
+            if (compactSettled)
+                return;
+            compactSettled = true;
+            clearTimeout(compactTimer);
+            machine.compactResponse({ success: true });
+        }).catch((error) => {
+            if (compactSettled)
+                return;
+            compactSettled = true;
+            clearTimeout(compactTimer);
+            const message = error instanceof Error ? error.message : String(error);
+            machine.compactResponse({ success: false, ambiguous: /process exited|process failed|session replaced|protocol/i.test(message) });
+        });
+    };
+    const recoverStalePiCompaction = async (agent) => {
+        if (!agent.stateStore)
+            return;
+        const breaker = agent.compactionBreaker;
+        if (!breaker)
+            return;
+        const stale = breaker.listNonTerminal().find((candidate) => candidate.state !== "native_succeeded");
+        if (!stale) {
+            const succeeded = breaker.listNonTerminal().find((candidate) => candidate.state === "native_succeeded");
+            if (succeeded)
+                breaker.transition(succeeded.key, {}, "closed");
+            return;
+        }
+        const record = [...agent.records.values()].find((candidate) => candidate.deliveryId === stale.deliveryId
+            || candidate.input.inputId === stale.inputId);
+        if (!record)
+            return;
+        const recoveryReason = stale.fallbackReason || "Pi compaction recovery resumed after restart";
+        if (record.errorCategory !== "context_window" || typeof record.reason !== "string")
+            return;
+        record.retryable = false;
+        setRecord(agent, record, "error");
+        breaker.forceFallback(stale.key, recoveryReason);
+        agent.busy = false;
+        agent.turnInProgress = false;
+        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 (!(0, pi_compaction_recovery_js_1.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)
             return; // Ignore late output from a replaced child.
@@ -576,11 +798,38 @@ function createRuntimeHost(options) {
         if (event.type !== "turn-end")
             telemetry?.runtimeEvent(agent.config.agentId, event);
         emit({ type: "runtime", agentId: agent.config.agentId, event });
+        if (event.type === "runtime-observation") {
+            if (event.phase === "compaction_start" && event.reason === "overflow" && event.inputId) {
+                const overflowRecord = [...agent.records.values()].find((candidate) => candidate.input.inputId === event.inputId);
+                if (overflowRecord && !agent.compactionMachines.has(event.inputId))
+                    beginPiManualCompaction(agent, session, overflowRecord, true);
+            }
+            const candidates = [...agent.compactionMachines.values()].filter((machine) => machine.recordSnapshot.sessionGeneration === agent.generation
+                && (!event.inputId || machine.recordSnapshot.inputId === event.inputId));
+            const machines = event.inputId ? candidates : candidates.length === 1 ? candidates : [];
+            for (const machine of machines) {
+                if (event.phase === "compaction_start" && event.reason === "overflow")
+                    machine.compactionStart({ reason: "overflow" });
+                if (event.phase === "compaction_end" && event.reason === "manual") {
+                    machine.compactionEnd({ reason: "manual", success: event.success === true, willRetry: event.willRetry === true });
+                }
+                if (event.phase === "compaction_end" && event.reason === "overflow") {
+                    machine.compactionEnd({ reason: "overflow", success: event.success === true, willRetry: event.willRetry === true });
+                }
+                if (event.phase === "settled")
+                    machine.agentSettled();
+            }
+            if (event.phase === "compaction_end" && event.reason === "overflow" && event.success !== true) {
+                for (const record of agent.records.values()) {
+                    if (isActiveDelivery(record.status))
+                        agent.piOverflowCompactionFailed.add(record.input.inputId);
+                }
+            }
+        }
         if (event.type === "session-init") {
             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;
@@ -591,6 +840,13 @@ function createRuntimeHost(options) {
             emit({ type: "activity", agentId: agent.config.agentId, activity: "working", activityKind: "working", detailKind: "turn_started" });
         }
         else if (event.type === "turn-end") {
+            for (const [inputId, machine] of agent.compactionMachines) {
+                if (machine.recordSnapshot.sessionGeneration !== agent.generation)
+                    continue;
+                machine.close();
+                if (["closed", "fallback_committed"].includes(machine.state))
+                    agent.compactionMachines.delete(inputId);
+            }
             const recoveredAuthentication = agent.authFailureActive && agent.turnInProgress
                 && agent.turnHadAuthenticatedOutput && !agent.turnHadFailure;
             agent.turnInProgress = false;
@@ -609,7 +865,11 @@ 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")
@@ -623,6 +883,34 @@ function createRuntimeHost(options) {
             if (!record || record.status === "consumed" || record.status === "error")
                 return;
             agent.turnHadFailure = true;
+            if (agent.adapter.id === "pi" && event.errorCategory === "context_window" && event.willRetry === true && session.compact) {
+                beginPiManualCompaction(agent, session, record, true);
+                return;
+            }
+            if (agent.adapter.id === "pi" && event.errorCategory === "context_window" && event.willRetry !== true && session.compact) {
+                record.reason = event.message;
+                record.retryable = false;
+                record.errorCategory = "context_window";
+                setRecord(agent, record, "error");
+                if (agent.piOverflowCompactionFailed.has(record.input.inputId)) {
+                    agent.busy = false;
+                    agent.turnInProgress = false;
+                    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
+                // normal turn reservation before the one authorized recovery action.
+                agent.busy = false;
+                agent.turnInProgress = false;
+                beginPiManualCompaction(agent, session, record);
+                return;
+            }
             if (event.willRetry) {
                 emit({ type: "delivery", agentId: agent.config.agentId, deliveryId: record.deliveryId,
                     messageId: record.messageId, status: "deferred", reason: event.message });
@@ -633,6 +921,13 @@ function createRuntimeHost(options) {
                 agent.busy = false;
             record.reason = event.message;
             record.retryable = event.retryable;
+            const classifiedCategory = event.errorCategory ?? (0, provider_error_classifier_js_1.classifyStrictProviderError)((0, provider_error_classifier_js_1.buildStrictProviderErrorInput)({
+                message: event.message, errorCategory: event.errorCategory, upstream: event.upstream,
+            }));
+            if (classifiedCategory)
+                record.errorCategory = classifiedCategory;
+            else
+                delete record.errorCategory;
             const finalRecord = setRecord(agent, record, event.retryable ? "pending" : "error");
             if (finalRecord.status !== "consumed")
                 emit({ type: "delivery", agentId: agent.config.agentId,
@@ -719,6 +1014,132 @@ function createRuntimeHost(options) {
         });
         return agent.starting;
     };
+    recoverContextOverflowInternal = async (agentId, deliveryKey, reason, breakerKey) => {
+        const agent = managed.get(agentId);
+        if (!agent || agent.stopped)
+            throw new RuntimeSessionRecoveryError("unknown_agent", `unknown runtime Agent: ${agentId}`);
+        if (agent.adapter.id !== "pi")
+            throw new RuntimeSessionRecoveryError("recovery_unavailable", "Pi context fallback is unavailable for this runtime");
+        const oldSession = agent.session;
+        if (!oldSession || agent.busy || agent.submitting || agent.starting) {
+            throw new RuntimeSessionRecoveryError("agent_busy", `Agent ${agentId} is not idle for Pi context fallback`);
+        }
+        const record = [...agent.records.values()].find((candidate) => candidate.deliveryId === deliveryKey || candidate.input.inputId === deliveryKey || `${candidate.deliveryId}:${candidate.input.inputId}` === deliveryKey);
+        if (!record)
+            throw new RuntimeSessionRecoveryError("recovery_refused", "Pi context fallback delivery identity is unavailable");
+        const probeEnv = runtimeEnv(agent.config, `${agent.launchId}:pi-context-fallback`);
+        await assertOfficialCliReady(agent.config, probeEnv);
+        const readiness = agent.adapter.probe ? await agent.adapter.probe({ agentId: agent.config.agentId,
+            workspaceDir: agent.config.workspaceDir, stateDir: agent.config.stateDir, env: probeEnv }) : { runtime: "pi", state: "ready" };
+        if (readiness.state !== "ready")
+            throw new RuntimeSessionRecoveryError("recovery_staged_not_committed", "Pi context fallback readiness failed");
+        const standingPrompt = options.promptBuilder.build({
+            agentId: agent.config.agentId, name: agent.config.displayName || agent.config.name,
+            description: agent.config.description || "", runtime: agent.adapter.id, cli: (0, agent_cli_capabilities_js_1.agentCliPromptCapabilities)("larkin"),
+        });
+        let fresh;
+        try {
+            fresh = await agent.adapter.createSession({ agentId: agent.config.agentId, model: agent.config.model,
+                reasoningEffort: agent.config.effort || null, workspaceDir: agent.config.workspaceDir, stateDir: agent.config.stateDir,
+                resumeSessionId: null, standingPrompt, env: probeEnv });
+        }
+        catch {
+            throw new RuntimeSessionRecoveryError("recovery_staged_not_committed", "Pi fresh fallback session could not be staged");
+        }
+        if (agent.session !== oldSession || agent.busy || agent.submitting || agent.starting || agent.stopped) {
+            await fresh.close("Pi context fallback commit precondition changed").catch(() => { });
+            throw new RuntimeSessionRecoveryError("agent_busy", `Agent ${agentId} changed during Pi context fallback`);
+        }
+        let unsubscribeFresh = null;
+        try {
+            unsubscribeFresh = fresh.subscribe((next) => observe(agent, fresh, next));
+        }
+        catch {
+            await fresh.close("Pi context fallback subscription failed").catch(() => { });
+            throw new RuntimeSessionRecoveryError("recovery_staged_not_committed", "Pi context fallback subscription failed");
+        }
+        const oldSessionId = oldSession.sessionId;
+        const oldGeneration = agent.generation;
+        const oldLaunchId = agent.launchId;
+        const oldConfigSessionId = agent.config.sessionId;
+        const oldReadiness = agent.readiness;
+        const oldDisabledReason = agent.disabledReason;
+        const oldRecord = { ...record, input: { ...record.input } };
+        let durableRollback = null;
+        let rearmedCount = 1;
+        let remainingPendingCount = 1;
+        const commitSwap = (messageIds, rollback) => {
+            if (agent.session !== oldSession || agent.busy || agent.submitting || agent.starting || agent.stopped) {
+                throw new RuntimeSessionRecoveryError("agent_busy", `Agent ${agentId} changed during Pi context fallback`);
+            }
+            durableRollback = rollback ?? null;
+            if (breakerKey && agent.compactionBreaker)
+                agent.compactionBreaker.forceFallbackInTransaction(breakerKey, reason);
+            agent.generation += 1;
+            agent.launchId = node_crypto_1.default.randomUUID();
+            agent.config.sessionId = null;
+            agent.session = fresh;
+            agent.readiness = readiness;
+            agent.disabledReason = null;
+            for (const candidate of agent.records.values()) {
+                if (!messageIds.includes(candidate.messageId))
+                    continue;
+                candidate.status = "pending";
+                candidate.retryable = true;
+                candidate.updatedAt = now();
+            }
+        };
+        try {
+            if (agent.stateStore?.rearmContextOverflow) {
+                const rearmed = agent.stateStore.rearmContextOverflow((messageIds, rollback) => commitSwap(messageIds, rollback), {
+                    messageId: record.messageId, deliveryId: record.deliveryId, inputId: record.input.inputId,
+                });
+                rearmedCount = rearmed.rearmedCount;
+                remainingPendingCount = rearmed.remainingPendingCount;
+            }
+            else {
+                commitSwap([record.messageId]);
+                persist(agent);
+            }
+        }
+        catch (error) {
+            try {
+                const rollback = durableRollback;
+                if (rollback)
+                    rollback();
+            }
+            catch { /* preserve primary error */ }
+            agent.generation = oldGeneration;
+            agent.launchId = oldLaunchId;
+            agent.config.sessionId = oldConfigSessionId;
+            agent.session = oldSession;
+            agent.readiness = oldReadiness;
+            agent.disabledReason = oldDisabledReason;
+            Object.assign(record, oldRecord);
+            try {
+                unsubscribeFresh?.();
+            }
+            catch { /* preserve primary failure */ }
+            await fresh.close("Pi context fallback rolled back").catch(() => { });
+            throw new RuntimeSessionRecoveryError("recovery_staged_not_committed", error instanceof Error ? error.message : "Pi context fallback commit failed");
+        }
+        if (fresh.sessionId) {
+            agent.config.sessionId = fresh.sessionId;
+            emit({ type: "session", agentId, runtime: agent.adapter.id, sessionId: fresh.sessionId, launchId: agent.launchId,
+                ...(fresh.effectiveModel ? { model: fresh.effectiveModel } : {}),
+                ...(fresh.effectiveReasoningEffort ? { reasoningEffort: fresh.effectiveReasoningEffort } : {}) });
+        }
+        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)));
+        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 };
+    };
     return {
         async probe(config) {
             const adapter = options.adapterFor(config.runtime);
@@ -893,6 +1314,183 @@ function createRuntimeHost(options) {
             return { generationChanged: true, sessionChanged: oldSessionId !== fresh.sessionId, turns: 0,
                 runtimeReady: true, pendingCount: 0, sessionId: fresh.sessionId };
         },
+        async recoverSession(agentId, reason) {
+            if (reason !== "context-overflow")
+                throw new RuntimeSessionRecoveryError("recovery_refused", "unsupported recovery reason");
+            const agent = managed.get(agentId);
+            if (agent && agent.adapter.id !== "pi")
+                throw new RuntimeSessionRecoveryError("recovery_unavailable", "context-overflow recovery is available only for Pi Runtime");
+            if (!agent || agent.stopped)
+                throw new RuntimeSessionRecoveryError("unknown_agent", `unknown runtime Agent: ${agentId}`);
+            if (!agent.stateStore?.rearmContextOverflow) {
+                throw new RuntimeSessionRecoveryError("recovery_unavailable", "canonical Inbox recovery is unavailable");
+            }
+            if (agent.busy || agent.turnInProgress || agent.submitting || agent.starting) {
+                throw new RuntimeSessionRecoveryError("agent_busy", `Agent ${agentId} is not idle`);
+            }
+            const oldSession = agent.session;
+            if (!oldSession)
+                throw new RuntimeSessionRecoveryError("agent_busy", `Agent ${agentId} Runtime session is unavailable`);
+            const oldSessionId = oldSession.sessionId;
+            if (agent.stateStore.readNdjson) {
+                const pendingRows = agent.stateStore.withInboxTransaction(() => agent.stateStore.readNdjson("inbox"));
+                if (pendingRows.length === 0) {
+                    throw new RuntimeSessionRecoveryError("recovery_refused", "context-window recovery has no retained Inbox backlog");
+                }
+                const messageIds = new Set(pendingRows.flatMap((row) => {
+                    const messageId = row && typeof row === "object" && !Array.isArray(row)
+                        ? row.message_id : undefined;
+                    return typeof messageId === "string" && messageId ? [messageId] : [];
+                }));
+                const persisted = agent.stateStore.readJson("runtimeDeliveries", { version: 1, records: [] });
+                if (Array.isArray(persisted.records) && persisted.records.some((record) => messageIds.has(record.messageId) && record.status !== "error")) {
+                    throw new RuntimeSessionRecoveryError("recovery_refused", "context-window recovery is already staged or completed");
+                }
+            }
+            const probeEnv = runtimeEnv(agent.config, `${agent.launchId}:context-overflow-recovery`);
+            let readiness;
+            try {
+                await assertOfficialCliReady(agent.config, probeEnv);
+                readiness = agent.adapter.probe ? await agent.adapter.probe({ agentId: agent.config.agentId,
+                    workspaceDir: agent.config.workspaceDir, stateDir: agent.config.stateDir,
+                    env: { LARKIN_PI_COMMAND: process.env.LARKIN_PI_COMMAND, LARKIN_CODEX_COMMAND: process.env.LARKIN_CODEX_COMMAND,
+                        LARKIN_CLAUDE_COMMAND: process.env.LARKIN_CLAUDE_COMMAND, ...probeEnv } })
+                    : { runtime: agent.adapter.id, state: "ready" };
+            }
+            catch (error) {
+                if (error instanceof runtime_readiness_js_1.RuntimePrerequisiteError)
+                    throw error;
+                throw new RuntimeSessionRecoveryError("recovery_staged_not_committed", "Runtime readiness probe failed");
+            }
+            if (readiness.state !== "ready")
+                throw new runtime_readiness_js_1.RuntimePrerequisiteError(readiness);
+            const standingPrompt = options.promptBuilder.build({
+                agentId: agent.config.agentId, name: agent.config.displayName || agent.config.name,
+                description: agent.config.description || "", runtime: agent.adapter.id,
+                cli: (0, agent_cli_capabilities_js_1.agentCliPromptCapabilities)("larkin"),
+            });
+            let fresh;
+            try {
+                fresh = await agent.adapter.createSession({
+                    agentId: agent.config.agentId, model: agent.config.model, reasoningEffort: agent.config.effort || null,
+                    workspaceDir: agent.config.workspaceDir, stateDir: agent.config.stateDir,
+                    resumeSessionId: null, standingPrompt, env: probeEnv,
+                });
+            }
+            catch {
+                throw new RuntimeSessionRecoveryError("recovery_staged_not_committed", "fresh Runtime session could not be staged");
+            }
+            let unsubscribeFresh = null;
+            try {
+                unsubscribeFresh = fresh.subscribe((event) => observe(agent, fresh, event));
+            }
+            catch {
+                await fresh.close("context-window recovery subscription failed").catch(() => { });
+                throw new RuntimeSessionRecoveryError("recovery_staged_not_committed", "fresh Runtime session subscription failed");
+            }
+            const oldGeneration = agent.generation;
+            const oldLaunchId = agent.launchId;
+            const oldConfigSessionId = agent.config.sessionId;
+            const oldReadiness = agent.readiness;
+            const oldDisabledReason = agent.disabledReason;
+            const oldRecords = new Map([...agent.records.entries()].map(([id, record]) => [id, { ...record, input: { ...record.input } }]));
+            const cleanupFresh = async (reason) => {
+                const unsubscribe = unsubscribeFresh;
+                unsubscribeFresh = null;
+                try {
+                    unsubscribe?.();
+                }
+                catch { /* close still owns staged-session cleanup */ }
+                await fresh.close(reason).catch(() => { });
+            };
+            const restoreRuntime = () => {
+                agent.session = oldSession;
+                agent.generation = oldGeneration;
+                agent.launchId = oldLaunchId;
+                agent.config.sessionId = oldConfigSessionId;
+                agent.readiness = oldReadiness;
+                agent.disabledReason = oldDisabledReason;
+                agent.records = new Map(oldRecords);
+                agent.byMessage = new Map([...oldRecords.values()].map((record) => [record.messageId, record.deliveryId]));
+            };
+            let recoveryProjectionEmitted = false;
+            const compensateProjection = () => {
+                if (!recoveryProjectionEmitted)
+                    return;
+                try {
+                    emit({ type: "session", agentId, runtime: agent.adapter.id, sessionId: oldSessionId, launchId: oldLaunchId });
+                }
+                catch { /* preserve the original listener failure */ }
+                try {
+                    emit({ type: "agent-status", agentId, status: "active", ...(oldReadiness ? { readiness: oldReadiness } : {}) });
+                }
+                catch { /* preserve the original listener failure */ }
+            };
+            let durableRollback = null;
+            try {
+                const rearmed = agent.stateStore.rearmContextOverflow((messageIds, rollback) => {
+                    // This callback runs under the canonical Inbox lock. All potentially
+                    // racing checks above are synchronous from this process, while the
+                    // state-store method rechecks every row and delivery on disk.
+                    if (agent.session !== oldSession || agent.busy || agent.turnInProgress || agent.submitting || agent.starting || agent.stopped) {
+                        throw new RuntimeSessionRecoveryError("agent_busy", `Agent ${agentId} changed during recovery`);
+                    }
+                    durableRollback = rollback;
+                    agent.generation += 1;
+                    agent.launchId = node_crypto_1.default.randomUUID();
+                    agent.config.sessionId = null;
+                    agent.session = fresh;
+                    agent.readiness = readiness;
+                    agent.disabledReason = null;
+                    for (const record of agent.records.values()) {
+                        if (!messageIds.includes(record.messageId))
+                            continue;
+                        record.status = "pending";
+                        record.retryable = true;
+                        record.updatedAt = now();
+                    }
+                });
+                recoveryProjectionEmitted = true;
+                if (fresh.sessionId) {
+                    agent.config.sessionId = fresh.sessionId;
+                    emit({ type: "session", agentId, runtime: agent.adapter.id, sessionId: fresh.sessionId, launchId: agent.launchId,
+                        ...(fresh.effectiveModel ? { model: fresh.effectiveModel } : {}),
+                        ...(fresh.effectiveReasoningEffort ? { reasoningEffort: fresh.effectiveReasoningEffort } : {}) });
+                }
+                emit({ type: "agent-status", agentId, status: "active", readiness });
+                durableRollback = null;
+                await oldSession.close("context-window recovery committed")
+                    .catch((error) => log("previous runtime close after context-window recovery failed", String(error)));
+                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 };
+            }
+            catch (error) {
+                try {
+                    const rollback = durableRollback;
+                    if (rollback)
+                        rollback();
+                }
+                catch { /* preserve the original failure */ }
+                restoreRuntime();
+                compensateProjection();
+                await cleanupFresh("context-window recovery not committed");
+                if (error instanceof RuntimeSessionRecoveryError)
+                    throw error;
+                if (typeof error.code === "string") {
+                    throw new RuntimeSessionRecoveryError("recovery_refused", error instanceof Error ? error.message : "context-window recovery was refused");
+                }
+                throw new RuntimeSessionRecoveryError("recovery_staged_not_committed", "context-window recovery was not committed");
+            }
+        },
+        async recoverContextOverflow(agentId, deliveryKey, reason) {
+            return recoverContextOverflowInternal(agentId, deliveryKey, reason);
+        },
         async start(configs) {
             let activeCount = 0;
             let recoveringCount = 0;
@@ -935,11 +1533,19 @@ function createRuntimeHost(options) {
                     : readDeliveryFile(config.stateDir ? node_path_1.default.join(config.stateDir, "runtime-deliveries.json") : null);
                 const agent = { config, adapter: options.adapterFor(config.runtime), session: null,
                     launchId: node_crypto_1.default.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, readiness: null,
+                    configurationRecovery: null, stateStore,
+                    compactionBreaker: config.runtime === "pi" && stateStore
+                        ? new pi_compaction_recovery_js_1.PiCompactionBreaker(config.stateDir ?? node_path_1.default.join(config.workspaceDir, ".larkin", "agents", config.agentId), {
+                            withLock: (operation) => stateStore.withInboxTransaction(operation),
+                        }) : undefined,
+                    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 = [];
@@ -971,8 +1577,13 @@ function createRuntimeHost(options) {
                 emitConsumed(agent, [...startupConsumed, ...persist(agent)]);
                 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);