larkin 0.5.4 → 0.5.6

package/dist/runtime/runtime-host.mjs

@@ -10,7 +10,7 @@ import { authFailureAppliesTo, classifyPiMissingCredentialRejection, classifyRun
 import { resolveOfficialLarkCli } from "../app/official-lark-cli.mjs";
 import { assertAgentWorkspaceBound, managedLarkCliEnv } from "../app/agent-lark-cli-workspace.mjs";
 import { isPiNativeCompactionRequired, PiCompactionBreaker, PiCompactionRecoveryMachine, } from "./pi-compaction-recovery.mjs";
-import { getDispatchedSubagent as lookupDispatchedSubagent, ledgerFilePath, noteDispatchedSubagent, noteDispatchedSubagentTerminal, noteDispatchedSubagentWakeAcknowledged, probePiSubagentRecord, readDispatchedSubagentLedger, reconcileDispatchedSubagents, taskIdsFromCompletionKey, undeliveredTerminalWakeKeys, PI_SUBAGENT_SESSION_OWNER_ENV, retirePiSubagentRecord, effectivePiStateDir, writeDispatchedSubagentLedger, writeDispatchedSubagentRecordFile, } from "./pi-subagent-ledger.mjs";
+import { effectivePiStateDir } from "./pi-state-dir.mjs";
 export class RuntimeSessionResetError extends Error {
     code;
     pendingCount;
@@ -32,8 +32,6 @@ export class RuntimeSessionRecoveryError extends Error {
     }
 }
 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
@@ -301,10 +299,6 @@ export 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);
@@ -316,7 +310,6 @@ export function createRuntimeHost(options) {
             LARKIN_AGENT_ID: config.agentId,
             ...(generation ? {
                 LARKIN_RUNTIME_OBSERVATION_GENERATION: generation,
-                [PI_SUBAGENT_SESSION_OWNER_ENV]: generation,
             } : {}),
             LARKIN_CONFIG_DIR: process.env.LARKIN_CONFIG_DIR,
             LARKIN_HOME: process.env.LARKIN_HOME,
@@ -717,12 +710,6 @@ export 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) => {
@@ -799,326 +786,6 @@ export 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 = taskIdsFromCompletionKey(headKey ?? "")
-                .map((taskId) => lookupDispatchedSubagent(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", crypto.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) => {
-        writeDispatchedSubagentLedger(ledgerFilePath(effectivePiStateDir(agent.config)), agent.subagentLedger);
-    };
-    const dropQueuedBackgroundCompletionFallback = (agent, completionKey) => {
-        const keys = new Set([completionKey, ...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 = noteDispatchedSubagentWakeAcknowledged(agent.subagentLedger, { completionKey });
-        if (next === agent.subagentLedger)
-            return;
-        agent.subagentLedger = next;
-        persistSubagentLedger(agent);
-        for (const taskId of taskIdsFromCompletionKey(completionKey)) {
-            retirePiSubagentRecord(lookupDispatchedSubagent(agent.subagentLedger, taskId)?.recordFile);
-        }
-    };
-    const enqueueUndeliveredTerminalWakes = (agent) => {
-        for (const key of undeliveredTerminalWakeKeys(agent.subagentLedger)) {
-            agent.backgroundCompletionKeys.delete(key);
-            for (const taskId of 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 readDispatchedSubagentLedger(ledgerFilePath(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 = 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 = writeDispatchedSubagentRecordFile(effectivePiStateDir(agent.config), taskId, agent.piSessionOwner);
-        agent.subagentLedger = noteDispatchedSubagent(agent.subagentLedger, { taskId, outputFile, recordFile });
-        persistSubagentLedger(agent);
-        armSubagentReconcileTimer(agent);
-    };
-    const recordTerminalSubagentNotification = (agent, completionKey, statuses) => {
-        let next = agent.subagentLedger;
-        for (const taskId of taskIdsFromCompletionKey(completionKey)) {
-            const status = statuses?.[taskId];
-            next = 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 = reconcileDispatchedSubagents(agent.subagentLedger, {
-            probe: options.subagentRecordProbe ?? 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;
@@ -1140,11 +807,7 @@ export 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 RuntimePrerequisiteError ? error.readiness
                     : classifyRuntimePrerequisite(agent.adapter.id, error);
@@ -1167,7 +830,6 @@ export function createRuntimeHost(options) {
         agent.busy = false;
         agent.submitting = false;
         agent.generation += 1;
-        rearmBackgroundCompletion(agent);
         agent.recreateReason = reason;
         if (agent.stabilityTimer)
             clearTimeout(agent.stabilityTimer);
@@ -1177,14 +839,11 @@ export 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);
         });
     };
@@ -1196,7 +855,6 @@ export function createRuntimeHost(options) {
         agent.busy = false;
         agent.submitting = false;
         agent.generation += 1;
-        rearmBackgroundCompletion(agent);
         if (agent.stabilityTimer)
             clearTimeout(agent.stabilityTimer);
         agent.stabilityTimer = null;
@@ -1211,8 +869,6 @@ export 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" };
@@ -1489,16 +1145,6 @@ export 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);
@@ -1516,34 +1162,12 @@ export 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;
@@ -1673,7 +1297,6 @@ export function createRuntimeHost(options) {
                 throw new Error("stale runtime session creation");
             }
             agent.session = session;
-            agent.piSessionOwner = sessionEnv[PI_SUBAGENT_SESSION_OWNER_ENV];
             session.subscribe((event) => observe(agent, session, event));
             if (agent.session !== session)
                 return session;
@@ -1819,9 +1442,7 @@ export function createRuntimeHost(options) {
                 ...(agent.previousSession ? { previousSession: agent.previousSession } : {}) });
         }
         emit({ type: "agent-status", agentId, status: "active", readiness });
-        agent.piSessionOwner = probeEnv[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,
@@ -1891,10 +1512,6 @@ export 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
                         && authFailureAppliesTo({
@@ -1906,7 +1523,6 @@ export function createRuntimeHost(options) {
                         ...previous, config, adapter, session, launchId: crypto.randomUUID(), busy: false, submitting: false,
                         starting: null, retryAfterSubmit: false, generation: 0, poller: null, retryTimer: null,
                         recreateAttempts: 0, stabilityTimer: null, recreateReason: null, stopped: false,
-                        backgroundCompletionRetryTimer: null, subagentReconcileTimer: null,
                         disabledReason: null, configurationRecovery: null,
                         authFailureActive: scoped && previous.authFailureActive,
                         authFailureKind: scoped ? previous.authFailureKind : null,
@@ -1928,14 +1544,8 @@ export function createRuntimeHost(options) {
                     if (!candidate.authFailureActive) {
                         emit({ type: "agent-status", agentId: config.agentId, status: "active", readiness: candidate.readiness ?? readiness });
                     }
-                    candidate.piSessionOwner = stageEnv[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,
             };
@@ -2038,10 +1648,8 @@ export function createRuntimeHost(options) {
                 ...(agent.authFailureActive ? { error: `${agent.readiness?.reason} ${agent.readiness?.nextAction}` } : {}),
                 readiness: agent.authFailureActive ? agent.readiness ?? readiness : readiness,
             });
-            agent.piSessionOwner = probeEnv[PI_SUBAGENT_SESSION_OWNER_ENV];
             await oldSession.close("fresh session reset committed")
                 .catch((error) => log("previous runtime close after fresh reset failed", String(error)));
-            reconcileAfterSessionSwap(agent);
             return { generationChanged: true, sessionChanged: oldSessionId !== fresh.sessionId, turns: 0,
                 runtimeReady: true, pendingCount: 0, sessionId: fresh.sessionId };
         },
@@ -2202,10 +1810,8 @@ export function createRuntimeHost(options) {
                     readiness: agent.authFailureActive ? agent.readiness ?? readiness : readiness,
                 });
                 durableRollback = null;
-                agent.piSessionOwner = probeEnv[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,
@@ -2291,11 +1897,7 @@ export 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 = [];
@@ -2329,8 +1931,6 @@ export 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;
@@ -2347,8 +1947,6 @@ export function createRuntimeHost(options) {
                     const reason = error instanceof Error ? error.message : String(error);
                     const transient = error instanceof 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);
@@ -2460,10 +2058,6 @@ export 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);
@@ -2476,9 +2070,5 @@ export 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 ? lookupDispatchedSubagent(agent.subagentLedger, taskId) : null;
-        },
     };
 }

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "larkin",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "private": false,
   "larkinPackageRole": "npm-published",
   "files": [
     "dist/",
-    "patches/",
     "assets/",
     "scripts/npm/",
     "README.md",
@@ -70,8 +69,7 @@
     "test:live:runtime-agent-interface-v2:read-only": "LARKIN_RUN_RUNTIME_AGENT_INTERFACE_V2_LIVE=1 bun test --max-concurrency 1 test/live/runtime-agent-interface-v2-live.test.mjs",
     "test:live:runtime-agent-interface-v2:hold-host": "bun run build && bun run test/live/runtime-agent-interface-v2-hold-host.mjs app/runtime-process.mjs",
     "test:eval:long-running-im-progress": "bun run build && bun test --max-concurrency 1 test/live/long-running-im-progress-live.test.mjs",
-    "test:eval:pi-subagents-background": "bun run build && bun test --max-concurrency 1 test/live/pi-subagents-background-live.test.mjs",
-    "test:eval:pi-bash-timeout": "bun run build && bun test --max-concurrency 1 test/live/pi-bash-timeout-live.test.mjs",
+    "test:eval:pi-tmux-bash": "bun run build && LARKIN_RUN_PI_TMUX_BASH_EVAL=1 bun test --max-concurrency 1 test/live/pi-tmux-bash-live.test.mjs",
     "test:eval:runtime-agent-interface-v2": "bun test --max-concurrency 1 test/unit/evals/runtime-agent-interface-v2.test.mjs",
     "test:eval:authoritative-freshness-gate": "bun test --max-concurrency 1 test/unit/evals/authoritative-freshness-gate.test.mjs",
     "test:eval:protected-message-recall": "bun run build && bun test --max-concurrency 1 test/unit/evals/protected-message-recall.test.mjs test/unit/app/lark-cli-launcher.test.mjs",
@@ -95,7 +93,6 @@
     "@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",
@@ -119,8 +116,5 @@
     "typescript": "^7.0.2",
     "vite": "^8.1.5",
     "vitest": "^4.1.10"
-  },
-  "patchedDependencies": {
-    "@tintinweb/pi-subagents@0.14.3": "patches/@tintinweb%2Fpi-subagents@0.14.3.patch"
   }
 }