@botbotgo/agent-harness 0.0.99 → 0.0.101

package/dist/runtime/harness.js

@@ -6,26 +6,29 @@ import { normalizeUpstreamRuntimeEvent } from "./parsing/stream-event-parsing.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, getRoutingSystemPrompt, isModelRoutingEnabled, matchRoutingRule, } from "../workspace/support/workspace-ref-utils.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 { 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, reviewCompletedRun as reviewLifecycleCompletedRun, synthesizeCompletedRun as synthesizeLifecycleCompletedRun, } from "./harness/run/run-lifecycle.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 { createContentBlocksItem as createStreamingContentBlocksItem, createToolResultKey as createStreamingToolResultKey, dispatchRunListeners as dispatchStreamingRunListeners, emitOutputDeltaAndCreateItem as emitStreamingOutputDeltaAndCreateItem, } 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 { buildRoutingInput, getDefaultHostAgentId, heuristicHostRoute, resolveSelectedAgentId } from "./harness/run/routing.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";
 import { getBindingAdapterKind, getBindingPrimaryTools, getBindingStoreConfig } from "./support/compiled-binding.js";
 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";
 export class AgentHarnessRuntime {
     workspace;
     runtimeAdapterOptions;
@@ -47,10 +50,8 @@ export class AgentHarnessRuntime {
     vectorStores = new Map();
     defaultStore;
     runtimeMemoryStore;
-    routingSystemPrompt;
     routingRules;
     routingDefaultAgentId;
-    modelRoutingEnabled;
     threadMemorySync;
     unregisterThreadMemorySync;
     resolvedRuntimeAdapterOptions;
@@ -72,15 +73,8 @@ export class AgentHarnessRuntime {
         return (this.listHostBindings()[0]?.harnessRuntime.runRoot ??
             `${this.workspace.workspaceRoot}/run-data`);
     }
-    heuristicRoute(input) {
-        return heuristicHostRoute(this.workspace, input);
-    }
     getDefaultHostAgentId() {
-        return getDefaultHostAgentId(this.workspace, AgentHarnessRuntime.DEFAULT_HOST_AGENT_ID);
-    }
-    async buildRoutingInput(input, threadId) {
-        const history = threadId ? await this.persistence.listThreadMessages(threadId) : [];
-        return buildRoutingInput(input, history);
+        return getDefaultHostAgentId(this.workspace, this.routingDefaultAgentId ?? AgentHarnessRuntime.DEFAULT_HOST_AGENT_ID);
     }
     async resolveSelectedAgentId(input, requestedAgentId, threadId) {
         return resolveSelectedAgentId({
@@ -88,56 +82,48 @@ export class AgentHarnessRuntime {
             input,
             requestedAgentId,
             threadId,
-            preferredHostAgentId: AgentHarnessRuntime.DEFAULT_HOST_AGENT_ID,
+            preferredHostAgentId: this.routingDefaultAgentId ?? AgentHarnessRuntime.DEFAULT_HOST_AGENT_ID,
             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)),
         };
         this.runtimeAdapter = new AgentRuntimeAdapter(this.resolvedRuntimeAdapterOptions);
-        this.routingSystemPrompt = getRoutingSystemPrompt(workspace.refs);
         this.routingRules = getRoutingRules(workspace.refs);
         this.routingDefaultAgentId = getRoutingDefaultAgentId(workspace.refs);
-        this.modelRoutingEnabled = isModelRoutingEnabled(workspace.refs);
-        this.threadMemorySync = new ThreadMemorySync(this.persistence, this.runtimeMemoryStore);
-        this.unregisterThreadMemorySync = this.eventBus.registerProjection(this.threadMemorySync);
+        if (isThreadMemorySyncEnabled(workspace)) {
+            this.threadMemorySync = new ThreadMemorySync(this.persistence, this.runtimeMemoryStore);
+            this.unregisterThreadMemorySync = this.eventBus.registerProjection(this.threadMemorySync);
+        }
+        else {
+            this.threadMemorySync = null;
+            this.unregisterThreadMemorySync = () => { };
+        }
         const checkpointMaintenanceConfig = readCheckpointMaintenanceConfig(workspace);
         this.checkpointMaintenance = checkpointMaintenanceConfig
             ? new CheckpointMaintenanceLoop(discoverCheckpointMaintenanceTargets(workspace), checkpointMaintenanceConfig)
@@ -148,8 +134,12 @@ export class AgentHarnessRuntime {
             : null;
         this.recoveryConfig = getRecoveryConfig(workspace.refs);
         this.concurrencyConfig = getConcurrencyConfig(workspace.refs);
-        this.healthMonitor = new HealthMonitor({
-            workspace,
+        const healthConfig = readHealthMonitorConfig(workspace);
+        this.healthMonitor = healthConfig.enabled ? this.createHealthMonitor() : null;
+    }
+    createHealthMonitor() {
+        return new HealthMonitor({
+            workspace: this.workspace,
             persistence: this.persistence,
             getActiveRunSlots: () => this.activeRunSlots,
             getPendingRunSlots: () => this.pendingRunSlots.length,
@@ -160,35 +150,34 @@ export class AgentHarnessRuntime {
             },
         });
     }
+    recordLlmSuccess(startedAt) {
+        this.healthMonitor?.recordLlmSuccess(Date.now() - startedAt);
+    }
+    recordLlmFailure(startedAt) {
+        this.healthMonitor?.recordLlmFailure(Date.now() - startedAt);
+    }
     async initialize() {
         await this.persistence.initialize();
         await this.checkpointMaintenance?.start();
         await this.runtimeRecordMaintenance?.start();
-        await this.healthMonitor.start();
+        await this.healthMonitor?.start();
         await this.recoverStartupRuns();
     }
     subscribe(listener) {
         return this.eventBus.subscribe(listener);
     }
     async getHealth() {
-        return this.healthMonitor.getSnapshot();
-    }
-    getBinding(agentId) {
-        return this.workspace.bindings.get(agentId);
-    }
-    listAgentTools(agentId) {
-        const binding = this.getBinding(agentId);
-        if (!binding) {
-            throw new Error(`Unknown agent ${agentId}`);
+        if (this.healthMonitor) {
+            return this.healthMonitor.getSnapshot();
         }
-        return getBindingPrimaryTools(binding);
+        return createDefaultHealthSnapshot(this.activeRunSlots, this.pendingRunSlots.length);
     }
     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) => ({
@@ -256,10 +245,16 @@ export class AgentHarnessRuntime {
         return approval ? toPublicApprovalRecord(approval) : null;
     }
     listAgentSkills(agentId, options = {}) {
-        return listWorkspaceAgentSkills(this.workspace, agentId, options);
+        return listWorkspaceAgentSkills(this.workspace, agentId, {
+            assessRequirements: isInventoryEnabled(this.workspace),
+            ...options,
+        });
     }
     describeWorkspaceInventory(options = {}) {
-        return describeWorkspaceInventory(this.workspace, options);
+        return describeWorkspaceInventory(this.workspace, {
+            assessRequirements: isInventoryEnabled(this.workspace),
+            ...options,
+        });
     }
     async deleteThreadCheckpoints(threadId) {
         const resolver = this.resolvedRuntimeAdapterOptions.checkpointerResolver;
@@ -311,10 +306,7 @@ export class AgentHarnessRuntime {
         return serveToolsOverStdioFromHarness(tools, options);
     }
     async routeAgent(input, options = {}) {
-        const routingHistory = options.threadId ? await this.persistence.listThreadMessages(options.threadId) : [];
-        const routingInput = buildRoutingInput(input, routingHistory);
         const rawInput = extractMessageText(input);
-        const { primaryBinding, secondaryBinding } = inferRoutingBindings(this.workspace);
         const configuredRule = this.routingRules.find((rule) => matchRoutingRule(rawInput, rule, options));
         if (configuredRule) {
             const configuredBinding = this.workspace.bindings.get(configuredRule.agentId);
@@ -322,25 +314,13 @@ export class AgentHarnessRuntime {
                 return configuredBinding.agent.id;
             }
         }
-        if (!this.modelRoutingEnabled) {
-            const defaultBinding = this.routingDefaultAgentId
-                ? this.workspace.bindings.get(this.routingDefaultAgentId)
-                : primaryBinding;
-            if (defaultBinding && isRuntimeEntryBinding(defaultBinding)) {
-                return defaultBinding.agent.id;
-            }
-        }
-        if (!primaryBinding || !secondaryBinding) {
-            return heuristicHostRoute(this.workspace, rawInput);
-        }
-        try {
-            return await this.runtimeAdapter.route(routingInput, primaryBinding, secondaryBinding, {
-                systemPrompt: this.routingSystemPrompt,
-            });
-        }
-        catch {
-            return heuristicHostRoute(this.workspace, rawInput);
+        const defaultBinding = this.routingDefaultAgentId
+            ? this.workspace.bindings.get(this.routingDefaultAgentId)
+            : undefined;
+        if (defaultBinding && isRuntimeEntryBinding(defaultBinding)) {
+            return defaultBinding.agent.id;
         }
+        return this.getDefaultHostAgentId();
     }
     async emit(threadId, runId, sequence, eventType, payload, source = "runtime") {
         return emitHarnessEvent({
@@ -415,9 +395,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 {
@@ -425,12 +402,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,
@@ -443,11 +414,11 @@ export class AgentHarnessRuntime {
         const startedAt = Date.now();
         try {
             const result = await this.runtimeAdapter.invoke(binding, input, threadId, runId, resumePayload, history, options);
-            this.healthMonitor.recordLlmSuccess(Date.now() - startedAt);
+            this.recordLlmSuccess(startedAt);
             return result;
         }
         catch (error) {
-            this.healthMonitor.recordLlmFailure(Date.now() - startedAt);
+            this.recordLlmFailure(startedAt);
             throw error;
         }
     }
@@ -506,7 +477,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),
@@ -523,47 +499,14 @@ 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,
             emit: (currentThreadId, currentRunId, sequence, eventType, payload, source) => this.emit(currentThreadId, currentRunId, sequence, eventType, payload, source),
             setRunStateAndEmit: (currentThreadId, currentRunId, sequence, state, lifecycleOptions) => this.setRunStateAndEmit(currentThreadId, currentRunId, sequence, state, lifecycleOptions),
             requestApprovalAndEmit: (currentThreadId, currentRunId, lifecycleInput, interruptContent, checkpointRef, sequence) => this.requestApprovalAndEmit(currentThreadId, currentRunId, lifecycleInput, interruptContent, checkpointRef, sequence),
-            synthesizeFinalResult: (currentBinding, lifecycleInput, lifecycleActual) => this.runtimeAdapter.synthesizeFinalResult(currentBinding, lifecycleInput, lifecycleActual),
-            reviewRunResult: (currentBinding, lifecycleInput, lifecycleActual) => this.runtimeAdapter.reviewRunResult(currentBinding, lifecycleInput, lifecycleActual),
         }, binding, threadId, runId, input, actual, options);
     }
-    async synthesizeCompletedRun(binding, input, actual) {
-        return synthesizeLifecycleCompletedRun({
-            synthesizeFinalResult: (currentBinding, lifecycleInput, lifecycleActual) => this.runtimeAdapter.synthesizeFinalResult(currentBinding, lifecycleInput, lifecycleActual),
-        }, binding, input, actual);
-    }
-    async reviewCompletedRun(binding, threadId, runId, input, actual) {
-        return reviewLifecycleCompletedRun({
-            reviewRunResult: (currentBinding, lifecycleInput, lifecycleActual) => this.runtimeAdapter.reviewRunResult(currentBinding, lifecycleInput, lifecycleActual),
-            emit: (currentThreadId, currentRunId, sequence, eventType, payload, source) => this.emit(currentThreadId, currentRunId, sequence, eventType, payload, source),
-        }, binding, threadId, runId, input, actual);
-    }
-    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,
@@ -580,25 +523,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;
     }
@@ -608,6 +532,55 @@ export class AgentHarnessRuntime {
         }
         await listener(value);
     }
+    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 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);
+        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),
+        };
+    }
+    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) {
         let stopHeartbeat = () => undefined;
         const beginLease = async (mode) => {
@@ -788,32 +761,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: 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 {
@@ -833,14 +786,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: 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);
@@ -857,268 +803,268 @@ export class AgentHarnessRuntime {
         }
         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",
-        });
+        }));
+        const priorHistoryPromise = Promise.resolve(isNewThread ? [] : undefined).then((historyHint) => historyHint ?? this.loadPriorHistory(threadId, runId));
         yield { type: "event", event: await runCreatedEventPromise };
