@botbotgo/agent-harness 0.0.100 → 0.0.102

package/dist/runtime/harness.js

@@ -1,26 +1,27 @@
 import { AUTO_AGENT_ID } from "../contracts/types.js";
 import { SqlitePersistence } from "../persistence/sqlite-store.js";
 import { createPersistentId } from "../utils/id.js";
-import { AGENT_INTERRUPT_SENTINEL_PREFIX, AgentRuntimeAdapter, RuntimeOperationTimeoutError } from "./agent-runtime-adapter.js";
-import { normalizeUpstreamRuntimeEvent } from "./parsing/stream-event-parsing.js";
+import { AgentRuntimeAdapter } from "./agent-runtime-adapter.js";
 import { createResourceBackendResolver, createResourceToolResolver } from "../resource/resource.js";
 import { EventBus } from "./harness/events/event-bus.js";
 import { PolicyEngine } from "./harness/system/policy-engine.js";
 import { getConcurrencyConfig, getRecoveryConfig, getRoutingDefaultAgentId, getRoutingRules, matchRoutingRule, } from "../workspace/support/workspace-ref-utils.js";
-import { createHarnessEvent, inferRoutingBindings, renderRuntimeFailure, renderToolFailure, } from "./support/harness-support.js";
+import { createHarnessEvent, inferRoutingBindings, renderRuntimeFailure, } from "./support/harness-support.js";
 import { ThreadMemorySync } from "./harness/system/thread-memory-sync.js";
 import { FileBackedStore } from "./harness/system/store.js";
-import { CheckpointMaintenanceLoop, discoverCheckpointMaintenanceTargets, readCheckpointMaintenanceConfig, } from "./checkpoint-maintenance.js";
+import { CheckpointMaintenanceLoop, discoverCheckpointMaintenanceTargets, readCheckpointMaintenanceConfig, } from "./maintenance/checkpoint-maintenance.js";
 import { RuntimeRecordMaintenanceLoop, discoverRuntimeRecordMaintenanceTargets, readRuntimeRecordMaintenanceConfig, } from "./maintenance/runtime-record-maintenance.js";
 import { HealthMonitor } from "./harness/system/health-monitor.js";
 import { readHealthMonitorConfig } from "./harness/system/health-monitor.js";
 import { extractMessageText, normalizeMessageContent } from "../utils/message-content.js";
 import { buildPersistedRunRequest, isTerminalRunState, normalizeInvocationEnvelope, normalizeRunPriority, resolveRunListeners, toPublicApprovalRecord, } from "./harness/run/helpers.js";
-import { emitHarnessEvent, emitRunCreatedEvent, emitSyntheticFallbackEvent, persistApproval, requestApprovalAndEmitEvent, setRunStateAndEmitEvent, } from "./harness/events/events.js";
-import { appendAssistantMessage as appendLifecycleAssistantMessage, checkpointRefForState as getCheckpointRefForRunState, expirePendingApprovals as expireLifecyclePendingApprovals, finalizeCancelledRun as finalizeLifecycleCancelledRun, finalizeContinuedRun as finalizeLifecycleContinuedRun, } from "./harness/run/run-lifecycle.js";
-import { createContentBlocksItem as createStreamingContentBlocksItem, createToolResultKey as createStreamingToolResultKey, dispatchRunListeners as dispatchStreamingRunListeners, emitOutputDeltaAndCreateItem as emitStreamingOutputDeltaAndCreateItem, } from "./harness/events/streaming.js";
+import { emitHarnessEvent, emitRunCreatedEvent, emitSyntheticFallbackEvent, requestApprovalAndEmitEvent, setRunStateAndEmitEvent, } from "./harness/events/events.js";
+import { appendAssistantMessage as appendLifecycleAssistantMessage, finalizeCancelledRun as finalizeLifecycleCancelledRun, finalizeContinuedRun as finalizeLifecycleContinuedRun, } from "./harness/run/run-lifecycle.js";
+import { dispatchRunListeners as dispatchStreamingRunListeners, } from "./harness/events/streaming.js";
 import { buildResumePayload as buildHarnessResumePayload, resolveApprovalRecord as resolveHarnessApprovalRecord, } from "./harness/run/resume.js";
-import { dropPendingRunSlot, enqueuePendingRunSlot, shiftNextPendingRunSlot } from "./harness/run/run-queue.js";
+import { cancelRunOperation, resumeRun } from "./harness/run/run-operations.js";
+import { acquireRunSlot as acquireHarnessRunSlot } from "./harness/run/run-slot-acquisition.js";
+import { dropPendingRunSlot, enqueuePendingRunSlot } from "./harness/run/run-queue.js";
 import { getDefaultHostAgentId, resolveSelectedAgentId } from "./harness/run/routing.js";
 import { resolveCheckpointer, resolveEmbeddingModel, resolveStore, resolveStoreFromConfig, resolveVectorStore, } from "./harness/run/resources.js";
 import { createToolMcpServerFromTools, serveToolsOverStdioFromHarness } from "../mcp.js";
@@ -28,6 +29,8 @@ import { getBindingAdapterKind, getBindingPrimaryTools, getBindingStoreConfig }
 import { isRuntimeEntryBinding } from "./support/runtime-entry.js";
 import { describeWorkspaceInventory, listAgentSkills as listWorkspaceAgentSkills, } from "./harness/system/inventory.js";
 import { createDefaultHealthSnapshot, isInventoryEnabled, isThreadMemorySyncEnabled, } from "./harness/runtime-defaults.js";
+import { recoverQueuedStartupRun, recoverResumingStartupRun, recoverRunningStartupRun, } from "./harness/run/recovery.js";
+import { streamHarnessRun } from "./harness/run/stream-run.js";
 export class AgentHarnessRuntime {
     workspace;
     runtimeAdapterOptions;
@@ -85,42 +88,30 @@ export class AgentHarnessRuntime {
             getThreadSummary: (currentThreadId) => this.getSession(currentThreadId),
         });
     }
