@botbotgo/agent-harness 0.0.101 → 0.0.103

package/dist/runtime/harness.js

@@ -1,13 +1,12 @@
 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 "./maintenance/checkpoint-maintenance.js";
@@ -15,12 +14,14 @@ import { RuntimeRecordMaintenanceLoop, discoverRuntimeRecordMaintenanceTargets,
 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 { buildPersistedRunRequest, normalizeInvocationEnvelope, normalizeRunPriority, resolveRunListeners, } from "./harness/run/helpers.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 { 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,7 +29,9 @@ 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 { initializeHarnessRuntime, isStaleRunningRun as isHarnessStaleRunningRun, reclaimExpiredClaimedRuns as reclaimHarnessExpiredClaimedRuns, recoverStartupRuns as recoverHarnessStartupRuns, } from "./harness/run/startup-runtime.js";
+import { streamHarnessRun } from "./harness/run/stream-run.js";
+import { deleteThreadRecord, getPublicApproval, getThreadRecord, listPublicApprovals, } from "./harness/run/thread-records.js";
 export class AgentHarnessRuntime {
     workspace;
     runtimeAdapterOptions;
@@ -157,11 +160,13 @@ export class AgentHarnessRuntime {
         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.recoverStartupRuns();
+        await initializeHarnessRuntime({
+            persistence: this.persistence,
+            checkpointMaintenance: this.checkpointMaintenance,
+            runtimeRecordMaintenance: this.runtimeRecordMaintenance,
+            healthMonitor: this.healthMonitor,
+            recoverStartupRuns: () => this.recoverStartupRuns(),
+        });
     }
     subscribe(listener) {
         return this.eventBus.subscribe(listener);
@@ -202,47 +207,20 @@ export class AgentHarnessRuntime {
         return this.persistence.getSession(threadId);
     }
     async getThread(threadId) {
-        const [threadSummary, meta, messages, runs] = await Promise.all([
-            this.getSession(threadId),
-            this.persistence.getThreadMeta(threadId),
-            this.persistence.listThreadMessages(threadId, 200),
-            this.persistence.listThreadRuns(threadId),
-        ]);
-        if (!threadSummary || !meta) {
-            return null;
-        }
-        const latestRunId = threadSummary.latestRunId;
-        const latestApprovals = await this.persistence.getRunApprovals(threadId, latestRunId);
-        const pendingApproval = latestApprovals
-            .filter((approval) => approval.status === "pending")
-            .sort((left, right) => right.requestedAt.localeCompare(left.requestedAt))[0];
-        return {
-            threadId,
-            entryAgentId: meta.entryAgentId,
-            currentState: threadSummary.status,
-            latestRunId,
-            createdAt: meta.createdAt,
-            updatedAt: threadSummary.updatedAt,
-            messages,
-            runs,
-            pendingDecision: pendingApproval
-                ? {
-                    approvalId: pendingApproval.approvalId,
-                    pendingActionId: pendingApproval.pendingActionId,
-                    toolName: pendingApproval.toolName,
-                    allowedDecisions: pendingApproval.allowedDecisions,
-                    requestedAt: pendingApproval.requestedAt,
-                }
-                : undefined,
-        };
+        return getThreadRecord({
+            persistence: this.persistence,
+            getSession: (currentThreadId) => this.getSession(currentThreadId),
+        }, threadId);
     }
     async listApprovals(filter) {
-        const approvals = await this.persistence.listApprovals(filter);
-        return approvals.map((approval) => toPublicApprovalRecord(approval));
+        return listPublicApprovals({
+            persistence: this.persistence,
+        }, filter);
     }
     async getApproval(approvalId) {
-        const approval = await this.persistence.getApproval(approvalId);
-        return approval ? toPublicApprovalRecord(approval) : null;
+        return getPublicApproval({
+            persistence: this.persistence,
+        }, approvalId);
     }
     listAgentSkills(agentId, options = {}) {
         return listWorkspaceAgentSkills(this.workspace, agentId, {
@@ -275,19 +253,11 @@ export class AgentHarnessRuntime {
         }
     }
     async deleteThread(threadId) {
-        const thread = await this.getThread(threadId);
-        if (!thread) {
-            return false;
-        }
-        const activeRun = thread.runs.find((run) => !isTerminalRunState(run.state));
-        if (activeRun) {
-            throw new Error(`Cannot delete thread ${threadId} while run ${activeRun.runId} is ${activeRun.state}`);
-        }
-        const deleted = await this.persistence.deleteThread(threadId);
-        if (deleted) {
-            await this.deleteThreadCheckpoints(threadId);
-        }
-        return deleted;
+        return deleteThreadRecord({
+            getThread: (currentThreadId) => this.getThread(currentThreadId),
+            deleteThread: (currentThreadId) => this.persistence.deleteThread(currentThreadId),
+            deleteThreadCheckpoints: (currentThreadId) => this.deleteThreadCheckpoints(currentThreadId),
+        }, threadId);
     }
     async createToolMcpServer(options) {
         const tools = this.resolveAgentTools(options.agentId).map(({ compiledTool, resolvedTool }) => ({
@@ -582,159 +552,24 @@ export class AgentHarnessRuntime {
         };
     }
     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();
-            };
-        }
-        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 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";
-        };
-        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();
-        };
+        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);
@@ -801,8 +636,6 @@ export class AgentHarnessRuntime {
             }
             return;
         }
-        let emitted = false;
-        let streamActivityObserved = false;
         const { threadId, runId, isNewThread, runCreatedEventPromise, releaseRunSlotPromise, } = await this.prepareRunStart(options, invocation, (_binding, activeSelectedAgentId) => ({
             agentId: activeSelectedAgentId,
             requestedAgentId: options.agentId ?? AUTO_AGENT_ID,
@@ -810,345 +643,55 @@ export class AgentHarnessRuntime {
             input: options.input,
             state: "running",
         }));
-        const priorHistoryPromise = Promise.resolve(isNewThread ? [] : undefined).then((historyHint) => historyHint ?? this.loadPriorHistory(threadId, runId));
-        yield { type: "event", event: await runCreatedEventPromise };
-        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 {
-            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 = createStreamingToolResultKey(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 emitOutputDelta(normalizedChunk.content);
-                }
-            }
-            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);
-                }
-                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: "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 appendLifecycleAssistantMessage(this.persistence, threadId, runId, actual.output);
-                if (Array.isArray(actual.contentBlocks) && actual.contentBlocks.length > 0) {
-                    yield createStreamingContentBlocksItem(threadId, runId, selectedAgentId, actual.contentBlocks);
-                }
-                if (actual.output) {
-                    yield await emitOutputDelta(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 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,
-                        state: "failed",
-                        output: renderRuntimeFailure(invokeError),
-                        finalMessageText: renderRuntimeFailure(invokeError),
-                    },
-                };
-                return;
-            }
-        }
-        finally {
-            await this.persistence.clearRunRequest(threadId, runId);
-            await releaseRunSlot();
-        }
+        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),
+        });
     }
     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 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 = buildHarnessResumePayload(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();
-        }
+        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);
@@ -1187,96 +730,35 @@ 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) {
-            return;
-        }
-        await this.reclaimExpiredClaimedRuns();
-        const threads = await this.persistence.listSessions();
-        const recoveryContext = this.createStartupRecoveryContext();
-        for (const thread of threads) {
-            const handled = await recoverQueuedStartupRun(recoveryContext, thread) ||
-                await recoverRunningStartupRun(recoveryContext, thread) ||
-                await recoverResumingStartupRun(recoveryContext, thread);
-            if (handled) {
-                continue;
-            }
-        }
+        await recoverHarnessStartupRuns({
+            recoveryConfig: this.recoveryConfig,
+            persistence: this.persistence,
+            createStartupRecoveryContext: () => this.createStartupRecoveryContext(),
+            reclaimExpiredClaimedRuns: (nowIso) => this.reclaimExpiredClaimedRuns(nowIso),
+        });
     }
     async reclaimExpiredClaimedRuns(nowIso = new Date().toISOString()) {
-        const expiredClaims = await this.persistence.listExpiredClaimedRuns(nowIso);
-        for (const claim of expiredClaims) {
-            const thread = await this.persistence.getSession(claim.threadId);
-            if (!thread) {
-                await this.persistence.releaseRunClaim(claim.runId);
-                continue;
-            }
-            const lifecycle = await this.persistence.getRunLifecycle(claim.threadId, claim.runId);
-            if (lifecycle.state === "claimed") {
-                await this.persistence.enqueueRun({
-                    threadId: claim.threadId,
-                    runId: claim.runId,
-                    priority: claim.priority,
-                    queueKey: claim.queueKey,
-                    availableAt: nowIso,
-                });
-                await this.setRunStateAndEmit(claim.threadId, claim.runId, 99, "queued", {
-                    previousState: "claimed",
-                });
-                await this.emit(claim.threadId, claim.runId, 100, "run.queued", {
-                    queuePosition: 0,
-                    activeRunCount: this.activeRunSlots,
-                    maxConcurrentRuns: this.concurrencyConfig.maxConcurrentRuns,
-                    recoveredOnStartup: true,
-                    reclaimReason: "expired-lease",
-                });
-                continue;
-            }
-            await this.persistence.releaseRunClaim(claim.runId);
-        }
+        await reclaimHarnessExpiredClaimedRuns({
+            persistence: this.persistence,
+            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),
+            concurrencyConfig: this.concurrencyConfig,
+            getActiveRunSlots: () => this.activeRunSlots,
+        }, nowIso);
     }
     async isStaleRunningRun(thread, nowMs = Date.now()) {
-        const control = await this.persistence.getRunControl(thread.latestRunId);
-        const heartbeatAt = control?.heartbeatAt;
-        if (!heartbeatAt) {
-            return true;
-        }
-        const heartbeatAtMs = Date.parse(heartbeatAt);
-        if (!Number.isFinite(heartbeatAtMs)) {
-            return true;
-        }
-        return nowMs - heartbeatAtMs >= this.concurrencyConfig.heartbeatTimeoutMs;
+        return isHarnessStaleRunningRun({
+            persistence: this.persistence,
+            concurrencyConfig: this.concurrencyConfig,
+        }, thread, nowMs);
     }
 }