-        const releaseRunSlotPromise = this.acquireRunSlot(threadId, runId, "running", priority);
         let releaseRunSlot = async () => undefined;
+        const emitOutputDelta = (content) => emitStreamingOutputDeltaAndCreateItem((currentThreadId, currentRunId, sequence, eventType, payload) => this.emit(currentThreadId, currentRunId, sequence, eventType, payload), threadId, runId, selectedAgentId, content);
         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",
+            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,
-                                content: normalizedChunk.content,
-                            };
+                                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 = createStreamingToolResultKey(normalizedChunk.toolName, normalizedChunk.output, normalizedChunk.isError);
+                        if (toolResultKey === lastToolResultKey) {
                             continue;
                         }
-                        if (normalizedChunk.kind === "step") {
-                            yield {
-                                type: "step",
-                                threadId,
-                                runId,
-                                agentId: selectedAgentId,
-                                content: normalizedChunk.content,
-                            };
-                            continue;
+                        lastToolResultKey = toolResultKey;
+                        if (normalizedChunk.isError) {
+                            toolErrors.push(renderToolFailure(normalizedChunk.toolName, normalizedChunk.output));
                         }
-                        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);
+                        yield {
+                            type: "tool-result",
+                            threadId,
+                            runId,
+                            agentId: selectedAgentId,
+                            toolName: normalizedChunk.toolName,
+                            output: normalizedChunk.output,
+                            isError: normalizedChunk.isError,
+                        };
+                        continue;
                     }
