larkin 0.5.4 → 0.5.5

package/dist/runtime/runtime-host.cjs

@@ -17,7 +17,7 @@ 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");
-const pi_subagent_ledger_js_1 = require("./pi-subagent-ledger.cjs");
+const pi_state_dir_js_1 = require("./pi-state-dir.cjs");
 class RuntimeSessionResetError extends Error {
     code;
     pendingCount;
@@ -41,8 +41,6 @@ class RuntimeSessionRecoveryError extends Error {
 }
 exports.RuntimeSessionRecoveryError = RuntimeSessionRecoveryError;
 const MAX_DELIVERIES = 2048;
-const BACKGROUND_COMPLETION_IMMEDIATE_RETRY_LIMIT = 5;
-const DEFAULT_SUBAGENT_RECONCILE_INTERVAL_MS = 15_000;
 const now = () => new Date().toISOString();
 const isActiveDelivery = (status) => ["pending", "submitting", "accepted"].includes(status);
 const previousSessionRefFor = (session, reason) => session.sessionId
@@ -310,10 +308,6 @@ function createRuntimeHost(options) {
         maxAttempts: options.retryPolicy?.maxAttempts ?? 6,
         stableWindowMs: options.retryPolicy?.stableWindowMs ?? 30_000,
     };
-    const subagentReconcileIntervalMs = options.subagentReconcileIntervalMs ?? DEFAULT_SUBAGENT_RECONCILE_INTERVAL_MS;
-    if (!Number.isFinite(subagentReconcileIntervalMs) || subagentReconcileIntervalMs < 0) {
-        throw new Error("subagentReconcileIntervalMs must be >= 0");
-    }
     const emit = (event) => {
         if (event.type === "delivery")
             telemetry?.delivery(event.agentId, event.messageId, event.status);
@@ -325,11 +319,10 @@ function createRuntimeHost(options) {
             LARKIN_AGENT_ID: config.agentId,
             ...(generation ? {
                 LARKIN_RUNTIME_OBSERVATION_GENERATION: generation,
-                [pi_subagent_ledger_js_1.PI_SUBAGENT_SESSION_OWNER_ENV]: generation,
             } : {}),
             LARKIN_CONFIG_DIR: process.env.LARKIN_CONFIG_DIR,
             LARKIN_HOME: process.env.LARKIN_HOME,
-            LARKIN_STATE_DIR: (0, pi_subagent_ledger_js_1.effectivePiStateDir)(config),
+            LARKIN_STATE_DIR: (0, pi_state_dir_js_1.effectivePiStateDir)(config),
             ...(process.env.HOME ? { HOME: process.env.HOME } : {}),
             ...(process.env.SHELL ? { SHELL: process.env.SHELL } : {}),
             ...(process.env.ZDOTDIR ? { ZDOTDIR: process.env.ZDOTDIR } : {}),
@@ -726,12 +719,6 @@ function createRuntimeHost(options) {
                 queueMicrotask(() => { void retryPending(agent); });
             }
             queueMicrotask(() => { void scanAndPromoteAcceptedInboxUpdates(agent); });
-            // A completion queued during this submit has no turn-end if prompt
-            // rejected/threw before turn-start. Drain now that submitting is clear.
-            if (!agent.busy && !agent.turnInProgress && agent.backgroundCompletionQueue.length > 0
-                && !agent.backgroundCompletionRetryTimer) {
-                scheduleBackgroundCompletionDrain(agent);
-            }
         }
     };
     const retryPending = async (agent) => {
@@ -808,326 +795,6 @@ function createRuntimeHost(options) {
             agent.retryAfterSubmit = true;
         await retryPending(agent);
     };
-    const clearBackgroundCompletionRetryTimer = (agent) => {
-        if (!agent.backgroundCompletionRetryTimer)
-            return;
-        clearTimeout(agent.backgroundCompletionRetryTimer);
-        agent.backgroundCompletionRetryTimer = null;
-    };
-    const scheduleBackgroundCompletionDrain = (agent, delayMs = 0) => {
-        if (agent.stopped)
-            return;
-        if (delayMs > 0) {
-            if (agent.backgroundCompletionRetryTimer)
-                return;
-            agent.backgroundCompletionRetryTimer = setTimeout(() => {
-                agent.backgroundCompletionRetryTimer = null;
-                if (agent.stopped)
-                    return;
-                void drainBackgroundCompletionQueue(agent);
-            }, delayMs);
-            agent.backgroundCompletionRetryTimer.unref?.();
-            return;
-        }
-        clearBackgroundCompletionRetryTimer(agent);
-        queueMicrotask(() => { void drainBackgroundCompletionQueue(agent); });
-    };
-    const dropBackgroundCompletion = (agent, completionKey) => {
-        if (!completionKey)
-            return;
-        if (agent.backgroundCompletionQueue[0] === completionKey)
-            agent.backgroundCompletionQueue.shift();
-        else {
-            const index = agent.backgroundCompletionQueue.indexOf(completionKey);
-            if (index >= 0)
-                agent.backgroundCompletionQueue.splice(index, 1);
-        }
-        agent.backgroundCompletionKeys.add(completionKey);
-        if (agent.backgroundCompletionInFlight === completionKey) {
-            agent.backgroundCompletionInFlight = null;
-            agent.backgroundCompletionWakeInputId = null;
-        }
-        agent.backgroundCompletionRejectStreak = 0;
-        clearBackgroundCompletionRetryTimer(agent);
-        // Leave the durable wake pending so a later restart can requeue it.
-    };
-    const scheduleBackgroundCompletionRetry = (agent) => {
-        const streak = agent.backgroundCompletionRejectStreak;
-        if (streak < BACKGROUND_COMPLETION_IMMEDIATE_RETRY_LIMIT) {
-            scheduleBackgroundCompletionDrain(agent);
-            return;
-        }
-        const delayedAttempt = streak - BACKGROUND_COMPLETION_IMMEDIATE_RETRY_LIMIT;
-        if (delayedAttempt >= retryPolicy.maxAttempts) {
-            const exhausted = agent.backgroundCompletionQueue[0];
-            if (exhausted) {
-                log("background completion wake retries exhausted", exhausted);
-                dropBackgroundCompletion(agent, exhausted);
-            }
-            if (agent.backgroundCompletionQueue.length > 0)
-                scheduleBackgroundCompletionDrain(agent);
-            return;
-        }
-        const delay = Math.min(retryPolicy.maxDelayMs, retryPolicy.baseDelayMs * 2 ** delayedAttempt);
-        scheduleBackgroundCompletionDrain(agent, delay);
-    };
-    const isPersistentBackgroundWakeFailure = (event) => {
-        if (!event)
-            return false;
-        const category = event.errorCategory;
-        if (category === "auth" || category === "billing" || category === "quota")
-            return true;
-        return category === "provider" && event.retryable === false;
-    };
-    const failBackgroundCompletionWake = (agent, event) => {
-        const completionKey = agent.backgroundCompletionInFlight ?? agent.backgroundCompletionQueue[0];
-        if (!completionKey)
-            return;
-        rearmBackgroundCompletion(agent, completionKey);
-        if (isPersistentBackgroundWakeFailure(event)) {
-            log("background completion wake dropped", event?.errorCategory ?? "persistent");
-            dropBackgroundCompletion(agent, completionKey);
-            if (agent.backgroundCompletionQueue.length > 0)
-                scheduleBackgroundCompletionDrain(agent);
-            return;
-        }
-        agent.backgroundCompletionRejectStreak += 1;
-        scheduleBackgroundCompletionRetry(agent);
-    };
-    const rearmBackgroundCompletion = (agent, completionKey = agent.backgroundCompletionInFlight) => {
-        if (!completionKey)
-            return;
-        agent.backgroundCompletionKeys.delete(completionKey);
-        if (agent.backgroundCompletionInFlight === completionKey) {
-            agent.backgroundCompletionInFlight = null;
-            agent.backgroundCompletionWakeInputId = null;
-        }
-        if (!agent.backgroundCompletionQueue.includes(completionKey)) {
-            agent.backgroundCompletionQueue.unshift(completionKey);
-        }
-    };
-    const commitBackgroundCompletion = (agent) => {
-        const completionKey = agent.backgroundCompletionInFlight;
-        if (!completionKey)
-            return;
-        if (agent.backgroundCompletionQueue[0] === completionKey)
-            agent.backgroundCompletionQueue.shift();
-        agent.backgroundCompletionInFlight = null;
-        agent.backgroundCompletionWakeInputId = null;
-        agent.backgroundCompletionRejectStreak = 0;
-        clearBackgroundCompletionRetryTimer(agent);
-        acknowledgeSubagentWake(agent, completionKey);
-    };
-    const wakeOnBackgroundCompletion = async (agent) => {
-        // Caller already reserved submitting/busy so a concurrent idle drain cannot
-        // dequeue another head while ensureSession/prompt yields.
-        try {
-            const session = await ensureSession(agent);
-            if (agent.session !== session || agent.stopped)
-                return { status: "dropped" };
-            const headKey = agent.backgroundCompletionQueue[0];
-            const tasks = (0, pi_subagent_ledger_js_1.taskIdsFromCompletionKey)(headKey ?? "")
-                .map((taskId) => (0, pi_subagent_ledger_js_1.getDispatchedSubagent)(agent.subagentLedger, taskId))
-                .filter((task) => Boolean(task));
-            const details = tasks.map((task) => `task ${task.taskId} status=${task.status}`).join("; ");
-            const wakeReason = details
-                ? `background subagent completed; ${details}`
-                : "background subagent completed";
-            const input = options.promptBuilder.buildRuntimeInput("wake", node_crypto_1.default.randomUUID(), { wakeReason });
-            const result = await session.prompt(input);
-            if (agent.session !== session || agent.stopped)
-                return { status: "dropped" };
-            if (result.status === "accepted") {
-                markSessionStable(agent, session);
-                return { status: "accepted", inputId: input.inputId };
-            }
-            agent.busy = false;
-            return { status: "retry" };
-        }
-        catch (error) {
-            agent.busy = false;
-            log("background completion wake failed", error instanceof Error ? error.message : String(error));
-            return { status: "retry" };
-        }
-    };
-    const drainBackgroundCompletionQueue = async (agent) => {
-        if (agent.stopped || agent.busy || agent.turnInProgress || agent.submitting)
-            return;
-        if (agent.backgroundCompletionInFlight || !agent.backgroundCompletionQueue.length)
-            return;
-        clearBackgroundCompletionRetryTimer(agent);
-        const proactive = agent.piProactiveCompaction
-            && agent.piProactiveCompactionGeneration === agent.generation
-            && agent.piProactiveCompactionSession === agent.session
-            ? agent.piProactiveCompaction : null;
-        if (proactive)
-            await proactive;
-        if (agent.adapter.id === "pi" && !agent.busy && !agent.turnInProgress && agent.session) {
-            const idleGate = proactivelyCompactPiAtIdle(agent, agent.session);
-            if (idleGate)
-                await idleGate;
-        }
-        if (agent.stopped || agent.busy || agent.turnInProgress || agent.submitting)
-            return;
-        if (agent.backgroundCompletionInFlight || !agent.backgroundCompletionQueue.length)
-            return;
-        agent.submitting = true;
-        agent.busy = true;
-        const completionKey = agent.backgroundCompletionQueue[0];
-        try {
-            const outcome = await wakeOnBackgroundCompletion(agent);
-            if (outcome.status === "accepted") {
-                agent.backgroundCompletionKeys.add(completionKey);
-                agent.backgroundCompletionInFlight = completionKey;
-                agent.backgroundCompletionWakeInputId = outcome.inputId;
-                // Keep the reject streak until the wake turn actually succeeds. An accepted
-                // prompt that later terminal-fails must not reset the bounded retry budget.
-                clearBackgroundCompletionRetryTimer(agent);
-            }
-            else if (outcome.status === "dropped") {
-                if (agent.stopped) {
-                    if (agent.backgroundCompletionQueue[0] === completionKey)
-                        agent.backgroundCompletionQueue.shift();
-                    agent.backgroundCompletionKeys.delete(completionKey);
-                    clearBackgroundCompletionRetryTimer(agent);
-                }
-                else {
-                    rearmBackgroundCompletion(agent, completionKey);
-                    agent.busy = false;
-                }
-            }
-            else {
-                agent.busy = false;
-                agent.backgroundCompletionRejectStreak += 1;
-                // Leave the item queued+deduped. Immediate microtask retries cover a
-                // brief reject; after that a bounded timer still drains because Pi will
-                // not re-emit the same completion.
-                scheduleBackgroundCompletionRetry(agent);
-            }
-        }
-        finally {
-            agent.submitting = false;
-        }
-    };
-    const persistSubagentLedger = (agent) => {
-        (0, pi_subagent_ledger_js_1.writeDispatchedSubagentLedger)((0, pi_subagent_ledger_js_1.ledgerFilePath)((0, pi_subagent_ledger_js_1.effectivePiStateDir)(agent.config)), agent.subagentLedger);
-    };
-    const dropQueuedBackgroundCompletionFallback = (agent, completionKey) => {
-        const keys = new Set([completionKey, ...(0, pi_subagent_ledger_js_1.taskIdsFromCompletionKey)(completionKey)]);
-        for (let index = agent.backgroundCompletionQueue.length - 1; index >= 0; index -= 1) {
-            const queued = agent.backgroundCompletionQueue[index];
-            if (queued && keys.has(queued))
-                agent.backgroundCompletionQueue.splice(index, 1);
-        }
-        for (const key of keys)
-            agent.backgroundCompletionKeys.add(key);
-    };
-    const acknowledgeSubagentWake = (agent, completionKey) => {
-        const next = (0, pi_subagent_ledger_js_1.noteDispatchedSubagentWakeAcknowledged)(agent.subagentLedger, { completionKey });
-        if (next === agent.subagentLedger)
-            return;
-        agent.subagentLedger = next;
-        persistSubagentLedger(agent);
-        for (const taskId of (0, pi_subagent_ledger_js_1.taskIdsFromCompletionKey)(completionKey)) {
-            (0, pi_subagent_ledger_js_1.retirePiSubagentRecord)((0, pi_subagent_ledger_js_1.getDispatchedSubagent)(agent.subagentLedger, taskId)?.recordFile);
-        }
-    };
-    const enqueueUndeliveredTerminalWakes = (agent) => {
-        for (const key of (0, pi_subagent_ledger_js_1.undeliveredTerminalWakeKeys)(agent.subagentLedger)) {
-            agent.backgroundCompletionKeys.delete(key);
-            for (const taskId of (0, pi_subagent_ledger_js_1.taskIdsFromCompletionKey)(key))
-                agent.backgroundCompletionKeys.delete(taskId);
-            noteBackgroundCompletion(agent, key);
-        }
-    };
-    const reconcileAfterSessionSwap = (agent) => {
-        reconcileSubagentLedger(agent, { forceMissing: true, missingReason: "pi session gone" });
-        enqueueUndeliveredTerminalWakes(agent);
-        if (agent.backgroundCompletionQueue.length > 0)
-            scheduleBackgroundCompletionDrain(agent);
-    };
-    const loadSubagentLedger = (config) => {
-        return (0, pi_subagent_ledger_js_1.readDispatchedSubagentLedger)((0, pi_subagent_ledger_js_1.ledgerFilePath)((0, pi_subagent_ledger_js_1.effectivePiStateDir)(config)));
-    };
-    const clearSubagentReconcileTimer = (agent) => {
-        if (!agent.subagentReconcileTimer)
-            return;
-        clearInterval(agent.subagentReconcileTimer);
-        agent.subagentReconcileTimer = null;
-    };
-    const hasActiveDispatchedSubagent = (agent) => agent.subagentLedger.tasks.some((task) => task.status === "dispatched");
-    const noteBackgroundCompletion = (agent, completionKey) => {
-        const taskIds = (0, pi_subagent_ledger_js_1.taskIdsFromCompletionKey)(completionKey);
-        if (agent.backgroundCompletionKeys.has(completionKey))
-            return;
-        if (taskIds.length > 0 && taskIds.every((taskId) => agent.backgroundCompletionKeys.has(taskId)))
-            return;
-        agent.backgroundCompletionKeys.add(completionKey);
-        for (const taskId of taskIds)
-            agent.backgroundCompletionKeys.add(taskId);
-        if (!agent.backgroundCompletionQueue.includes(completionKey)) {
-            agent.backgroundCompletionQueue.push(completionKey);
-        }
-        if (!agent.busy && !agent.turnInProgress && !agent.submitting && !agent.backgroundCompletionInFlight) {
-            scheduleBackgroundCompletionDrain(agent);
-        }
-    };
-    const recordDispatchedSubagent = (agent, taskId, outputFile) => {
-        const recordFile = (0, pi_subagent_ledger_js_1.writeDispatchedSubagentRecordFile)((0, pi_subagent_ledger_js_1.effectivePiStateDir)(agent.config), taskId, agent.piSessionOwner);
-        agent.subagentLedger = (0, pi_subagent_ledger_js_1.noteDispatchedSubagent)(agent.subagentLedger, { taskId, outputFile, recordFile });
-        persistSubagentLedger(agent);
-        armSubagentReconcileTimer(agent);
-    };
-    const recordTerminalSubagentNotification = (agent, completionKey, statuses) => {
-        let next = agent.subagentLedger;
-        for (const taskId of (0, pi_subagent_ledger_js_1.taskIdsFromCompletionKey)(completionKey)) {
-            const status = statuses?.[taskId];
-            next = (0, pi_subagent_ledger_js_1.noteDispatchedSubagentTerminal)(next, {
-                taskId,
-                status: status && status !== "dispatched" && status !== "orphaned" ? status : "completed",
-                wakeKey: completionKey,
-            });
-        }
-        agent.subagentLedger = next;
-        persistSubagentLedger(agent);
-        if (!hasActiveDispatchedSubagent(agent))
-            clearSubagentReconcileTimer(agent);
-    };
-    const reconcileSubagentLedger = (agent, input = {}) => {
-        if (agent.stopped)
-            return;
-        const result = (0, pi_subagent_ledger_js_1.reconcileDispatchedSubagents)(agent.subagentLedger, {
-            probe: options.subagentRecordProbe ?? pi_subagent_ledger_js_1.probePiSubagentRecord,
-            forceMissing: input.forceMissing === true,
-            missingReason: input.missingReason,
-        });
-        const previousLedger = agent.subagentLedger;
-        agent.subagentLedger = result.ledger;
-        if (result.orphaned.length > 0 || result.terminals.length > 0 || result.ledger !== previousLedger) {
-            persistSubagentLedger(agent);
-        }
-        for (const record of [...result.orphaned, ...result.terminals]) {
-            noteBackgroundCompletion(agent, record.wakeKey ?? record.taskId);
-        }
-        if (!hasActiveDispatchedSubagent(agent))
-            clearSubagentReconcileTimer(agent);
-        else
-            armSubagentReconcileTimer(agent);
-    };
-    const armSubagentReconcileTimer = (agent) => {
-        if (agent.stopped || agent.subagentReconcileTimer || subagentReconcileIntervalMs === 0)
-            return;
-        if (!hasActiveDispatchedSubagent(agent))
-            return;
-        agent.subagentReconcileTimer = setInterval(() => {
-            if (agent.stopped) {
-                clearSubagentReconcileTimer(agent);
-                return;
-            }
-            reconcileSubagentLedger(agent);
-        }, subagentReconcileIntervalMs);
-        agent.subagentReconcileTimer.unref?.();
-    };
     const scheduleRecreate = (agent, reason) => {
         if (agent.stopped || agent.retryTimer || agent.starting || agent.session)
             return;
@@ -1149,11 +816,7 @@ function createRuntimeHost(options) {
                 const proactive = session ? proactivelyCompactPiAtIdle(agent, session) : null;
                 if (proactive)
                     await proactive;
-                reconcileSubagentLedger(agent, { forceMissing: true, missingReason: "pi session gone" });
-                enqueueUndeliveredTerminalWakes(agent);
                 await retryPending(agent);
-                if (agent.backgroundCompletionQueue.length > 0)
-                    scheduleBackgroundCompletionDrain(agent);
             }).catch((error) => {
                 const readiness = error instanceof runtime_readiness_js_1.RuntimePrerequisiteError ? error.readiness
                     : (0, runtime_readiness_js_1.classifyRuntimePrerequisite)(agent.adapter.id, error);
@@ -1176,7 +839,6 @@ function createRuntimeHost(options) {
         agent.busy = false;
         agent.submitting = false;
         agent.generation += 1;
-        rearmBackgroundCompletion(agent);
         agent.recreateReason = reason;
         if (agent.stabilityTimer)
             clearTimeout(agent.stabilityTimer);
@@ -1186,14 +848,11 @@ function createRuntimeHost(options) {
                 record.status = "pending";
         emitConsumed(agent, persist(agent));
         emit({ type: "agent-status", agentId: agent.config.agentId, status: "error", error: reason });
-        // Close first so the shutdown sweep can bridge consumed or terminal state
-        // before force-missing reconcile treats a plain sidecar as orphaned.
         void session.close(`replace after ${reason}`)
             .catch((error) => log("runtime close after replacement failed", String(error)))
             .finally(() => {
             if (agent.stopped)
                 return;
-            reconcileAfterSessionSwap(agent);
             scheduleRecreate(agent, reason);
         });
     };
@@ -1205,7 +864,6 @@ function createRuntimeHost(options) {
         agent.busy = false;
         agent.submitting = false;
         agent.generation += 1;
-        rearmBackgroundCompletion(agent);
         if (agent.stabilityTimer)
             clearTimeout(agent.stabilityTimer);
         agent.stabilityTimer = null;
@@ -1220,8 +878,6 @@ function createRuntimeHost(options) {
         const recovery = (async () => {
             try {
                 await session.close("runtime configuration error");
-                if (!agent.stopped)
-                    reconcileAfterSessionSwap(agent);
                 const result = agent.adapter.recoverConfigurationError
                     ? await agent.adapter.recoverConfigurationError(message)
                     : { recovered: false, reason: "runtime adapter does not support automatic configuration recovery" };
@@ -1498,16 +1154,6 @@ function createRuntimeHost(options) {
             // closed instead of inheriting a previous turn's chat or reminder.
             agent.stateStore?.clearCurrentInboxSource?.();
             finalizeReminderContexts(agent, "Runtime turn ended without a matching Feishu write");
-            if (agent.backgroundCompletionInFlight) {
-                if (agent.turnHadFailure)
-                    failBackgroundCompletionWake(agent);
-                else
-                    commitBackgroundCompletion(agent);
-            }
-            if (agent.backgroundCompletionQueue.length > 0 && !agent.backgroundCompletionRetryTimer) {
-                scheduleBackgroundCompletionDrain(agent);
-            }
-            reconcileSubagentLedger(agent);
             telemetry?.runtimeEvent(agent.config.agentId, event);
             if (recoveredAuthentication) {
                 clearAuthFailure(agent);
@@ -1525,34 +1171,12 @@ function createRuntimeHost(options) {
             void (proactive ?? Promise.resolve("noop")).then(() => retryPending(agent));
             queueMicrotask(() => { void scanAndPromoteAcceptedInboxUpdates(agent); });
         }
-        else if (event.type === "runtime-observation") {
-            if (event.phase === "background_dispatched" && typeof event.taskId === "string" && event.taskId) {
-                recordDispatchedSubagent(agent, event.taskId, typeof event.outputFile === "string" ? event.outputFile : undefined);
-            }
-            else if (event.phase === "completed" && typeof event.completionKey === "string") {
-                recordTerminalSubagentNotification(agent, event.completionKey, event.completionStatuses);
-                if (event.handledInTurn === true) {
-                    acknowledgeSubagentWake(agent, event.completionKey);
-                    dropQueuedBackgroundCompletionFallback(agent, event.completionKey);
-                }
-                else {
-                    noteBackgroundCompletion(agent, event.completionKey);
-                }
-            }
-        }
         else if (event.type === "activity") {
             if (agent.turnInProgress && event.activity !== "internal")
                 agent.turnHadAuthenticatedOutput = true;
             emit({ type: "activity", agentId: agent.config.agentId, activity: event.activity, activityKind: event.activity });
         }
         else if (event.type === "input-error") {
-            if (agent.backgroundCompletionInFlight
-                && (!event.inputId || !agent.backgroundCompletionWakeInputId
-                    || event.inputId === agent.backgroundCompletionWakeInputId)
-                && event.willRetry !== true) {
-                agent.turnHadFailure = true;
-                failBackgroundCompletionWake(agent, event);
-            }
             const record = event.inputId
                 ? agent.records.get(event.inputId) ?? [...agent.records.values()].find((candidate) => candidate.input.inputId === event.inputId)
                 : undefined;
@@ -1682,7 +1306,6 @@ function createRuntimeHost(options) {
                 throw new Error("stale runtime session creation");
             }
             agent.session = session;
-            agent.piSessionOwner = sessionEnv[pi_subagent_ledger_js_1.PI_SUBAGENT_SESSION_OWNER_ENV];
             session.subscribe((event) => observe(agent, session, event));
             if (agent.session !== session)
                 return session;
@@ -1828,9 +1451,7 @@ function createRuntimeHost(options) {
                 ...(agent.previousSession ? { previousSession: agent.previousSession } : {}) });
         }
         emit({ type: "agent-status", agentId, status: "active", readiness });
-        agent.piSessionOwner = probeEnv[pi_subagent_ledger_js_1.PI_SUBAGENT_SESSION_OWNER_ENV];
         await oldSession.close("Pi context fallback committed").catch((error) => log("previous Pi session close after fallback failed", String(error)));
-        reconcileAfterSessionSwap(agent);
         const proactive = proactivelyCompactPiAtIdle(agent, fresh);
         void (proactive ?? Promise.resolve("noop")).then(() => retryPending(agent));
         return { generationChanged: true, sessionChanged: oldSessionId !== fresh.sessionId, turns: 0,
@@ -1900,10 +1521,6 @@ function createRuntimeHost(options) {
                         clearTimeout(previous.retryTimer);
                     if (previous.stabilityTimer)
                         clearTimeout(previous.stabilityTimer);
-                    if (previous.backgroundCompletionRetryTimer)
-                        clearTimeout(previous.backgroundCompletionRetryTimer);
-                    if (previous.subagentReconcileTimer)
-                        clearInterval(previous.subagentReconcileTimer);
                     const previousFailure = currentAuthFailure(previous);
                     const scoped = Boolean(previousFailure
                         && (0, runtime_readiness_js_1.authFailureAppliesTo)({
@@ -1915,7 +1532,6 @@ function createRuntimeHost(options) {
                         ...previous, config, adapter, session, launchId: node_crypto_1.default.randomUUID(), busy: false, submitting: false,
                         starting: null, retryAfterSubmit: false, generation: 0, poller: null, retryTimer: null,
                         recreateAttempts: 0, stabilityTimer: null, recreateReason: null, stopped: false,
-                        backgroundCompletionRetryTimer: null, subagentReconcileTimer: null,
                         disabledReason: null, configurationRecovery: null,
                         authFailureActive: scoped && previous.authFailureActive,
                         authFailureKind: scoped ? previous.authFailureKind : null,
@@ -1937,14 +1553,8 @@ function createRuntimeHost(options) {
                     if (!candidate.authFailureActive) {
                         emit({ type: "agent-status", agentId: config.agentId, status: "active", readiness: candidate.readiness ?? readiness });
                     }
-                    candidate.piSessionOwner = stageEnv[pi_subagent_ledger_js_1.PI_SUBAGENT_SESSION_OWNER_ENV];
-                    // Close first so the old session's shutdown sweep can bridge consumed
-                    // terminals before force-missing reconcile. Commit also clears any
-                    // inherited backoff timer; reschedule so a queued completion still
-                    // drains on the new session.
                     await previous.session?.close("runtime candidate committed")
                         .catch((error) => log("previous runtime close after candidate commit failed", String(error)));
-                    reconcileAfterSessionSwap(candidate);
                 },
                 rollback,
             };
@@ -2047,10 +1657,8 @@ function createRuntimeHost(options) {
                 ...(agent.authFailureActive ? { error: `${agent.readiness?.reason} ${agent.readiness?.nextAction}` } : {}),
                 readiness: agent.authFailureActive ? agent.readiness ?? readiness : readiness,
             });
-            agent.piSessionOwner = probeEnv[pi_subagent_ledger_js_1.PI_SUBAGENT_SESSION_OWNER_ENV];
             await oldSession.close("fresh session reset committed")
                 .catch((error) => log("previous runtime close after fresh reset failed", String(error)));
-            reconcileAfterSessionSwap(agent);
             return { generationChanged: true, sessionChanged: oldSessionId !== fresh.sessionId, turns: 0,
                 runtimeReady: true, pendingCount: 0, sessionId: fresh.sessionId };
         },
@@ -2211,10 +1819,8 @@ function createRuntimeHost(options) {
                     readiness: agent.authFailureActive ? agent.readiness ?? readiness : readiness,
                 });
                 durableRollback = null;
-                agent.piSessionOwner = probeEnv[pi_subagent_ledger_js_1.PI_SUBAGENT_SESSION_OWNER_ENV];
                 await oldSession.close("context-window recovery committed")
                     .catch((error) => log("previous runtime close after context-window recovery failed", String(error)));
-                reconcileAfterSessionSwap(agent);
                 const proactive = proactivelyCompactPiAtIdle(agent, fresh);
                 void (proactive ?? Promise.resolve("noop")).then(() => retryPending(agent));
                 return { generationChanged: true, sessionChanged: oldSessionId !== fresh.sessionId, turns: 0,
@@ -2300,11 +1906,7 @@ function createRuntimeHost(options) {
                     previousSession: loadPersistedPreviousSession(config, stateStore), readiness: null,
                     turnInProgress: false, turnHadFailure: false, turnHadAuthenticatedOutput: false, authFailureActive: false,
                     authFailureKind: null, authFailureProvider: null,
-                    promotedInboxUpdateIds: new Set(),
-                    backgroundCompletionQueue: [], backgroundCompletionKeys: new Set(),
-                    backgroundCompletionInFlight: null, backgroundCompletionWakeInputId: null,
-                    backgroundCompletionRejectStreak: 0, backgroundCompletionRetryTimer: null,
-                    subagentLedger: loadSubagentLedger(config), subagentReconcileTimer: null };
+                    promotedInboxUpdateIds: new Set() };
                 restoreAuthFailure(agent);
                 const startupConsumed = [];
                 const startupQuarantined = [];
@@ -2338,8 +1940,6 @@ function createRuntimeHost(options) {
                     await ensureSession(agent);
                     if (agent.stopped)
                         return;
-                    reconcileSubagentLedger(agent, { forceMissing: true, missingReason: "runtime restarted" });
-                    enqueueUndeliveredTerminalWakes(agent);
                     await recoverStalePiCompaction(agent);
                     const startupSession = agent.session;
                     const proactive = startupSession ? proactivelyCompactPiAtIdle(agent, startupSession) : null;
@@ -2356,8 +1956,6 @@ function createRuntimeHost(options) {
                     const reason = error instanceof Error ? error.message : String(error);
                     const transient = error instanceof runtime_readiness_js_1.RuntimePrerequisiteError && error.readiness.state === "unavailable";
                     agent.disabledReason = transient ? null : reason;
-                    reconcileSubagentLedger(agent, { forceMissing: true, missingReason: "runtime restarted" });
-                    enqueueUndeliveredTerminalWakes(agent);
                     if (transient) {
                         recoveringCount += 1;
                         scheduleRecreate(agent, reason);
@@ -2469,10 +2067,6 @@ function createRuntimeHost(options) {
                 clearTimeout(agent.retryTimer);
             if (agent.stabilityTimer)
                 clearTimeout(agent.stabilityTimer);
-            if (agent.backgroundCompletionRetryTimer)
-                clearTimeout(agent.backgroundCompletionRetryTimer);
-            if (agent.subagentReconcileTimer)
-                clearInterval(agent.subagentReconcileTimer);
             if (agent.busy)
                 await agent.session?.cancel(reason);
             await agent.session?.close(reason);
@@ -2485,9 +2079,5 @@ function createRuntimeHost(options) {
         },
         async shutdown(reason) { await Promise.allSettled([...managed.keys()].map((id) => this.stop(id, reason))); },
         subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
-        getDispatchedSubagent(agentId, taskId) {
-            const agent = managed.get(agentId);
-            return agent ? (0, pi_subagent_ledger_js_1.getDispatchedSubagent)(agent.subagentLedger, taskId) : null;
-        },
     };
 }