-    resolveStore(binding) {
-        return resolveStore(this.stores, this.defaultStore, this.defaultRunRoot(), (currentBinding) => currentBinding ? getBindingStoreConfig(currentBinding) : undefined, binding);
-    }
-    resolveStoreFromConfig(storeConfig, runRoot) {
-        return resolveStoreFromConfig(this.stores, storeConfig, runRoot);
-    }
-    async resolveEmbeddingModel(embeddingModelRef) {
-        return resolveEmbeddingModel(this.workspace, this.embeddingModels, embeddingModelRef, this.runtimeAdapterOptions);
-    }
-    async resolveVectorStore(vectorStoreRef) {
-        return resolveVectorStore(this.workspace, this.vectorStores, vectorStoreRef, this.runtimeAdapterOptions);
-    }
     constructor(workspace, runtimeAdapterOptions = {}) {
         this.workspace = workspace;
         this.runtimeAdapterOptions = runtimeAdapterOptions;
         const runRoot = this.defaultRunRoot();
         this.persistence = new SqlitePersistence(runRoot);
         const defaultStoreConfig = this.listHostBindings()[0]?.harnessRuntime.store;
-        this.defaultStore = this.resolveStoreFromConfig(defaultStoreConfig, runRoot) ?? new FileBackedStore(`${runRoot}/store.json`);
+        this.defaultStore = resolveStoreFromConfig(this.stores, defaultStoreConfig, runRoot) ?? new FileBackedStore(`${runRoot}/store.json`);
         const runtimeMemoryStoreConfig = typeof this.listHostBindings()[0]?.harnessRuntime.runtimeMemory?.store === "object" &&
             this.listHostBindings()[0]?.harnessRuntime.runtimeMemory?.store
             ? this.listHostBindings()[0]?.harnessRuntime.runtimeMemory?.store
             : undefined;
-        this.runtimeMemoryStore = this.resolveStoreFromConfig(runtimeMemoryStoreConfig, runRoot) ?? this.defaultStore;
+        this.runtimeMemoryStore = resolveStoreFromConfig(this.stores, runtimeMemoryStoreConfig, runRoot) ?? this.defaultStore;
         this.resolvedRuntimeAdapterOptions = {
             ...runtimeAdapterOptions,
             toolResolver: runtimeAdapterOptions.toolResolver ??
                 createResourceToolResolver(workspace, {
-                    getStore: (binding) => this.resolveStore(binding),
-                    getEmbeddingModel: (embeddingModelRef) => this.resolveEmbeddingModel(embeddingModelRef),
-                    getVectorStore: (vectorStoreRef) => this.resolveVectorStore(vectorStoreRef),
+                    getStore: (binding) => resolveStore(this.stores, this.defaultStore, this.defaultRunRoot(), (currentBinding) => currentBinding ? getBindingStoreConfig(currentBinding) : undefined, binding),
+                    getEmbeddingModel: (embeddingModelRef) => resolveEmbeddingModel(this.workspace, this.embeddingModels, embeddingModelRef, this.runtimeAdapterOptions),
+                    getVectorStore: (vectorStoreRef) => resolveVectorStore(this.workspace, this.vectorStores, vectorStoreRef, this.runtimeAdapterOptions),
                 }),
             checkpointerResolver: runtimeAdapterOptions.checkpointerResolver ??
                 ((binding) => resolveCheckpointer(this.checkpointers, binding)),
             storeResolver: runtimeAdapterOptions.storeResolver ??
-                ((binding) => this.resolveStore(binding)),
+                ((binding) => resolveStore(this.stores, this.defaultStore, this.defaultRunRoot(), (currentBinding) => currentBinding ? getBindingStoreConfig(currentBinding) : undefined, binding)),
             backendResolver: runtimeAdapterOptions.backendResolver ??
                 ((binding) => createResourceBackendResolver(workspace)(binding)),
         };
@@ -183,22 +174,12 @@ export class AgentHarnessRuntime {
         }
         return createDefaultHealthSnapshot(this.activeRunSlots, this.pendingRunSlots.length);
     }