-                }
-                if (!assistantOutput && toolErrors.length > 0) {
-                    assistantOutput = toolErrors.join("\n\n");
                     emitted = true;
-                    yield await this.emitOutputDeltaAndCreateItem(threadId, runId, selectedAgentId, assistantOutput);
+                    assistantOutput += normalizedChunk.content;
+                    yield await emitOutputDelta(normalizedChunk.content);
                 }
-                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);
-                    }
+            }
+            if (!assistantOutput && toolErrors.length > 0) {
+                assistantOutput = toolErrors.join("\n\n");
+                emitted = true;
+                yield await emitOutputDelta(assistantOutput);
+            }
+            if (!assistantOutput) {
+                const actual = await this.invokeWithHistory(binding, options.input, threadId, runId);
+                if (Array.isArray(actual.contentBlocks) && actual.contentBlocks.length > 0) {
+                    yield createStreamingContentBlocksItem(threadId, runId, selectedAgentId, actual.contentBlocks);
                 }
-                await this.appendAssistantMessage(threadId, runId, assistantOutput);
+                if (actual.output) {
+                    assistantOutput = actual.output;
+                    emitted = true;
+                    yield await emitOutputDelta(actual.output);
+                }
+            }
+            await appendLifecycleAssistantMessage(this.persistence, 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: "completed",
-                        output: assistantOutput,
-                        finalMessageText: assistantOutput,
+                        state: "failed",
+                        output: runtimeFailure,
+                        finalMessageText: runtimeFailure,
                     },
                 };
-                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",
+            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,
-                        content: runtimeFailure,
-                    };
-                    yield {
-                        type: "result",
-                        result: {
-                            threadId,
-                            runId,
-                            agentId: selectedAgentId,
-                            state: "failed",
-                            output: runtimeFailure,
-                            finalMessageText: runtimeFailure,
-                        },
-                    };
-                    return;
+                        state: "failed",
+                        output: renderRuntimeFailure(error),
+                        finalMessageText: renderRuntimeFailure(error),
+                    },
+                };
+                return;
+            }
+            try {
+                const actual = await this.invokeWithHistory(binding, options.input, threadId, runId);
+                await appendLifecycleAssistantMessage(this.persistence, threadId, runId, actual.output);
+                if (Array.isArray(actual.contentBlocks) && actual.contentBlocks.length > 0) {
+                    yield createStreamingContentBlocksItem(threadId, runId, selectedAgentId, actual.contentBlocks);
                 }
-                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",
+                if (actual.output) {
+                    yield await emitOutputDelta(actual.output);
+                }
+                yield {
+                    type: "result",
+                    result: {
+                        ...actual,
                         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",
+                    },
+                };
+                yield { type: "event", event: await this.setRunStateAndEmit(threadId, runId, 6, actual.state, {
+                        previousState: "running",
+                    }) };
+                return;
+            }
+            catch (invokeError) {
+                await emitSyntheticFallbackEvent({
+                    persistence: this.persistence,
+                    publishEvent: (event) => this.eventBus.publish(event),
+                    trackBackgroundTask: (task) => this.trackBackgroundTask(task),
+                    backgroundEventTypes: AgentHarnessRuntime.BACKGROUND_EVENT_TYPES,
+                }, 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,
-                        content: renderRuntimeFailure(invokeError),
-                    };
-                    yield {
-                        type: "result",
-                        result: {
-                            threadId,
-                            runId,
-                            agentId: selectedAgentId,
-                            state: "failed",
-                            output: renderRuntimeFailure(invokeError),
-                            finalMessageText: renderRuntimeFailure(invokeError),
-                        },
-                    };
-                    return;
-                }
+                        state: "failed",
+                        output: renderRuntimeFailure(invokeError),
+                        finalMessageText: renderRuntimeFailure(invokeError),
+                    },
+                };
+                return;
             }
         }
         finally {
@@ -1136,14 +1082,14 @@ export class AgentHarnessRuntime {
         if (!thread) {
             throw new Error("resume requires either threadId or approvalId");
         }
-        const approval = approvalById ?? await this.resolveApprovalRecord(options, thread);
+        const approval = approvalById ?? await resolveHarnessApprovalRecord(this.persistence, 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 resumePayload = buildHarnessResumePayload(binding, approval, options);
         const cancellation = await this.getRunCancellation(runId);
         if (cancellation.requested) {
             return this.finalizeCancelledRun(threadId, runId, thread.status, cancellation.reason);
@@ -1178,7 +1124,7 @@ export class AgentHarnessRuntime {
             const startedAt = Date.now();
             try {
                 const actual = await this.runtimeAdapter.invoke(binding, "", threadId, runId, resumePayload, priorHistory);
-                this.healthMonitor.recordLlmSuccess(Date.now() - startedAt);
+                this.recordLlmSuccess(startedAt);
                 const cancelledAfterInvoke = await this.getRunCancellation(runId);
                 if (cancelledAfterInvoke.requested) {
                     return this.finalizeCancelledRun(threadId, runId, "resuming", cancelledAfterInvoke.reason);
@@ -1196,7 +1142,7 @@ export class AgentHarnessRuntime {
                 };
             }
             catch (error) {
-                this.healthMonitor.recordLlmFailure(Date.now() - startedAt);
+                this.recordLlmFailure(startedAt);
                 throw error;
             }
         }
@@ -1204,9 +1150,6 @@ export class AgentHarnessRuntime {
             await releaseRunSlot();
         }
     }
-    buildResumePayload(binding, approval, options) {
-        return buildHarnessResumePayload(binding, approval, options);
-    }
     async restartConversation(options) {
         const thread = await this.getSession(options.threadId);
         if (!thread) {
@@ -1233,12 +1176,12 @@ export class AgentHarnessRuntime {
         };
     }
     async close() {
-        await this.healthMonitor.stop();
+        await this.healthMonitor?.stop();
         await this.checkpointMaintenance?.stop();
         await this.runtimeRecordMaintenance?.stop();
         this.unregisterThreadMemorySync();
         await Promise.allSettled(Array.from(this.backgroundTasks));
-        await this.threadMemorySync.close();
+        await this.threadMemorySync?.close();
     }
     async stop() {
         await this.close();
@@ -1282,136 +1225,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) {
-                continue;
-            }
-            const binding = this.workspace.bindings.get(thread.agentId);
-            if (!binding) {
+            const handled = await recoverQueuedStartupRun(recoveryContext, thread) ||
+                await recoverRunningStartupRun(recoveryContext, thread) ||
+                await recoverResumingStartupRun(recoveryContext, thread);
+            if (handled) {
                 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.healthMonitor.recordLlmSuccess(Date.now() - 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.healthMonitor.recordLlmFailure(Date.now() - 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()) {
@@ -1459,4 +1280,3 @@ export class AgentHarnessRuntime {
         return nowMs - heartbeatAtMs >= this.concurrencyConfig.heartbeatTimeoutMs;
     }
 }
-export { AgentHarnessRuntime as AgentHarness };