-    getBinding(agentId) {
-        return this.workspace.bindings.get(agentId);
-    }
-    listAgentTools(agentId) {
-        const binding = this.getBinding(agentId);
-        if (!binding) {
-            throw new Error(`Unknown agent ${agentId}`);
-        }
-        return getBindingPrimaryTools(binding);
-    }
     resolveAgentTools(agentId) {
-        const binding = this.getBinding(agentId);
+        const binding = this.workspace.bindings.get(agentId);
         if (!binding) {
             throw new Error(`Unknown agent ${agentId}`);
         }
-        const compiledTools = this.listAgentTools(agentId);
+        const compiledTools = getBindingPrimaryTools(binding);
         const resolver = this.resolvedRuntimeAdapterOptions.toolResolver;
         const resolvedTools = resolver ? resolver(compiledTools.map((tool) => tool.id), binding) : [];
         return compiledTools.map((compiledTool, index) => ({
@@ -416,9 +397,6 @@ export class AgentHarnessRuntime {
         const userTurn = history.find((message) => message.runId === runId && message.role === "user");
         return userTurn?.content ?? "";
     }
-    async appendAssistantMessage(threadId, runId, content) {
-        return appendLifecycleAssistantMessage(this.persistence, threadId, runId, content);
-    }
     async getRunCancellation(runId) {
         const control = await this.persistence.getRunControl(runId);
         return {
@@ -426,12 +404,6 @@ export class AgentHarnessRuntime {
             ...(control?.cancelReason ? { reason: control.cancelReason } : {}),
         };
     }
-    async expirePendingApprovals(threadId, runId) {
-        return expireLifecyclePendingApprovals({
-            persistence: this.persistence,
-            emit: (currentThreadId, currentRunId, sequence, eventType, payload, source) => this.emit(currentThreadId, currentRunId, sequence, eventType, payload, source),
-        }, threadId, runId);
-    }
     async finalizeCancelledRun(threadId, runId, previousState, reason) {
         return finalizeLifecycleCancelledRun({
             persistence: this.persistence,
@@ -507,7 +479,12 @@ export class AgentHarnessRuntime {
             };
         }
         catch (error) {
-            await this.emitSyntheticFallback(threadId, runId, agentId, error, 103);
+            await emitSyntheticFallbackEvent({
+                persistence: this.persistence,
+                publishEvent: (event) => this.eventBus.publish(event),
+                trackBackgroundTask: (task) => this.trackBackgroundTask(task),
+                backgroundEventTypes: AgentHarnessRuntime.BACKGROUND_EVENT_TYPES,
+            }, threadId, runId, agentId, error, 103);
             await this.setRunStateAndEmit(threadId, runId, 104, "failed", {
                 previousState: previousState === "queued" ? "running" : previousState,
                 error: error instanceof Error ? error.message : String(error),
@@ -524,9 +501,6 @@ export class AgentHarnessRuntime {
             await this.persistence.clearRunRequest(threadId, runId);
         }
     }
-    checkpointRefForState(threadId, runId, state) {
-        return getCheckpointRefForRunState(threadId, runId, state);
-    }
     async finalizeContinuedRun(binding, threadId, runId, input, actual, options) {
         return finalizeLifecycleContinuedRun({
             persistence: this.persistence,
@@ -535,23 +509,6 @@ export class AgentHarnessRuntime {
             requestApprovalAndEmit: (currentThreadId, currentRunId, lifecycleInput, interruptContent, checkpointRef, sequence) => this.requestApprovalAndEmit(currentThreadId, currentRunId, lifecycleInput, interruptContent, checkpointRef, sequence),
         }, binding, threadId, runId, input, actual, options);
     }
-    async emitOutputDeltaAndCreateItem(threadId, runId, agentId, content) {
-        return emitStreamingOutputDeltaAndCreateItem((currentThreadId, currentRunId, sequence, eventType, payload) => this.emit(currentThreadId, currentRunId, sequence, eventType, payload), threadId, runId, agentId, content);
-    }
-    createContentBlocksItem(threadId, runId, agentId, contentBlocks) {
-        return createStreamingContentBlocksItem(threadId, runId, agentId, contentBlocks);
-    }
-    createToolResultKey(toolName, output, isError) {
-        return createStreamingToolResultKey(toolName, output, isError);
-    }
-    async emitRunCreated(threadId, runId, payload) {
-        return emitRunCreatedEvent({
-            persistence: this.persistence,
-            publishEvent: (event) => this.eventBus.publish(event),
-            trackBackgroundTask: (task) => this.trackBackgroundTask(task),
-            backgroundEventTypes: AgentHarnessRuntime.BACKGROUND_EVENT_TYPES,
-        }, threadId, runId, payload);
-    }
     async setRunStateAndEmit(threadId, runId, sequence, state, options) {
         return setRunStateAndEmitEvent({
             persistence: this.persistence,
@@ -568,25 +525,6 @@ export class AgentHarnessRuntime {
             backgroundEventTypes: AgentHarnessRuntime.BACKGROUND_EVENT_TYPES,
         }, threadId, runId, input, interruptContent, checkpointRef, sequence);
     }
-    async emitSyntheticFallback(threadId, runId, selectedAgentId, error, sequence = 3) {
-        await emitSyntheticFallbackEvent({
-            persistence: this.persistence,
-            publishEvent: (event) => this.eventBus.publish(event),
-            trackBackgroundTask: (task) => this.trackBackgroundTask(task),
-            backgroundEventTypes: AgentHarnessRuntime.BACKGROUND_EVENT_TYPES,
-        }, threadId, runId, selectedAgentId, error, sequence);
-    }
-    async persistApproval(threadId, runId, checkpointRef, input, interruptContent) {
-        return persistApproval({
-            persistence: this.persistence,
-            publishEvent: (event) => this.eventBus.publish(event),
-            trackBackgroundTask: (task) => this.trackBackgroundTask(task),
-            backgroundEventTypes: AgentHarnessRuntime.BACKGROUND_EVENT_TYPES,
-        }, threadId, runId, checkpointRef, input, interruptContent);
-    }
-    async resolveApprovalRecord(options, thread) {
-        return resolveHarnessApprovalRecord(this.persistence, options, thread);
-    }
     isDecisionRun(options) {
         return "decision" in options;
     }
@@ -596,161 +534,75 @@ export class AgentHarnessRuntime {
         }
         await listener(value);
     }
-    async acquireRunSlot(threadId, runId, activeState = "running", priority = 0) {
-        let stopHeartbeat = () => undefined;
-        const beginLease = async (mode) => {
-            if (!threadId || !runId) {
-                return;
-            }
-            const claimedAt = new Date().toISOString();
-            if (mode === "queue-claim") {
-                await this.persistence.claimQueuedRun({
-                    threadId,
-                    runId,
-                    workerId: this.workerId,
-                    claimedAt,
-                    leaseExpiresAt: new Date(Date.now() + this.concurrencyConfig.leaseMs).toISOString(),
-                });
-            }
-            else {
-                await this.persistence.renewRunLease({
-                    runId,
-                    workerId: this.workerId,
-                    heartbeatAt: claimedAt,
-                    leaseExpiresAt: new Date(Date.now() + this.concurrencyConfig.leaseMs).toISOString(),
-                });
-            }
-            if (this.concurrencyConfig.heartbeatIntervalMs <= 0) {
-                return;
-            }
-            const timer = setInterval(() => {
-                void this.persistence.renewRunLease({
-                    runId,
-                    workerId: this.workerId,
-                    heartbeatAt: new Date().toISOString(),
-                    leaseExpiresAt: new Date(Date.now() + this.concurrencyConfig.leaseMs).toISOString(),
-                });
-            }, this.concurrencyConfig.heartbeatIntervalMs);
-            timer.unref?.();
-            stopHeartbeat = () => {
-                clearInterval(timer);
-            };
-        };
-        const releaseLease = async () => {
-            stopHeartbeat();
-            if (runId) {
-                await this.persistence.releaseRunClaim(runId);
-            }
-        };
-        const maxConcurrentRuns = this.concurrencyConfig.maxConcurrentRuns;
-        if (!maxConcurrentRuns) {
-            await beginLease("direct-heartbeat");
-            return async () => {
-                await releaseLease();
-            };
+    async prepareRunStart(options, invocation, runCreatedPayload) {
+        const selectedAgentId = await this.resolveSelectedAgentId(options.input, options.agentId, options.threadId);
+        const binding = this.workspace.bindings.get(selectedAgentId);
+        if (!binding) {
+            throw new Error(`Unknown agent ${selectedAgentId}`);
         }
-        const canActivateImmediately = this.activeRunSlots < maxConcurrentRuns;
-        const useDirectHeartbeatFastPath = canActivateImmediately && maxConcurrentRuns > 1;
-        if (canActivateImmediately) {
-            this.activeRunSlots += 1;
-            if (threadId && runId && !useDirectHeartbeatFastPath) {
-                await this.persistence.enqueueRun({ threadId, runId, priority });
-            }
-            await beginLease(useDirectHeartbeatFastPath ? "direct-heartbeat" : "queue-claim");
-            let released = false;
-            return async () => {
-                if (released) {
-                    return;
-                }
-                released = true;
-                await releaseLease();
-                this.activeRunSlots = Math.max(0, this.activeRunSlots - 1);
-                const next = shiftNextPendingRunSlot(this.pendingRunSlots);
-                void next?.activate();
-            };
+        const policyDecision = this.policyEngine.evaluate(binding);
+        if (!policyDecision.allowed) {
+            throw new Error(`Policy evaluation blocked agent ${selectedAgentId}: ${policyDecision.reasons.join(", ")}`);
         }
-        const activateQueuedRun = async () => {
-            const currentRun = runId ? await this.persistence.getRun(runId) : null;
-            if (currentRun?.state === "cancelled") {
-                return "abort";
-            }
-            this.activeRunSlots += 1;
-            if (threadId && runId) {
-                await this.emit(threadId, runId, 4, "run.dequeued", {
-                    queuePosition: 0,
-                    activeRunCount: this.activeRunSlots,
-                    maxConcurrentRuns,
-                    priority,
-                });
-                await this.setRunStateAndEmit(threadId, runId, 5, activeState, {
-                    previousState: "queued",
-                });
-                await beginLease("queue-claim");
-            }
-            return "activate";
+        const priority = normalizeRunPriority(options.priority);
+        const runRequest = buildPersistedRunRequest(options.input, invocation, priority);
+        const { threadId, runId, isNewThread } = await this.ensureThreadStarted(selectedAgentId, binding, options.input, runRequest, options.threadId);
+        return {
+            binding,
+            selectedAgentId,
+            priority,
+            threadId,
+            runId,
+            isNewThread,
+            runCreatedEventPromise: emitRunCreatedEvent({
+                persistence: this.persistence,
+                publishEvent: (event) => this.eventBus.publish(event),
+                trackBackgroundTask: (task) => this.trackBackgroundTask(task),
+                backgroundEventTypes: AgentHarnessRuntime.BACKGROUND_EVENT_TYPES,
+            }, threadId, runId, runCreatedPayload(binding, selectedAgentId)),
+            releaseRunSlotPromise: this.acquireRunSlot(threadId, runId, "running", priority),
         };
-        if (threadId && runId) {
-            await this.persistence.enqueueRun({ threadId, runId, priority });
-            const slotAcquisition = new Promise((resolve, reject) => {
-                const displacedEntries = this.enqueuePendingRunSlot({
-                    threadId,
-                    runId,
-                    priority,
-                    activate: async () => {
-                        try {
-                            resolve(await activateQueuedRun());
-                        }
-                        catch (error) {
-                            reject(error);
-                        }
-                    },
-                    abort: () => resolve("abort"),
-                });
-                void Promise.all(displacedEntries.map((candidate) => this.emit(candidate.threadId, candidate.runId, 3, "run.queued", {
-                    queuePosition: candidate.queuePosition,
-                    activeRunCount: this.activeRunSlots,
-                    maxConcurrentRuns,
-                    priority: candidate.priority,
-                })));
-            });
-            const queuePosition = this.pendingRunSlots.findIndex((entry) => entry.runId === runId) + 1;
-            await this.setRunStateAndEmit(threadId, runId, 2, "queued", {
-                previousState: activeState,
-            });
-            await this.emit(threadId, runId, 3, "run.queued", {
-                queuePosition,
-                activeRunCount: this.activeRunSlots,
-                maxConcurrentRuns,
-                priority,
-            });
-            const slotAcquisitionResult = await slotAcquisition;
-            if (slotAcquisitionResult === "abort") {
-                return async () => undefined;
-            }
-            let released = false;
-            return async () => {
-                if (released) {
-                    return;
-                }
-                released = true;
-                await releaseLease();
-                this.activeRunSlots = Math.max(0, this.activeRunSlots - 1);
-                const next = this.pendingRunSlots.shift();
-                void next?.activate();
-            };
-        }
-        let released = false;
-        return async () => {
-            if (released) {
-                return;
-            }
-            released = true;
-            await releaseLease();
-            this.activeRunSlots = Math.max(0, this.activeRunSlots - 1);
-            const next = shiftNextPendingRunSlot(this.pendingRunSlots);
-            void next?.activate();
+    }
+    createStartupRecoveryContext() {
+        return {
+            persistence: this.persistence,
+            workspace: this.workspace,
+            runtimeAdapter: this.runtimeAdapter,
+            recoveryConfig: this.recoveryConfig,
+            concurrencyConfig: this.concurrencyConfig,
+            getBinding: (agentId) => this.workspace.bindings.get(agentId),
+            acquireRunSlot: (threadId, runId, activeState = "running", priority = 0) => this.acquireRunSlot(threadId, runId, activeState, priority),
+            executeQueuedRun: (binding, input, threadId, runId, agentId, options = {}) => this.executeQueuedRun(binding, input, threadId, runId, agentId, options),
+            setRunStateAndEmit: (threadId, runId, sequence, state, options) => this.setRunStateAndEmit(threadId, runId, sequence, state, options),
+            emit: (threadId, runId, sequence, eventType, payload) => this.emit(threadId, runId, sequence, eventType, payload),
+            loadRunInput: (threadId, runId) => this.loadRunInput(threadId, runId),
+            finalizeContinuedRun: (binding, threadId, runId, input, actual, options) => this.finalizeContinuedRun(binding, threadId, runId, input, actual, options),
+            supportsRunningReplay: (binding) => this.supportsRunningReplay(binding),
+            isStaleRunningRun: (thread, nowMs = Date.now()) => this.isStaleRunningRun(thread, nowMs),
+            recordLlmSuccess: (startedAt) => this.recordLlmSuccess(startedAt),
+            recordLlmFailure: (startedAt) => this.recordLlmFailure(startedAt),
         };
     }
+    async acquireRunSlot(threadId, runId, activeState = "running", priority = 0) {
+        return acquireHarnessRunSlot({
+            persistence: this.persistence,
+            workerId: this.workerId,
+            concurrencyConfig: this.concurrencyConfig,
+            pendingRunSlots: this.pendingRunSlots,
+            getActiveRunSlots: () => this.activeRunSlots,
+            setActiveRunSlots: (count) => {
+                this.activeRunSlots = count;
+            },
+            enqueuePendingRunSlot: (entry) => this.enqueuePendingRunSlot(entry),
+            emit: (currentThreadId, currentRunId, sequence, eventType, payload) => this.emit(currentThreadId, currentRunId, sequence, eventType, payload),
+            setRunStateAndEmit: (currentThreadId, currentRunId, sequence, state, stateOptions) => this.setRunStateAndEmit(currentThreadId, currentRunId, sequence, state, stateOptions),
+        }, {
+            threadId,
+            runId,
+            activeState,
+            priority,
+        });
+    }
     dropPendingRunSlot(runId) {
         return dropPendingRunSlot(this.pendingRunSlots, runId);
     }
@@ -776,32 +628,12 @@ export class AgentHarnessRuntime {
             return this.dispatchRunListeners(this.streamEvents(options), resolvedListeners);
         }
         const invocation = normalizeInvocationEnvelope(options);
-        const selectedAgentId = await resolveSelectedAgentId({
-            workspace: this.workspace,
-            input: options.input,
-            requestedAgentId: options.agentId,
-            threadId: options.threadId,
-            preferredHostAgentId: this.routingDefaultAgentId ?? AgentHarnessRuntime.DEFAULT_HOST_AGENT_ID,
-            getThreadSummary: (threadId) => this.getSession(threadId),
-        });
-        const binding = this.workspace.bindings.get(selectedAgentId);
-        if (!binding) {
-            throw new Error(`Unknown agent ${selectedAgentId}`);
-        }
-        const policyDecision = this.policyEngine.evaluate(binding);
-        if (!policyDecision.allowed) {
-            throw new Error(`Policy evaluation blocked agent ${selectedAgentId}: ${policyDecision.reasons.join(", ")}`);
-        }
-        const priority = normalizeRunPriority(options.priority);
-        const runRequest = buildPersistedRunRequest(options.input, invocation, priority);
-        const { threadId, runId, isNewThread } = await this.ensureThreadStarted(selectedAgentId, binding, options.input, runRequest, options.threadId);
-        const runCreatedEventPromise = this.emitRunCreated(threadId, runId, {
-            agentId: binding.agent.id,
+        const { binding, selectedAgentId, threadId, runId, isNewThread, runCreatedEventPromise, releaseRunSlotPromise, } = await this.prepareRunStart(options, invocation, (activeBinding, activeSelectedAgentId) => ({
+            agentId: activeBinding.agent.id,
             requestedAgentId: options.agentId ?? AUTO_AGENT_ID,
-            selectedAgentId,
-            executionMode: getBindingAdapterKind(binding),
-        });
-        const releaseRunSlotPromise = this.acquireRunSlot(threadId, runId, "running", priority);
+            selectedAgentId: activeSelectedAgentId,
+            executionMode: getBindingAdapterKind(activeBinding),
+        }));
         await runCreatedEventPromise;
         const releaseRunSlot = await releaseRunSlotPromise;
         try {
@@ -821,14 +653,7 @@ export class AgentHarnessRuntime {
     }
     async *streamEvents(options) {
         const invocation = normalizeInvocationEnvelope(options);
-        const selectedAgentId = await resolveSelectedAgentId({
-            workspace: this.workspace,
-            input: options.input,
-            requestedAgentId: options.agentId,
-            threadId: options.threadId,
-            preferredHostAgentId: this.routingDefaultAgentId ?? AgentHarnessRuntime.DEFAULT_HOST_AGENT_ID,
-            getThreadSummary: (threadId) => this.getSession(threadId),
-        });
+        const selectedAgentId = await this.resolveSelectedAgentId(options.input, options.agentId, options.threadId);
         const binding = this.workspace.bindings.get(selectedAgentId);
         if (!binding) {
             const result = await this.run(options);
@@ -843,357 +668,62 @@ export class AgentHarnessRuntime {
             }
             return;
         }
-        let emitted = false;
-        let streamActivityObserved = false;
-        const priority = normalizeRunPriority(options.priority);
-        const runRequest = buildPersistedRunRequest(options.input, invocation, priority);
-        const { threadId, runId, isNewThread } = await this.ensureThreadStarted(selectedAgentId, binding, options.input, runRequest, options.threadId);
-        const priorHistoryPromise = Promise.resolve(isNewThread ? [] : undefined).then((historyHint) => historyHint ?? this.loadPriorHistory(threadId, runId));
-        const runCreatedEventPromise = this.emitRunCreated(threadId, runId, {
-            agentId: selectedAgentId,
+        const { threadId, runId, isNewThread, runCreatedEventPromise, releaseRunSlotPromise, } = await this.prepareRunStart(options, invocation, (_binding, activeSelectedAgentId) => ({
+            agentId: activeSelectedAgentId,
             requestedAgentId: options.agentId ?? AUTO_AGENT_ID,
-            selectedAgentId,
+            selectedAgentId: activeSelectedAgentId,
             input: options.input,
             state: "running",
+        }));
+        yield* streamHarnessRun({
+            binding,
+            input: options.input,
+            invocation,
+            threadId,
+            runId,
+            selectedAgentId,
+            isNewThread,
+            runCreatedEventPromise,
+            releaseRunSlotPromise,
+            loadPriorHistory: (currentThreadId, currentRunId) => this.loadPriorHistory(currentThreadId, currentRunId),
+            stream: (activeBinding, input, currentThreadId, priorHistory, streamOptions) => this.runtimeAdapter.stream(activeBinding, input, currentThreadId, priorHistory, streamOptions),
+            invokeWithHistory: (activeBinding, input, currentThreadId, currentRunId) => this.invokeWithHistory(activeBinding, input, currentThreadId, currentRunId),
+            emit: (currentThreadId, currentRunId, sequence, eventType, payload) => this.emit(currentThreadId, currentRunId, sequence, eventType, payload),
+            setRunStateAndEmit: (currentThreadId, currentRunId, sequence, state, stateOptions) => this.setRunStateAndEmit(currentThreadId, currentRunId, sequence, state, stateOptions),
+            requestApprovalAndEmit: (currentThreadId, currentRunId, input, interruptContent, checkpointRef, sequence) => this.requestApprovalAndEmit(currentThreadId, currentRunId, input, interruptContent, checkpointRef, sequence),
+            appendAssistantMessage: (currentThreadId, currentRunId, content) => appendLifecycleAssistantMessage(this.persistence, currentThreadId, currentRunId, content),
+            clearRunRequest: (currentThreadId, currentRunId) => this.persistence.clearRunRequest(currentThreadId, currentRunId),
+            emitSyntheticFallback: (currentThreadId, currentRunId, currentSelectedAgentId, error) => emitSyntheticFallbackEvent({
+                persistence: this.persistence,
+                publishEvent: (event) => this.eventBus.publish(event),
+                trackBackgroundTask: (task) => this.trackBackgroundTask(task),
+                backgroundEventTypes: AgentHarnessRuntime.BACKGROUND_EVENT_TYPES,
+            }, currentThreadId, currentRunId, currentSelectedAgentId, error),
         });
-        yield { type: "event", event: await runCreatedEventPromise };
-        const releaseRunSlotPromise = this.acquireRunSlot(threadId, runId, "running", priority);
-        let releaseRunSlot = async () => undefined;
-        try {
-            try {
-                const [priorHistory, acquiredReleaseRunSlot] = await Promise.all([
-                    priorHistoryPromise,
-                    releaseRunSlotPromise,
-                ]).then(([loadedPriorHistory, resolvedReleaseRunSlot]) => [loadedPriorHistory, resolvedReleaseRunSlot]);
-                releaseRunSlot = acquiredReleaseRunSlot;
-                let assistantOutput = "";
-                const toolErrors = [];
-                let lastToolResultKey = null;
-                for await (const chunk of this.runtimeAdapter.stream(binding, options.input, threadId, priorHistory, {
-                    context: invocation.context,
-                    state: invocation.state,
-                    files: invocation.files,
-                    runId,
-                })) {
-                    if (chunk) {
-                        streamActivityObserved = true;
-                        const normalizedChunk = typeof chunk === "string"
-                            ? chunk.startsWith(AGENT_INTERRUPT_SENTINEL_PREFIX)
-                                ? { kind: "interrupt", content: chunk.slice(AGENT_INTERRUPT_SENTINEL_PREFIX.length) }
-                                : { kind: "content", content: chunk }
-                            : chunk;
-                        if (normalizedChunk.kind === "upstream-event") {
-                            yield {
-                                type: "upstream-event",
-                                threadId,
-                                runId,
-                                agentId: selectedAgentId,
-                                event: normalizedChunk.event.format === "langgraph-v2"
-                                    ? normalizedChunk.event
-                                    : normalizeUpstreamRuntimeEvent(normalizedChunk.event.raw ?? normalizedChunk.event),
-                            };
-                            continue;
-                        }
-                        if (normalizedChunk.kind === "interrupt") {
-                            const checkpointRef = `checkpoints/${threadId}/${runId}/cp-1`;
-                            const waitingEvent = await this.setRunStateAndEmit(threadId, runId, 6, "waiting_for_approval", {
-                                previousState: "running",
-                                checkpointRef,
-                            });
-                            const approvalRequest = await this.requestApprovalAndEmit(threadId, runId, options.input, normalizedChunk.content, checkpointRef, 7);
-                            yield {
-                                type: "event",
-                                event: waitingEvent,
-                            };
-                            yield {
-                                type: "event",
-                                event: approvalRequest.event,
-                            };
-                            yield {
-                                type: "result",
-                                result: {
-                                    threadId,
-                                    runId,
-                                    agentId: selectedAgentId,
-                                    state: "waiting_for_approval",
-                                    output: assistantOutput,
-                                    finalMessageText: assistantOutput,
-                                    interruptContent: normalizedChunk.content,
-                                    approvalId: approvalRequest.approval.approvalId,
-                                    pendingActionId: approvalRequest.approval.pendingActionId,
-                                },
-                            };
-                            return;
-                        }
-                        if (normalizedChunk.kind === "reasoning") {
-                            await this.emit(threadId, runId, 3, "reasoning.delta", {
-                                content: normalizedChunk.content,
-                            });
-                            yield {
-                                type: "reasoning",
-                                threadId,
-                                runId,
-                                agentId: selectedAgentId,
-                                content: normalizedChunk.content,
-                            };
-                            continue;
-                        }
-                        if (normalizedChunk.kind === "step") {
-                            yield {
-                                type: "step",
-                                threadId,
-                                runId,
-                                agentId: selectedAgentId,
-                                content: normalizedChunk.content,
-                            };
-                            continue;
-                        }
-                        if (normalizedChunk.kind === "tool-result") {
-                            const toolResultKey = this.createToolResultKey(normalizedChunk.toolName, normalizedChunk.output, normalizedChunk.isError);
-                            if (toolResultKey === lastToolResultKey) {
-                                continue;
-                            }
-                            lastToolResultKey = toolResultKey;
-                            if (normalizedChunk.isError) {
-                                toolErrors.push(renderToolFailure(normalizedChunk.toolName, normalizedChunk.output));
-                            }
-                            yield {
-                                type: "tool-result",
-                                threadId,
-                                runId,
-                                agentId: selectedAgentId,
-                                toolName: normalizedChunk.toolName,
-                                output: normalizedChunk.output,
-                                isError: normalizedChunk.isError,
-                            };
-                            continue;
-                        }
-                        emitted = true;
-                        assistantOutput += normalizedChunk.content;
-                        yield await this.emitOutputDeltaAndCreateItem(threadId, runId, selectedAgentId, normalizedChunk.content);
-                    }
-                }
-                if (!assistantOutput && toolErrors.length > 0) {
-                    assistantOutput = toolErrors.join("\n\n");
-                    emitted = true;
-                    yield await this.emitOutputDeltaAndCreateItem(threadId, runId, selectedAgentId, assistantOutput);
-                }
-                if (!assistantOutput) {
-                    const actual = await this.invokeWithHistory(binding, options.input, threadId, runId);
-                    if (Array.isArray(actual.contentBlocks) && actual.contentBlocks.length > 0) {
-                        yield this.createContentBlocksItem(threadId, runId, selectedAgentId, actual.contentBlocks);
-                    }
-                    if (actual.output) {
-                        assistantOutput = actual.output;
-                        emitted = true;
-                        yield await this.emitOutputDeltaAndCreateItem(threadId, runId, selectedAgentId, actual.output);
-                    }
-                }
-                await this.appendAssistantMessage(threadId, runId, assistantOutput);
-                yield {
-                    type: "result",
-                    result: {
-                        threadId,
-                        runId,
-                        agentId: selectedAgentId,
-                        state: "completed",
-                        output: assistantOutput,
-                        finalMessageText: assistantOutput,
-                    },
-                };
-                yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 6, "completed", {
-                        previousState: "running",
-                    }) };
-                return;
-            }
-            catch (error) {
-                if (emitted || streamActivityObserved) {
-                    const runtimeFailure = renderRuntimeFailure(error);
-                    yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 6, "failed", {
-                            previousState: "running",
-                            error: error instanceof Error ? error.message : String(error),
-                        }) };
-                    yield {
-                        type: "content",
-                        threadId,
-                        runId,
-                        agentId: selectedAgentId,
-                        content: runtimeFailure,
-                    };
-                    yield {
-                        type: "result",
-                        result: {
-                            threadId,
-                            runId,
-                            agentId: selectedAgentId,
-                            state: "failed",
-                            output: runtimeFailure,
-                            finalMessageText: runtimeFailure,
-                        },
-                    };
-                    return;
-                }
-                if (error instanceof RuntimeOperationTimeoutError && error.stage === "invoke") {
-                    yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 6, "failed", {
-                            previousState: "running",
-                            error: error.message,
-                        }) };
-                    yield {
-                        type: "content",
-                        threadId,
-                        runId,
-                        agentId: selectedAgentId,
-                        content: renderRuntimeFailure(error),
-                    };
-                    yield {
-                        type: "result",
-                        result: {
-                            threadId,
-                            runId,
-                            agentId: selectedAgentId,
-                            state: "failed",
-                            output: renderRuntimeFailure(error),
-                            finalMessageText: renderRuntimeFailure(error),
-                        },
-                    };
-                    return;
-                }
-                try {
-                    const actual = await this.invokeWithHistory(binding, options.input, threadId, runId);
-                    await this.appendAssistantMessage(threadId, runId, actual.output);
-                    if (Array.isArray(actual.contentBlocks) && actual.contentBlocks.length > 0) {
-                        yield this.createContentBlocksItem(threadId, runId, selectedAgentId, actual.contentBlocks);
-                    }
-                    if (actual.output) {
-                        yield await this.emitOutputDeltaAndCreateItem(threadId, runId, selectedAgentId, actual.output);
-                    }
-                    yield {
-                        type: "result",
-                        result: {
-                            ...actual,
-                            threadId,
-                            runId,
-                            agentId: selectedAgentId,
-                        },
-                    };
-                    yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 6, actual.state, {
-                            previousState: "running",
-                        }) };
-                    return;
-                }
-                catch (invokeError) {
-                    await this.emitSyntheticFallback(threadId, runId, selectedAgentId, invokeError);
-                    yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 6, "failed", {
-                            previousState: "running",
-                            error: invokeError instanceof Error ? invokeError.message : String(invokeError),
-                        }) };
-                    yield {
-                        type: "content",
-                        threadId,
-                        runId,
-                        agentId: selectedAgentId,
-                        content: renderRuntimeFailure(invokeError),
-                    };
-                    yield {
-                        type: "result",
-                        result: {
-                            threadId,
-                            runId,
-                            agentId: selectedAgentId,
-                            state: "failed",
-                            output: renderRuntimeFailure(invokeError),
-                            finalMessageText: renderRuntimeFailure(invokeError),
-                        },
-                    };
-                    return;
-                }
-            }
-        }
-        finally {
-            await this.persistence.clearRunRequest(threadId, runId);
-            await releaseRunSlot();
-        }
     }
     async resume(options) {
-        const approvalById = options.approvalId ? await this.persistence.getApproval(options.approvalId) : null;
-        const thread = options.threadId
-            ? await this.getSession(options.threadId)
-            : approvalById
-                ? await this.getSession(approvalById.threadId)
-                : null;
-        if (!thread) {
-            throw new Error("resume requires either threadId or approvalId");
-        }
-        const approval = approvalById ?? await this.resolveApprovalRecord(options, thread);
-        const threadId = approval.threadId;
-        const runId = approval.runId;
-        const binding = this.workspace.bindings.get(thread.agentId);
-        if (!binding) {
-            throw new Error(`Unknown agent ${thread.agentId}`);
-        }
-        const resumePayload = this.buildResumePayload(binding, approval, options);
-        const cancellation = await this.getRunCancellation(runId);
-        if (cancellation.requested) {
-            return this.finalizeCancelledRun(threadId, runId, thread.status, cancellation.reason);
-        }
-        await this.persistence.setRunState(threadId, runId, "resuming", `checkpoints/${threadId}/${runId}/cp-1`);
-        const releaseRunSlot = await this.acquireRunSlot(threadId, runId, "resuming", await this.resolvePersistedRunPriority(threadId, runId));
-        try {
-            await this.persistence.saveRecoveryIntent(threadId, runId, {
-                kind: "approval-decision",
-                savedAt: new Date().toISOString(),
-                checkpointRef: `checkpoints/${threadId}/${runId}/cp-1`,
-                resumePayload,
-                attempts: 0,
-            });
-            await this.emit(threadId, runId, 5, "run.resumed", {
-                resumeKind: "cross-restart",
-                checkpointRef: `checkpoints/${threadId}/${runId}/cp-1`,
-                state: "resuming",
-                approvalId: approval.approvalId,
-                pendingActionId: approval.pendingActionId,
-            });
-            await this.persistence.resolveApproval(threadId, runId, approval.approvalId, options.decision === "reject" ? "rejected" : options.decision === "edit" ? "edited" : "approved");
-            await this.emit(threadId, runId, 6, "approval.resolved", {
-                approvalId: approval.approvalId,
-                pendingActionId: approval.pendingActionId,
-                decision: options.decision ?? "approve",
-                toolName: approval.toolName,
-            });
-            const history = await this.persistence.listThreadMessages(threadId);
-            const priorHistory = history.filter((message) => message.runId !== runId);
-            const runInput = await this.loadRunInput(threadId, runId);
-            const startedAt = Date.now();
-            try {
-                const actual = await this.runtimeAdapter.invoke(binding, "", threadId, runId, resumePayload, priorHistory);
-                this.recordLlmSuccess(startedAt);
-                const cancelledAfterInvoke = await this.getRunCancellation(runId);
-                if (cancelledAfterInvoke.requested) {
-                    return this.finalizeCancelledRun(threadId, runId, "resuming", cancelledAfterInvoke.reason);
-                }
-                await this.persistence.clearRecoveryIntent(threadId, runId);
-                const finalized = await this.finalizeContinuedRun(binding, threadId, runId, runInput, actual, {
-                    previousState: "resuming",
-                    stateSequence: 7,
-                    approvalSequence: 8,
-                });
-                return {
-                    ...finalized,
-                    approvalId: finalized.approvalId ?? approval.approvalId,
-                    pendingActionId: finalized.pendingActionId ?? approval.pendingActionId,
-                };
-            }
-            catch (error) {
-                this.recordLlmFailure(startedAt);
-                throw error;
-            }
-        }
-        finally {
-            await releaseRunSlot();
-        }
-    }
-    buildResumePayload(binding, approval, options) {
-        return buildHarnessResumePayload(binding, approval, options);
+        return resumeRun({
+            getApprovalById: (approvalId) => this.persistence.getApproval(approvalId),
+            getSession: (threadId) => this.getSession(threadId),
+            resolveApprovalRecord: (resumeOptions, thread) => resolveHarnessApprovalRecord(this.persistence, resumeOptions, thread),
+            getBinding: (agentId) => this.workspace.bindings.get(agentId),
+            buildResumePayload: (binding, approval, resumeOptions) => buildHarnessResumePayload(binding, approval, resumeOptions),
+            getRunCancellation: (runId) => this.getRunCancellation(runId),
+            finalizeCancelledRun: (threadId, runId, previousState, reason) => this.finalizeCancelledRun(threadId, runId, previousState, reason),
+            setRunState: (threadId, runId, state, checkpointRef) => this.persistence.setRunState(threadId, runId, state, checkpointRef),
+            acquireRunSlot: (threadId, runId, activeState, priority) => this.acquireRunSlot(threadId, runId, activeState, priority),
+            resolvePersistedRunPriority: (threadId, runId) => this.resolvePersistedRunPriority(threadId, runId),
+            saveRecoveryIntent: (threadId, runId, payload) => this.persistence.saveRecoveryIntent(threadId, runId, payload),
+            emit: (threadId, runId, sequence, eventType, payload) => this.emit(threadId, runId, sequence, eventType, payload),
+            resolveApproval: (threadId, runId, approvalId, resolution) => this.persistence.resolveApproval(threadId, runId, approvalId, resolution),
+            listThreadMessages: (threadId) => this.persistence.listThreadMessages(threadId),
+            loadRunInput: (threadId, runId) => this.loadRunInput(threadId, runId),
+            invoke: (binding, input, threadId, runId, resumePayload, priorHistory) => this.runtimeAdapter.invoke(binding, input, threadId, runId, resumePayload, priorHistory),
+            recordLlmSuccess: (startedAt) => this.recordLlmSuccess(startedAt),
+            recordLlmFailure: (startedAt) => this.recordLlmFailure(startedAt),
+            clearRecoveryIntent: (threadId, runId) => this.persistence.clearRecoveryIntent(threadId, runId),
+            finalizeContinuedRun: (binding, threadId, runId, input, actual, operationOptions) => this.finalizeContinuedRun(binding, threadId, runId, input, actual, operationOptions),
+        }, options);
     }
     async restartConversation(options) {
         const thread = await this.getSession(options.threadId);
@@ -1232,37 +762,13 @@ export class AgentHarnessRuntime {
         await this.close();
     }
     async cancelRun(options) {
-        const run = await this.persistence.getRun(options.runId);
-        if (!run) {
-            throw new Error(`Unknown run ${options.runId}`);
-        }
-        if (isTerminalRunState(run.state)) {
-            return {
-                threadId: run.threadId,
-                runId: run.runId,
-                agentId: run.agentId,
-                state: run.state,
-                output: run.state,
-            };
-        }
-        await this.persistence.requestRunCancel(run.runId, options.reason);
-        if (run.state === "queued" || run.state === "waiting_for_approval" || run.state === "claimed") {
-            if (run.state === "queued") {
-                this.dropPendingRunSlot(run.runId);
-            }
-            return this.finalizeCancelledRun(run.threadId, run.runId, run.state, options.reason);
-        }
-        await this.setRunStateAndEmit(run.threadId, run.runId, 103, "cancelling", {
-            previousState: run.state,
-            ...(options.reason ? { error: options.reason } : {}),
-        });
-        return {
-            threadId: run.threadId,
-            runId: run.runId,
-            agentId: run.agentId,
-            state: "cancelling",
-            output: options.reason ? `cancelling: ${options.reason}` : "cancelling",
-        };
+        return cancelRunOperation({
+            getRun: (runId) => this.persistence.getRun(runId),
+            requestRunCancel: (runId, reason) => this.persistence.requestRunCancel(runId, reason),
+            dropPendingRunSlot: (runId) => this.dropPendingRunSlot(runId),
+            finalizeCancelledRun: (threadId, runId, previousState, reason) => this.finalizeCancelledRun(threadId, runId, previousState, reason),
+            setRunStateAndEmit: (threadId, runId, sequence, state, stateOptions) => this.setRunStateAndEmit(threadId, runId, sequence, state, stateOptions),
+        }, options);
     }
     async recoverStartupRuns() {
         if (!this.recoveryConfig.enabled) {
@@ -1270,136 +776,14 @@ export class AgentHarnessRuntime {
         }
         await this.reclaimExpiredClaimedRuns();
         const threads = await this.persistence.listSessions();
+        const recoveryContext = this.createStartupRecoveryContext();
         for (const thread of threads) {
-            if (thread.status === "queued") {
-                const runMeta = await this.persistence.getRunMeta(thread.threadId, thread.latestRunId);
-                const binding = this.workspace.bindings.get(runMeta.agentId);
-                if (!binding) {
-                    continue;
-                }
-                const request = await this.persistence.getRunRequest(thread.threadId, thread.latestRunId);
-                if (!request) {
-                    await this.setRunStateAndEmit(thread.threadId, thread.latestRunId, 100, "failed", {
-                        previousState: "queued",
-                        error: "missing persisted run request for queued run recovery",
-                    });
-                    continue;
-                }
-                const releaseRunSlot = await this.acquireRunSlot(thread.threadId, thread.latestRunId, "running", normalizeRunPriority(request.priority));
-                try {
-                    await this.executeQueuedRun(binding, request.input, thread.threadId, thread.latestRunId, runMeta.agentId, {
-                        context: request.invocation?.context,
-                        state: request.invocation?.inputs,
-                        files: request.invocation?.attachments,
-                        previousState: "queued",
-                        stateSequence: 103,
-                        approvalSequence: 104,
-                    });
-                }
-                finally {
-                    await releaseRunSlot();
-                }
-                continue;
-            }
-            if (thread.status === "running") {
-                const isStale = await this.isStaleRunningRun(thread);
-                if (!isStale) {
-                    continue;
-                }
-                const runMeta = await this.persistence.getRunMeta(thread.threadId, thread.latestRunId);
-                const binding = this.workspace.bindings.get(runMeta.agentId);
-                if (!binding) {
-                    continue;
-                }
-                if (!this.supportsRunningReplay(binding)) {
-                    await this.setRunStateAndEmit(thread.threadId, thread.latestRunId, 100, "failed", {
-                        previousState: "running",
-                        error: "stale running run cannot be replayed safely",
-                    });
-                    await this.persistence.releaseRunClaim(thread.latestRunId);
-                    continue;
-                }
-                const request = await this.persistence.getRunRequest(thread.threadId, thread.latestRunId);
-                if (!request) {
-                    await this.setRunStateAndEmit(thread.threadId, thread.latestRunId, 100, "failed", {
-                        previousState: "running",
-                        error: "missing persisted run request for stale running run recovery",
-                    });
-                    await this.persistence.releaseRunClaim(thread.latestRunId);
-                    continue;
-                }
-                const releaseRunSlot = await this.acquireRunSlot(thread.threadId, thread.latestRunId, "running", normalizeRunPriority(request.priority));
-                try {
-                    await this.emit(thread.threadId, thread.latestRunId, 100, "run.resumed", {
-                        resumeKind: "startup-running-recovery",
-                        state: "running",
-                    });
-                    await this.executeQueuedRun(binding, request.input, thread.threadId, thread.latestRunId, runMeta.agentId, {
-                        context: request.invocation?.context,
-                        state: request.invocation?.inputs,
-                        files: request.invocation?.attachments,
-                        previousState: "running",
-                        stateSequence: 103,
-                        approvalSequence: 104,
-                    });
-                }
-                finally {
-                    await releaseRunSlot();
-                }
-                continue;
-            }
-            if (thread.status !== "resuming" || !this.recoveryConfig.resumeResumingRunsOnStartup) {
+            const handled = await recoverQueuedStartupRun(recoveryContext, thread) ||
+                await recoverRunningStartupRun(recoveryContext, thread) ||
+                await recoverResumingStartupRun(recoveryContext, thread);
+            if (handled) {
                 continue;
             }
-            const binding = this.workspace.bindings.get(thread.agentId);
-            if (!binding) {
-                continue;
-            }
-            const recoveryIntent = await this.persistence.getRecoveryIntent(thread.threadId, thread.latestRunId);
-            if (!recoveryIntent || recoveryIntent.kind !== "approval-decision") {
-                continue;
-            }
-            if (recoveryIntent.attempts >= this.recoveryConfig.maxRecoveryAttempts) {
-                await this.persistence.setRunState(thread.threadId, thread.latestRunId, "failed", recoveryIntent.checkpointRef);
-                await this.persistence.clearRecoveryIntent(thread.threadId, thread.latestRunId);
-                continue;
-            }
-            await this.persistence.saveRecoveryIntent(thread.threadId, thread.latestRunId, {
-                ...recoveryIntent,
-                attempts: recoveryIntent.attempts + 1,
-            });
-            await this.emit(thread.threadId, thread.latestRunId, 100, "run.resumed", {
-                resumeKind: "startup-recovery",
-                checkpointRef: recoveryIntent.checkpointRef,
-                state: "resuming",
-            });
-            const history = await this.persistence.listThreadMessages(thread.threadId);
-            const priorHistory = history.filter((message) => message.runId !== thread.latestRunId);
-            const runInput = await this.loadRunInput(thread.threadId, thread.latestRunId);
-            const startedAt = Date.now();
-            try {
-                const actual = await this.runtimeAdapter.invoke(binding, "", thread.threadId, thread.latestRunId, recoveryIntent.resumePayload, priorHistory);
-                this.recordLlmSuccess(startedAt);
-                await this.persistence.clearRecoveryIntent(thread.threadId, thread.latestRunId);
-                await this.finalizeContinuedRun(binding, thread.threadId, thread.latestRunId, runInput, actual, {
-                    previousState: "resuming",
-                    stateSequence: 101,
-                    approvalSequence: 102,
-                });
-            }
-            catch (error) {
-                this.recordLlmFailure(startedAt);
-                if (recoveryIntent.attempts + 1 >= this.recoveryConfig.maxRecoveryAttempts) {
-                    await this.persistence.setRunState(thread.threadId, thread.latestRunId, "failed", recoveryIntent.checkpointRef);
-                    await this.persistence.clearRecoveryIntent(thread.threadId, thread.latestRunId);
-                    await this.emit(thread.threadId, thread.latestRunId, 101, "run.state.changed", {
-                        previousState: "resuming",
-                        state: "failed",
-                        checkpointRef: recoveryIntent.checkpointRef,
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                }
-            }
         }
     }
     async reclaimExpiredClaimedRuns(nowIso = new Date().toISOString()) {