@assemblyline-agents/runtime 0.1.0

package/dist/index.js

@@ -0,0 +1,2046 @@
+import { createHash } from "node:crypto";
+import { join, resolve } from "node:path";
+import { builtInToolDefinition } from "./builtin-tools.js";
+export { builtInToolDefaults } from "./builtin-tools.js";
+import { createHookDispatcher } from "./hook-dispatch.js";
+import { resolveEvalToolStub, validateEvalRunOptions } from "./eval-run-options.js";
+import { resolveRunCapabilitiesImpl } from "./run-resolver.js";
+import { AgentSourceModuleLoader } from "./source-loader.js";
+import { compiledChannelProvider, providerIngressSecurityError, providerIngressSecurityWarnings, resolveCoreToolPolicy, trustedAttachmentProviderForTurn } from "./security.js";
+export { constantTimeSecretEqual } from "./security.js";
+export { RUN_STREAM_TERMINAL_EVENTS } from "./run-stream.js";
+export { failRun } from "./run-outcome.js";
+import { OPENEVE_MANIFEST_SCHEMA_VERSION, applyEnvAliases, hasCurrentSandboxFilesystemContract, sandboxFilesystemContractMetadata } from "@assemblyline-agents/core";
+import { resolveBooleanEnv, resolveNonNegativeIntegerEnv, resolvePositiveIntegerEnv } from "./env-config.js";
+import { RunEventBus, withRunEventPublishing } from "./run-stream.js";
+import { handleRunExecutionError, logTerminalRunEvent, settleCompletionBoundaryControlImpl } from "./run-outcome.js";
+import { registerRunAbortController, startRunHeartbeatImpl } from "./run-heartbeat.js";
+import { redactTruncateJson } from "./content-capture.js";
+import { sandboxSessionKeyForRun } from "./sandbox-session-key.js";
+export { sandboxSessionKeyForRun } from "./sandbox-session-key.js";
+import { InMemoryConnectionAuthorizationSessionStore, InMemoryConnectionGrantStore, materializeConnectionCredentialsIntoSandbox } from "./connections.js";
+import { InMemoryConnectionDefinitionStore, InMemoryScheduleStore, InMemorySkillStore, compiledConnectionFromStored, isHostAllowed, liveSkills, resolveSkillsConfig, resolveSchedulesConfig, resolveConnectionsConfig, seedSkills, writeSkill } from "./self-improvement.js";
+import { materializeTurnAttachments } from "./attachments.js";
+// Attachment helpers for channel modules implementing `resolveAttachment`.
+export { attachmentFetchTimeoutMs, attachmentRemoteUrl, attachmentTrustedForProvider, firstDownloadableUrl } from "./attachments.js";
+import { LocalSandboxAdapter } from "./local-sandbox.js";
+import { schedulerAdapterForKind } from "./scheduler.js";
+import { isTelemetrySink, telemetrySinkFromSetupResult } from "./telemetry.js";
+import { InMemoryStateAdapter, LocalBlobAdapter, StateMemoryStore, memoryBodyText, positiveLimit } from "./storage.js";
+import { createJsonConsoleLogger, normalizeLogLevel } from "./logging.js";
+import { runDueDeliveriesImpl, startDeliveryWorkerImpl } from "./delivery-queue.js";
+import { recoverIncompleteRunsImpl, startBackgroundWorkersImpl } from "./run-recovery.js";
+import { captureSandboxSnapshotImpl, disposeSandboxSessionImpl, inspectSandboxSyncJobImpl, retrySandboxSyncJobImpl, runDueSandboxSyncJobsImpl, sandboxSyncDiagnosticsImpl, startSandboxSyncWorkerImpl } from "./sandbox-sync-worker.js";
+import { beginChannelTurnImpl, completeRunImpl, enqueueSandboxSyncAfterDeliveryImpl, latestRunFailureMessageImpl, recordChannelTurnStartImpl, sendDeliveryImpl, stopUnclaimedChannelTurnImpl, stopChannelTurnImpl } from "./delivery-send.js";
+import { backfillMemoryDocumentsFromFileIndexesImpl, hydrateLogicalPathForToolImpl, listResourcesForRunImpl, memoryScopeForRunImpl, projectResourcesForRunImpl, projectSkillIntoSandboxImpl, readResourceForRunImpl, readSandboxTombstonesWithMissingProjectedFilesImpl, recordSandboxTombstoneImpl, runMemoryEmbeddingBackfillImpl } from "./resource-projection.js";
+import { beginConnectionAuthorizationImpl, createConnectionRegistryForRunImpl, createConnectionRegistryForSessionImpl, createConnectionRegistryImpl, executeConnectionToolWithRecordImpl, skillLoadDetailsImpl } from "./builtin-tool-executors.js";
+import { createMemoryToolApiImpl, createResourceToolApiImpl, durableStepImpl } from "./tool-apis.js";
+import { executeToolImpl, executeToolWithRecordImpl, harnessExecuteToolImpl, modelToolsImpl, selectToolImpl, visibleToolSetImpl, wrapSandboxImpl } from "./tool-execution.js";
+import { dispatchAutomationEventImpl, normalizeScheduleTriggerDefinitionImpl, registerManifestSchedulesImpl, runDueSchedulesImpl, startSchedulerPollingLoopImpl } from "./schedule-execution.js";
+import { completeConnectionAuthorizationCallbackImpl, replayImpl, resumeApprovalNowImpl, resumeHarnessLoopImpl, resumeInputNowImpl, resumeRunFromContinuationImpl, resumeSuspendedNowImpl } from "./replay-resume.js";
+import { readSubagentImpl, runSubagentImpl, sendSubagentFollowupImpl } from "./subagent-execution.js";
+import { createHarnessContextImpl, DEFAULT_MAX_MODEL_ITERATIONS, DEFAULT_OUTPUT_VALIDATION_MAX_RETRIES, executeHarnessTurnImpl, persistHarnessContinuationImpl, piHarnessImpl, resolveAgentHarnessImpl, runHarnessLoopImpl } from "./harness-loop.js";
+import { getAgentControlImpl, requestRunControlImpl, setAgentEnabledImpl, setAgentMaintenanceImpl } from "./operator-controls.js";
+import { acceptChannelTurnImpl, channelAttachmentResolverImpl, dispatchHttpChannelImpl, loadChannelModuleImpl, startChannelIngressImpl } from "./channel-ingress.js";
+import { augmentChannelContextImpl, buildContextBundleImpl, prepareConversationImpl, recentHistoryImpl } from "./conversation-context.js";
+import { loadResumableConversationTranscriptImpl } from "./conversation-transcript.js";
+import { ConversationTurnDispatcher } from "./conversation-turn-dispatch.js";
+import { instructionsForRunTargetImpl } from "./run-resolver.js";
+import { emitTelemetrySpanImpl, runSpanAttributesImpl } from "./telemetry.js";
+import { normalizeRuntimeState } from "./state-stores.js";
+import { COMPACTABLE_ACTIVE_CHECKPOINT_NAMES, checkpointDataForStorage as checkpointDataForBlobStorage, emptyCheckpointRetentionResult, hydrateCheckpointData as hydrateCheckpointDataFromBlob, resolveCheckpointRetentionPolicy } from "./checkpoints.js";
+// State record types, capability facets (RunStore & friends), the
+// StateAdapter intersection, StateStores, and the capability guards.
+export * from "./state.js";
+export { evalRunOptionsForRun, validateEvalRunOptions } from "./eval-run-options.js";
+export { InMemoryConversationStore, InMemoryConversationTurnStore, InMemoryFileIndexStore, InMemoryMemoryStateStore, InMemoryRunStore, InMemorySandboxSessionStore, InMemoryScheduleStateStore, InMemoryUsageStore, composeStateStores, normalizeRuntimeState } from "./state-stores.js";
+export { applyDeliveryPatch, createDeliveryRecord, deliveryQueueRetryDelayMs, isDeliveryDue, normalizeDeliveryRecord, stateSupportsDeliveryQueue } from "./delivery-queue.js";
+export { defaultRunStaleAfterMs } from "./run-recovery.js";
+export { BoundedSemaphore, RunCapacityError, retryAfterSeconds } from "./concurrency.js";
+import { BoundedSemaphore, RunCapacityError } from "./concurrency.js";
+import { DEFAULT_MODEL_OUTPUT_MAX_CHARS } from "@assemblyline-agents/core";
+export { FileConnectionAuthorizationSessionStore, FileConnectionGrantStore, InMemoryConnectionAuthorizationSessionStore, InMemoryConnectionGrantStore, RuntimeConnectionRegistry, connectionToolAccess } from "./connections.js";
+export { FileConnectionDefinitionStore, FileScheduleStore, FileSkillStore, InMemoryConnectionDefinitionStore, InMemoryScheduleStore, InMemorySkillStore, computeNextRun, resolveSkillsConfig, resolveSchedulesConfig, resolveConnectionsConfig } from "./self-improvement.js";
+export { LocalSandboxAdapter } from "./local-sandbox.js";
+export { FileMemoryStore, FileStateAdapter, InMemoryMemoryStore, InMemoryStateAdapter, LocalBlobAdapter, StateMemoryStore } from "./storage.js";
+export { gatewaySchedulerAdapter, localSchedulerAdapter, postgresSchedulerAdapter, schedulerAdapterForKind } from "./scheduler.js";
+export { createOpenTelemetrySink } from "./telemetry.js";
+export { createJsonConsoleLogger, noopLogger, normalizeLogLevel } from "./logging.js";
+export { capabilityCatalogForManifest, capabilityForModel, capabilityMatchesId, connectionSearchResultForModel, normalizeCapabilityKind, normalizeCapabilityRouterInput, normalizeDeferredToolSearchInput, routerShouldSearchConnections, scoreCapability, searchCapabilityCatalog, tokenizeCapabilityQuery } from "./capability-catalog.js";
+export { fetchJson, fetchWithPolicy, readBodyCapped, retryAfterMs, HttpResponseTooLargeError } from "./http.js";
+import { hydrateSandboxFilesystem, memoryPathFromSandboxRelativePath, scanSandboxFiles, visibleToolsForSkills } from "./sandbox-fs.js";
+export { buildDefaultContextBundle, hydrateSandboxFilesystem, syncSandboxFilesystem, visibleToolsForSkills } from "./sandbox-fs.js";
+export { queryAgentRuns } from "./runs-query.js";
+export { UsageAccountingError, createUsageRecord, matchesUsageQuery, microsToUsd, queryUsageRecords, reconcileUsageRecord, sha256Json, summarizeUsageRecords, usageTokensAreAuthoritative, usageRecordInput, usdToMicros } from "./usage-records.js";
+export { reconcileOpenAIOrganization, reconcileOpenRouterUsage, usageReconciliationReport } from "./usage-reconciliation.js";
+import { isValidSandboxSkillBody, resolveResourceProjectionPolicy, sandboxFileContentsToUtf8, sha256Text, skillNameFromSandboxRelativePath, skillNameFromSkillPath } from "./resource-projection-util.js";
+import { resolveSandboxSnapshotPolicy } from "./sandbox-snapshot-policy.js";
+import { inferToolInput } from "./channel-http-util.js";
+import { connectionPrincipalKeyForGrant, durableAgentScopeForManifest, isInstrumentationDefinition, normalizeCapturePolicy, randomHex, stringValue, timestamp, } from "./runtime-util.js";
+export { currentModulePath, durableAgentScopeForManifest } from "./runtime-util.js";
+export { loadRuntimeBundle } from "./runtime-bundle.js";
+export class OpenEveRuntime {
+    manifest;
+    state;
+    runEventBus = new RunEventBus();
+    blob;
+    sandbox;
+    scheduler;
+    deliveryMode;
+    toolStubs;
+    /** Per-run {results:[...]} stub cursors; in-memory by design (see eval-run-options.ts). */
+    evalStubCursors = new Map();
+    /** @deprecated See {@link RuntimeOptions.models}. */
+    models;
+    agentHarnessOverride;
+    modelHarnesses;
+    defaultAgentHarness;
+    checkpointEveryIteration;
+    checkpointRetention;
+    checkpointBlobStorageEnabled;
+    devMode;
+    sourceBundle;
+    connections;
+    env;
+    fetch;
+    logger;
+    connectionGrantStore;
+    connectionAuthorizationSessionStore;
+    connectionCallbackBaseUrl;
+    skillStore;
+    memoryStore;
+    scheduleStore;
+    connectionDefinitionStore;
+    skillsConfig;
+    schedulesConfig;
+    connectionsConfig;
+    skillsSeeded = false;
+    skillScopeMigrated = false;
+    connectionScopeMigrated = false;
+    dynamicConnectionsCache;
+    schedulerEnabled;
+    schedulerTickMs;
+    scheduleMaxConsecutiveFailures;
+    now;
+    sandboxSnapshotPolicy;
+    sandboxSyncInline;
+    sandboxSyncLeaseMs;
+    sandboxSyncBatchSize;
+    sandboxSyncMaxAttempts;
+    deliveryQueueLeaseMs;
+    toolOutputMaxChars;
+    toolTimeoutMs;
+    deliveryQueueBatchSize;
+    deliveryQueueMaxAttempts;
+    deliveryQueueIntervalMs;
+    runHeartbeatMs;
+    runRecoveryIntervalMs;
+    maxModelIterations;
+    outputValidationMaxRetries;
+    runSemaphore;
+    conversationTurnDispatcher;
+    memoryEmbeddingProvider;
+    memoryEmbeddingsEnabled;
+    resourceProjectionPolicy;
+    coreToolPolicy;
+    telemetry;
+    instrumentationLoaded = false;
+    providerIngressSecurityLogged = false;
+    hostTelemetryProvided;
+    hostInstrumentationProvided;
+    instrumentationConfig;
+    sourceLoader;
+    contextPolicyPromise;
+    /** Fast local view of durable control intents, refreshed by run heartbeats. */
+    runControlIntents = new Map();
+    /** Deadline-fired runs (read by shouldStopRun) + their in-flight abort controllers. */
+    runDeadlines = new Set();
+    runAbortControllers = new Map();
+    maxRunDurationMs;
+    constructor(options) {
+        this.manifest = options.manifest;
+        const normalizedState = normalizeRuntimeState(options.state ?? new InMemoryStateAdapter());
+        // Events fan out to live streams; terminal outcomes become log lines at
+        // this one choke point (logger read lazily — assigned below).
+        this.state = withRunEventPublishing(normalizedState.state, this.runEventBus, (runId, event) => logTerminalRunEvent(this.logger, runId, event), (runId, event) => this.dispatchHookEvent(runId, event));
+        this.blob = options.blob ?? new LocalBlobAdapter();
+        this.sandbox = options.sandbox ?? new LocalSandboxAdapter();
+        this.scheduler = options.scheduler ?? schedulerAdapterForKind(this.manifest.gateway.scheduler?.kind);
+        this.deliveryMode = options.deliveryMode ?? "send";
+        this.toolStubs = options.toolStubs ?? {};
+        this.devMode = options.devMode ?? false;
+        this.sourceBundle = options.sourceBundle ?? {};
+        this.connections = options.connections ?? {};
+        this.env = applyEnvAliases(options.env ?? process.env).env;
+        this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+        this.logger = options.logger ??
+            createJsonConsoleLogger({ level: normalizeLogLevel(this.env.OPENEVE_LOG_LEVEL) ?? "info" });
+        if (normalizedState.degradedFacets.length > 0) {
+            this.logger.warn("state.degraded", {
+                missingFacets: normalizedState.degradedFacets,
+                detail: "optional state facets not configured; using non-durable in-memory fallbacks"
+            });
+        }
+        this.coreToolPolicy = resolveCoreToolPolicy(options.coreToolPolicy, this.env, this.devMode);
+        this.models = options.models;
+        this.agentHarnessOverride = options.agentHarness;
+        this.modelHarnesses = options.modelHarnesses ?? {};
+        this.checkpointEveryIteration = resolveBooleanEnv(this.env.OPENEVE_CHECKPOINT_EVERY_ITERATION, true);
+        this.checkpointRetention = resolveCheckpointRetentionPolicy(options.checkpointRetention, this.env);
+        this.checkpointBlobStorageEnabled = options.blob !== undefined && this.checkpointRetention.blobThresholdBytes > 0;
+        this.telemetry = options.telemetry;
+        this.hostTelemetryProvided = options.telemetry !== undefined;
+        this.hostInstrumentationProvided = options.instrumentation !== undefined;
+        const override = options.instrumentation;
+        this.instrumentationConfig = {
+            recordInputs: override?.recordInputs ?? false,
+            recordOutputs: override?.recordOutputs ?? false,
+            functionId: override?.functionId ?? override?.serviceName ?? this.agentName(),
+            serviceName: override?.serviceName ?? this.agentName(),
+            contentCapture: normalizeCapturePolicy(override?.captureContent)
+        };
+        this.connectionGrantStore = options.connectionGrantStore ?? new InMemoryConnectionGrantStore();
+        this.connectionAuthorizationSessionStore = options.connectionAuthorizationSessionStore ?? new InMemoryConnectionAuthorizationSessionStore();
+        this.connectionCallbackBaseUrl = options.connectionCallbackBaseUrl;
+        this.skillStore = options.skillStore ?? new InMemorySkillStore();
+        this.memoryEmbeddingProvider = options.memoryEmbeddingProvider;
+        const memoryEmbeddingsRequested = options.memoryEmbeddingsEnabled ??
+            resolveBooleanEnv(this.env.OPENEVE_MEMORY_EMBEDDINGS_ENABLED, Boolean(options.memoryEmbeddingProvider));
+        const memoryEmbeddingStoreAvailable = this.state.supportsMemoryEmbeddings?.() ?? true;
+        this.memoryEmbeddingsEnabled = memoryEmbeddingsRequested && memoryEmbeddingStoreAvailable;
+        if (memoryEmbeddingsRequested && !memoryEmbeddingStoreAvailable) {
+            this.logger.warn("memory.embeddings_unavailable", {
+                detail: "semantic memory is disabled because the configured state store does not have its optional vector backend enabled"
+            });
+        }
+        this.memoryStore = options.memoryStore ?? new StateMemoryStore(this.state, this.memoryEmbeddingProvider, this.memoryEmbeddingsEnabled);
+        this.scheduleStore = options.scheduleStore ?? new InMemoryScheduleStore();
+        this.connectionDefinitionStore = options.connectionDefinitionStore ?? new InMemoryConnectionDefinitionStore();
+        this.skillsConfig = resolveSkillsConfig(this.manifest.agent.selfImprovement, this.env);
+        this.schedulesConfig = resolveSchedulesConfig(this.manifest.agent.dynamicAutomations ?? this.manifest.agent.dynamicSchedules, this.env);
+        this.connectionsConfig = resolveConnectionsConfig(this.manifest.agent.dynamicConnections, this.env);
+        this.schedulerEnabled = options.schedulerEnabled;
+        this.schedulerTickMs = options.schedulerTickMs ?? 60_000;
+        this.scheduleMaxConsecutiveFailures = resolvePositiveIntegerEnv(this.env.OPENEVE_SCHEDULE_MAX_FAILURES, 5);
+        this.now = options.now ?? (() => new Date());
+        this.sandboxSnapshotPolicy = resolveSandboxSnapshotPolicy(this.manifest, this.env, options.sandboxSnapshotPolicy);
+        this.sandboxSyncInline = options.sandboxSyncInline ?? resolveBooleanEnv(this.env.OPENEVE_SANDBOX_SYNC_INLINE, false);
+        this.sandboxSyncLeaseMs = options.sandboxSyncLeaseMs ?? resolvePositiveIntegerEnv(this.env.OPENEVE_SANDBOX_SYNC_LEASE_MS, 5 * 60_000);
+        this.sandboxSyncBatchSize = options.sandboxSyncBatchSize ?? resolvePositiveIntegerEnv(this.env.OPENEVE_SANDBOX_SYNC_BATCH_SIZE, 10);
+        this.sandboxSyncMaxAttempts = options.sandboxSyncMaxAttempts ?? resolvePositiveIntegerEnv(this.env.OPENEVE_SANDBOX_SYNC_MAX_ATTEMPTS, 5);
+        this.deliveryQueueLeaseMs = options.deliveryQueueLeaseMs ?? resolvePositiveIntegerEnv(this.env.OPENEVE_DELIVERY_QUEUE_LEASE_MS, 60_000);
+        this.toolOutputMaxChars = resolvePositiveIntegerEnv(this.env.OPENEVE_TOOL_OUTPUT_MAX_CHARS, DEFAULT_MODEL_OUTPUT_MAX_CHARS);
+        this.toolTimeoutMs = resolveNonNegativeIntegerEnv(this.env.OPENEVE_TOOL_TIMEOUT_MS, 600_000);
+        this.deliveryQueueBatchSize = options.deliveryQueueBatchSize ?? resolvePositiveIntegerEnv(this.env.OPENEVE_DELIVERY_QUEUE_BATCH_SIZE, 10);
+        this.deliveryQueueMaxAttempts = options.deliveryQueueMaxAttempts ?? resolvePositiveIntegerEnv(this.env.OPENEVE_DELIVERY_QUEUE_MAX_ATTEMPTS, 5);
+        this.deliveryQueueIntervalMs = options.deliveryQueueIntervalMs ?? resolvePositiveIntegerEnv(this.env.OPENEVE_DELIVERY_QUEUE_INTERVAL_MS, 15_000);
+        this.runHeartbeatMs = options.runHeartbeatMs ?? resolvePositiveIntegerEnv(this.env.OPENEVE_RUN_HEARTBEAT_MS, 30_000);
+        this.maxRunDurationMs = options.maxRunDurationMs ?? resolveNonNegativeIntegerEnv(this.env.OPENEVE_MAX_RUN_DURATION_MS, 3_600_000);
+        this.runRecoveryIntervalMs = options.runRecoveryIntervalMs ?? resolvePositiveIntegerEnv(this.env.OPENEVE_RUN_RECOVERY_INTERVAL_MS, 60_000);
+        this.maxModelIterations = resolvePositiveIntegerEnv(this.env.OPENEVE_MAX_MODEL_ITERATIONS, DEFAULT_MAX_MODEL_ITERATIONS);
+        this.outputValidationMaxRetries = resolveNonNegativeIntegerEnv(this.env.OPENEVE_OUTPUT_VALIDATION_MAX_RETRIES, DEFAULT_OUTPUT_VALIDATION_MAX_RETRIES);
+        this.runSemaphore = new BoundedSemaphore({
+            maxConcurrent: options.maxConcurrentRuns ?? resolvePositiveIntegerEnv(this.env.OPENEVE_MAX_CONCURRENT_RUNS, Infinity),
+            maxQueued: options.maxQueuedRuns ?? resolvePositiveIntegerEnv(this.env.OPENEVE_MAX_QUEUED_RUNS, 0)
+        });
+        this.conversationTurnDispatcher = new ConversationTurnDispatcher({
+            state: this.state, logger: this.logger,
+            agentScope: this.durableAgentScope(), maxRunDurationMs: this.maxRunDurationMs,
+            now: () => this.now(), agentEnabled: () => this.agentEnabled(),
+            admitRunOrReject: () => this.admitRunOrReject(),
+            runTurn: (turn, admission, onRunCreated) => this.run({
+                message: turn.message,
+                channel: turn.channel, turn, admission, startChannelTurnEarly: true,
+                onRunCreated
+            })
+        });
+        this.resourceProjectionPolicy = resolveResourceProjectionPolicy(options.resourceProjectionPolicy, this.env);
+        this.sourceLoader = new AgentSourceModuleLoader({
+            manifest: this.manifest,
+            sourceBundle: this.sourceBundle,
+            ...(options.artifactRoot ? { cacheRoot: join(resolve(options.artifactRoot), ".assembly-line", "module-cache") } : {})
+        });
+    }
+    boot() {
+        if (this.manifest.schemaVersion !== OPENEVE_MANIFEST_SCHEMA_VERSION) {
+            throw new Error(`Unsupported OpenEve manifest schema ${this.manifest.schemaVersion}.`);
+        }
+        if (!this.devMode) {
+            const missing = this.manifest.preflight.filter((requirement) => requirement.kind === "env" &&
+                requirement.required &&
+                requirement.name !== "RAILWAY_TOKEN" &&
+                ![requirement.name, ...(requirement.alternatives ?? [])]
+                    .some((name) => Boolean(this.env[name]?.trim())));
+            if (missing.length > 0) {
+                throw new Error(`Missing required runtime bindings: ${missing
+                    .map((requirement) => [requirement.name, ...(requirement.alternatives ?? [])].join(" or "))
+                    .join(", ")}`);
+            }
+            this.validateProviderIngressSecurity();
+        }
+        else {
+            this.logDevProviderIngressSecurity();
+        }
+    }
+    validateProviderIngressSecurity() {
+        const error = providerIngressSecurityError(this.manifest.channels, this.env);
+        if (error)
+            throw new Error(error);
+    }
+    debugSwallow(message, fields) {
+        return (error) => {
+            this.logger.debug(message, { ...fields, error: error instanceof Error ? error.message : String(error) });
+            return undefined;
+        };
+    }
+    warnSwallow(message, fields) {
+        return (error) => {
+            this.logger.warn(message, { ...fields, error: error instanceof Error ? error.message : String(error) });
+            return undefined;
+        };
+    }
+    async compactCheckpoints(options = {}) {
+        if (!this.state.compactCheckpoints)
+            return emptyCheckpointRetentionResult(options.dryRun === true);
+        return this.state.compactCheckpoints({
+            maxActivePerRunName: this.checkpointRetention.maxActivePerRunName,
+            activeNames: COMPACTABLE_ACTIVE_CHECKPOINT_NAMES,
+            terminalTtlMs: this.checkpointRetention.terminalTtlMs,
+            failedRunTtlMs: this.checkpointRetention.failedRunTtlMs,
+            scheduledRunTtlMs: this.checkpointRetention.scheduledRunTtlMs,
+            now: this.now(),
+            ...options
+        });
+    }
+    async createCheckpoint(input) {
+        const storedData = await this.checkpointDataForStorage(input.runId, input.name, input.data);
+        const checkpoint = await this.state.createCheckpoint({ ...input, data: storedData });
+        if (COMPACTABLE_ACTIVE_CHECKPOINT_NAMES.includes(input.name)) {
+            await this.compactCheckpoints({
+                runId: input.runId,
+                activeNames: COMPACTABLE_ACTIVE_CHECKPOINT_NAMES,
+                terminalTtlMs: undefined,
+                failedRunTtlMs: undefined,
+                scheduledRunTtlMs: undefined
+            }).catch(this.warnSwallow("checkpoint active compaction failed", { runId: input.runId, checkpointName: input.name }));
+        }
+        return { ...checkpoint, data: input.data };
+    }
+    async listHydratedCheckpoints(runId) {
+        const checkpoints = await this.state.listCheckpoints(runId);
+        return Promise.all(checkpoints.map(async (checkpoint) => ({
+            ...checkpoint,
+            data: await this.hydrateCheckpointData(checkpoint.data)
+        })));
+    }
+    async checkpointDataForStorage(runId, name, data) {
+        return checkpointDataForBlobStorage({ blob: this.blob, enabled: this.checkpointBlobStorageEnabled, thresholdBytes: this.checkpointRetention.blobThresholdBytes, runId, name, data });
+    }
+    async hydrateCheckpointData(data) { return hydrateCheckpointDataFromBlob(data, this.blob); }
+    logDevProviderIngressSecurity() {
+        if (this.providerIngressSecurityLogged)
+            return;
+        const warnings = providerIngressSecurityWarnings(this.manifest.channels, this.env);
+        if (warnings.length === 0)
+            return;
+        this.providerIngressSecurityLogged = true;
+        for (const warning of warnings) {
+            this.logger.warn("provider ingress security warning", { warning });
+        }
+    }
+    skillScope() {
+        return this.durableAgentScope();
+    }
+    connectionScope() {
+        return this.durableAgentScope();
+    }
+    durableAgentScope() {
+        return durableAgentScopeForManifest(this.manifest);
+    }
+    usesRevisionScopedDurableState() {
+        return this.durableAgentScope() === this.manifest.agentRevision;
+    }
+    scheduleScopeForRun(run) {
+        const userId = typeof run.input.userId === "string" ? run.input.userId : undefined;
+        const conversationId = typeof run.input.conversationId === "string" ? run.input.conversationId : undefined;
+        return userId ?? conversationId ?? this.manifest.agentRevision;
+    }
+    /** Seed the durable skill store from compiled manifest skills (idempotent). */
+    async ensureSkillsSeeded() {
+        if (this.skillsSeeded)
+            return;
+        await this.migrateLegacySkillScope();
+        await seedSkills(this.skillStore, this.skillScope(), this.manifest.skills);
+        this.skillsSeeded = true;
+    }
+    async migrateLegacySkillScope() {
+        if (this.skillScopeMigrated)
+            return;
+        this.skillScopeMigrated = true;
+        const scope = this.skillScope();
+        const legacyScope = this.manifest.agentRevision;
+        if (scope === legacyScope)
+            return;
+        const current = await this.skillStore.list(scope);
+        if (current.length > 0)
+            return;
+        for (const skill of await this.skillStore.list(legacyScope)) {
+            await this.skillStore.put(scope, skill);
+        }
+    }
+    async migrateLegacyConnectionScope() {
+        if (this.connectionScopeMigrated)
+            return;
+        this.connectionScopeMigrated = true;
+        const scope = this.connectionScope();
+        const legacyScope = this.manifest.agentRevision;
+        if (scope === legacyScope)
+            return;
+        const current = await this.connectionDefinitionStore.list(scope);
+        if (current.length > 0)
+            return;
+        for (const definition of await this.connectionDefinitionStore.list(legacyScope)) {
+            await this.connectionDefinitionStore.put(scope, { ...definition, scope });
+        }
+    }
+    /** Live skill catalog (durable store, post-seed) for context assembly and inspection. */
+    async listSkills() {
+        await this.ensureSkillsSeeded();
+        return liveSkills(this.skillStore, this.skillScope());
+    }
+    /** Persist an agent/user authored skill, honoring the write-approval gate. */
+    async saveSkill(input) {
+        if (!this.skillsConfig.writable) {
+            throw new Error("Skill writing is disabled (selfImprovement.writable is false).");
+        }
+        await this.ensureSkillsSeeded();
+        const writeInput = { name: input.name, body: input.body };
+        if (input.origin)
+            writeInput.origin = input.origin;
+        const record = await writeSkill(this.skillStore, this.skillScope(), writeInput, {
+            requireApproval: this.skillsConfig.writeApproval
+        });
+        return { name: record.name, pending: record.pending ?? false };
+    }
+    async deleteSkill(name) {
+        if (!this.skillsConfig.writable) {
+            throw new Error("Skill writing is disabled (selfImprovement.writable is false).");
+        }
+        await this.ensureSkillsSeeded();
+        await this.skillStore.delete(this.skillScope(), name);
+    }
+    async createDynamicSchedule(input) {
+        if (!this.schedulesConfig.dynamic) {
+            throw new Error("Dynamic automations are disabled (dynamicAutomations.dynamic is false).");
+        }
+        const trigger = input.trigger ? this.normalizeScheduleTriggerDefinition(input.trigger) : undefined;
+        const prompt = stringValue(input.prompt) || stringValue(input.message) || (trigger ? `Run scheduled trigger ${trigger.handler}.` : "");
+        if (!prompt)
+            throw new Error("Dynamic schedules require prompt or message.");
+        const createInput = {
+            ...input,
+            prompt
+        };
+        if (input.message)
+            createInput.message = input.message;
+        if (trigger)
+            createInput.trigger = trigger;
+        return this.scheduleStore.create(createInput);
+    }
+    async createDynamicAutomation(input) {
+        return this.createDynamicSchedule(input);
+    }
+    async listDynamicSchedules(scope) {
+        return this.scheduleStore.list(scope);
+    }
+    async listDynamicAutomations(scope) {
+        return this.listDynamicSchedules(scope);
+    }
+    async updateDynamicSchedule(scope, id, patch) {
+        if (!this.schedulesConfig.dynamic) {
+            throw new Error("Dynamic automations are disabled (dynamicAutomations.dynamic is false).");
+        }
+        const normalized = { ...patch };
+        if (Object.prototype.hasOwnProperty.call(patch, "trigger")) {
+            const rawTrigger = patch.trigger;
+            normalized.trigger = rawTrigger === null ? null : this.normalizeScheduleTriggerDefinition(rawTrigger);
+        }
+        return this.scheduleStore.update(scope, id, normalized);
+    }
+    async updateDynamicAutomation(scope, id, patch) {
+        return this.updateDynamicSchedule(scope, id, patch);
+    }
+    async deleteDynamicSchedule(scope, id) {
+        return this.scheduleStore.delete(scope, id);
+    }
+    async deleteDynamicAutomation(scope, id) {
+        return this.deleteDynamicSchedule(scope, id);
+    }
+    /** Persist a runtime-provided connection definition (gated). Credentials route to the grant store. */
+    async saveConnectionDefinition(input) {
+        if (!this.connectionsConfig.dynamic) {
+            throw new Error("Dynamic connections are disabled (dynamicConnections.dynamic is false).");
+        }
+        if (input.protocol === "mcp" && (input.definition.transport === "stdio"
+            || "command" in input.definition
+            || "args" in input.definition
+            || "cwd" in input.definition
+            || "env" in input.definition)) {
+            throw new Error("Dynamic MCP connections are URL-only and cannot launch host processes.");
+        }
+        const url = typeof input.definition.url === "string" ? input.definition.url : undefined;
+        if (input.protocol === "mcp" && !url) {
+            throw new Error("Dynamic MCP connections must provide an HTTP url.");
+        }
+        if (url && !isHostAllowed(url, this.connectionsConfig.allowedHosts)) {
+            throw new Error(`Connection host is not allowlisted: ${url}`);
+        }
+        await this.migrateLegacyConnectionScope();
+        const scope = input.scope ?? this.connectionScope();
+        const now = timestamp();
+        await this.connectionDefinitionStore.put(scope, {
+            name: input.name,
+            scope,
+            protocol: input.protocol,
+            description: input.description,
+            definition: input.definition,
+            origin: "agent",
+            createdAt: now,
+            updatedAt: now
+        });
+        if (input.grant) {
+            const principal = input.grant.principal ?? { type: "app" };
+            await this.connectionGrantStore.saveGrant({
+                connectionName: input.name,
+                principalKey: input.grant.principalKey ?? connectionPrincipalKeyForGrant(principal),
+                principal,
+                token: input.grant.token,
+                createdAt: now,
+                updatedAt: now
+            });
+        }
+        this.dynamicConnectionsCache = undefined;
+        return { name: input.name };
+    }
+    async listConnectionDefinitions(scope) {
+        await this.migrateLegacyConnectionScope();
+        const stored = await this.connectionDefinitionStore.list(scope ?? this.connectionScope());
+        return stored.map((definition) => ({
+            name: definition.name,
+            protocol: definition.protocol,
+            description: definition.description,
+            origin: definition.origin
+        }));
+    }
+    async deleteConnectionDefinition(name, scope) {
+        await this.migrateLegacyConnectionScope();
+        await this.connectionDefinitionStore.delete(scope ?? this.connectionScope(), name);
+        this.dynamicConnectionsCache = undefined;
+    }
+    async syncMemoryFromSandbox(run, sandboxSession, tombstones) {
+        const scope = this.memoryScopeForRun(run);
+        const deleted = [];
+        const tombstonedPaths = new Set(tombstones
+            .map((tombstone) => tombstone.path)
+            .filter((path) => path.startsWith("/memory/")));
+        for (const path of tombstonedPaths) {
+            await this.state.deleteMemoryDocument(scope, path);
+            deleted.push(path);
+        }
+        let files;
+        try {
+            files = await scanSandboxFiles(sandboxSession, "/memory");
+        }
+        catch {
+            return { written: [], deleted };
+        }
+        const written = [];
+        for (const file of files) {
+            const path = memoryPathFromSandboxRelativePath(file.relativePath);
+            if (!path || tombstonedPaths.has(path))
+                continue;
+            const content = sandboxFileContentsToUtf8(file.contents);
+            const current = await this.memoryStore.read(scope, { path });
+            if (current && memoryBodyText(current) === content)
+                continue;
+            await this.memoryStore.write(scope, {
+                path,
+                content,
+                mode: "replace",
+                metadata: {
+                    tags: ["sandbox"],
+                    sourceRefs: [`sandbox:${run.id}`]
+                }
+            });
+            written.push(path);
+        }
+        if (written.length > 0 || deleted.length > 0) {
+            await this.state.appendEvent(run.id, "memory.documents_synced", {
+                written,
+                deleted
+            });
+        }
+        return { written, deleted };
+    }
+    /** Reconcile skill files the agent explicitly edited/deleted under `/skills`. */
+    async syncSkillsFromSandbox(run, sandboxSession, tombstones) {
+        let files;
+        try {
+            files = await scanSandboxFiles(sandboxSession, "/skills");
+        }
+        catch {
+            files = [];
+        }
+        const skillScope = this.skillScope();
+        const before = await this.skillStore.list(skillScope);
+        const beforeByName = new Map(before.map((skill) => [skill.name, skill]));
+        const deletedSkillNames = new Set(tombstones
+            .map((tombstone) => skillNameFromSkillPath(tombstone.path))
+            .filter((name) => Boolean(name)));
+        const sandboxSkills = [];
+        const invalid = [];
+        for (const file of files) {
+            const name = skillNameFromSandboxRelativePath(file.relativePath);
+            if (!name) {
+                if (file.relativePath.endsWith("SKILL.md"))
+                    invalid.push(file.relativePath);
+                continue;
+            }
+            const body = sandboxFileContentsToUtf8(file.contents);
+            if (!isValidSandboxSkillBody(body)) {
+                invalid.push(`/skills/${file.relativePath}`);
+                continue;
+            }
+            sandboxSkills.push({ name, body });
+        }
+        const changed = sandboxSkills.filter((skill) => {
+            if (deletedSkillNames.has(skill.name))
+                return false;
+            return beforeByName.get(skill.name)?.bodySha256 !== sha256Text(skill.body);
+        });
+        if (!this.skillsConfig.writable) {
+            if (changed.length > 0 || deletedSkillNames.size > 0 || invalid.length > 0) {
+                throw new Error("Sandbox skill writes are blocked because self-improvement is disabled.");
+            }
+            return;
+        }
+        if (invalid.length > 0) {
+            throw new Error(`Invalid sandbox skill file(s): ${invalid.join(", ")}`);
+        }
+        const created = [];
+        const updated = [];
+        const deleted = [];
+        for (const name of deletedSkillNames) {
+            if (!beforeByName.has(name))
+                continue;
+            await this.skillStore.delete(skillScope, name);
+            deleted.push(name);
+        }
+        for (const skill of changed) {
+            const existing = beforeByName.get(skill.name);
+            await writeSkill(this.skillStore, skillScope, {
+                name: skill.name,
+                body: skill.body,
+                origin: "agent"
+            }, {
+                requireApproval: this.skillsConfig.writeApproval
+            });
+            if (existing)
+                updated.push(skill.name);
+            else
+                created.push(skill.name);
+        }
+        if (created.length || updated.length || deleted.length) {
+            await this.state.appendEvent(run.id, "skill.synced", {
+                created,
+                updated,
+                deleted,
+                pending: this.skillsConfig.writeApproval
+            });
+        }
+    }
+    createSandboxHandle(getRun, setRun, getBundle) {
+        const runtime = this;
+        let sandboxSession;
+        let acquiring;
+        const acquire = async () => {
+            const run = getRun();
+            sandboxSession = await runtime.acquireSandboxForRun(run);
+            const updatedRun = await runtime.state.updateRun(run.id, { sandboxId: sandboxSession.id });
+            setRun(updatedRun);
+            await runtime.state.appendEvent(run.id, "sandbox.acquired", { sandboxId: sandboxSession.id, root: sandboxSession.root });
+            await runtime.createCheckpoint({ runId: run.id, name: "sandbox.acquired", data: { sandboxId: sandboxSession.id } });
+            await hydrateSandboxFilesystem(sandboxSession, getBundle(), {
+                fullHydration: runtime.legacyFullSandboxHydration(),
+                blob: runtime.blob
+            });
+            await runtime.state.appendEvent(run.id, "filesystem.hydrated", {
+                memory: "/memory",
+                history: "/history",
+                files: "/files",
+                workspace: "/workspace",
+                mode: runtime.legacyFullSandboxHydration() ? "full" : "minimal"
+            });
+            await runtime.createCheckpoint({
+                runId: run.id,
+                name: "filesystem.hydrated",
+                data: {
+                    memory: "/memory",
+                    history: "/history",
+                    files: "/files",
+                    workspace: "/workspace",
+                    mode: runtime.legacyFullSandboxHydration() ? "full" : "minimal"
+                }
+            });
+            await materializeConnectionCredentialsIntoSandbox(run, runtime.createConnectionRegistryForRun(run, "local"), sandboxSession, (eventType, payload) => runtime.state.appendEvent(run.id, eventType, payload));
+            return sandboxSession;
+        };
+        return {
+            current() {
+                return sandboxSession;
+            },
+            async get() {
+                if (sandboxSession)
+                    return sandboxSession;
+                // Memoize the in-flight acquisition: parallel tool calls must share
+                // one sandbox session instead of racing to create two.
+                acquiring ??= acquire().catch((error) => {
+                    acquiring = undefined;
+                    throw error;
+                });
+                return acquiring;
+            },
+            async getWrapped() {
+                const run = getRun();
+                return runtime.wrapSandbox(run.id, await this.get());
+            },
+            async dispose() {
+                if (!sandboxSession)
+                    return;
+                await runtime.disposeSandboxSession(getRun().id, sandboxSession);
+            }
+        };
+    }
+    sandboxSessionKey(run) {
+        return sandboxSessionKeyForRun(this.durableAgentScope(), run);
+    }
+    async acquireSandboxForRun(run) {
+        const sessionKey = this.sandboxSessionKey(run);
+        const provider = this.sandbox.provider ?? "sandbox";
+        const existing = await this.state.getSandboxSession(sessionKey);
+        const reconnectManifest = existing?.manifest ?? {};
+        const reconnectCompatible = hasCurrentSandboxFilesystemContract(reconnectManifest);
+        const reconnectInput = {
+            runId: run.id,
+            sandboxId: existing?.sandboxId ?? "",
+            sessionKey,
+            manifest: reconnectManifest
+        };
+        const root = stringValue(reconnectManifest.sandboxRoot);
+        if (root)
+            reconnectInput.root = root;
+        if (existing?.sandboxId && reconnectCompatible) {
+            const connected = await this.sandbox.connect?.(reconnectInput)
+                .catch(this.debugSwallow("sandbox connect probe failed", { runId: run.id, sessionKey }));
+            if (connected) {
+                await this.upsertSandboxSessionForRun(run, sessionKey, provider, connected, existing.dirty, existing.syncJobId, {
+                    ...existing.manifest,
+                    sandboxRoot: connected.root,
+                    ...sandboxFilesystemContractMetadata(connected.provider === "local" ? "emulated" : "physical")
+                }, "live");
+                await this.state.appendEvent(run.id, "sandbox.reused", { sandboxId: connected.id, sessionKey, mode: "connect" });
+                return connected;
+            }
+            const woken = await this.sandbox.wake?.(reconnectInput)
+                .catch(this.debugSwallow("sandbox wake probe failed", { runId: run.id, sessionKey }));
+            if (woken) {
+                await this.upsertSandboxSessionForRun(run, sessionKey, provider, woken, existing.dirty, existing.syncJobId, {
+                    ...existing.manifest,
+                    sandboxRoot: woken.root,
+                    ...sandboxFilesystemContractMetadata(woken.provider === "local" ? "emulated" : "physical")
+                }, "live");
+                await this.state.appendEvent(run.id, "sandbox.reused", { sandboxId: woken.id, sessionKey, mode: "wake" });
+                return woken;
+            }
+        }
+        const lookup = (!existing || reconnectCompatible) ? await this.sandbox.lookup?.({
+            sessionKey,
+            runId: run.id,
+            agentRevision: run.agentRevision,
+            manifest: {
+                ...reconnectManifest,
+                ...sandboxFilesystemContractMetadata(this.sandbox.provider === "local" ? "emulated" : "physical")
+            }
+        }).catch(this.debugSwallow("sandbox lookup probe failed", { runId: run.id, sessionKey })) : undefined;
+        if (lookup) {
+            const lookupInput = {
+                runId: run.id,
+                sandboxId: lookup.sandboxId,
+                sessionKey,
+                manifest: lookup.manifest ?? reconnectManifest
+            };
+            if (lookup.root)
+                lookupInput.root = lookup.root;
+            const connected = await this.sandbox.connect?.(lookupInput)
+                .catch(this.debugSwallow("sandbox connect probe failed", { runId: run.id, sessionKey })) ??
+                await this.sandbox.wake?.(lookupInput)
+                    .catch(this.debugSwallow("sandbox wake probe failed", { runId: run.id, sessionKey }));
+            if (connected) {
+                await this.upsertSandboxSessionForRun(run, sessionKey, provider, connected, existing?.dirty ?? false, existing?.syncJobId, {
+                    ...(lookup.manifest ?? existing?.manifest ?? {}),
+                    sandboxRoot: connected.root,
+                    ...sandboxFilesystemContractMetadata(connected.provider === "local" ? "emulated" : "physical")
+                }, "live");
+                await this.state.appendEvent(run.id, "sandbox.reused", { sandboxId: connected.id, sessionKey, mode: lookup.state ?? "lookup" });
+                return connected;
+            }
+        }
+        const createInput = {
+            sessionKey,
+            metadata: {
+                sessionKey,
+                runId: run.id,
+                agentRevision: run.agentRevision,
+                ...sandboxFilesystemContractMetadata(this.sandbox.provider === "local" ? "emulated" : "physical")
+            }
+        };
+        if (existing?.snapshotId && reconnectCompatible)
+            createInput.snapshotId = existing.snapshotId;
+        const created = this.sandbox.create
+            ? await this.sandbox.create(run, createInput)
+            : await this.sandbox.acquire(run);
+        await this.upsertSandboxSessionForRun(run, sessionKey, provider, created, existing?.dirty ?? false, existing?.syncJobId, {
+            ...(existing?.manifest ?? {}),
+            sandboxRoot: created.root,
+            ...sandboxFilesystemContractMetadata(created.provider === "local" ? "emulated" : "physical")
+        }, existing?.dirty ? "dirty" : "live");
+        await this.state.appendEvent(run.id, "sandbox.created", { sandboxId: created.id, sessionKey });
+        return created;
+    }
+    async upsertSandboxSessionForRun(run, sessionKey, provider, session, dirty, syncJobId, manifest, state) {
+        return this.state.upsertSandboxSession({
+            sessionKey,
+            provider: session.provider ?? provider,
+            sandboxId: session.id,
+            runId: run.id,
+            state: dirty ? "dirty" : state,
+            dirty,
+            lastSeenAt: timestamp(),
+            ...(syncJobId ? { syncJobId } : {}),
+            manifest
+        });
+    }
+    legacyFullSandboxHydration() {
+        return this.env.OPENEVE_LEGACY_FULL_SANDBOX_HYDRATION === "1" ||
+            this.env.OPENEVE_LEGACY_FULL_SANDBOX_HYDRATION === "true";
+    }
+    async ensureDynamicConnections() {
+        if (!this.connectionsConfig.dynamic) {
+            this.dynamicConnectionsCache = { compiled: [], defs: new Map() };
+            return;
+        }
+        if (this.dynamicConnectionsCache)
+            return;
+        await this.migrateLegacyConnectionScope();
+        const stored = await this.connectionDefinitionStore.list(this.connectionScope());
+        const compiled = [];
+        const defs = new Map();
+        for (const definition of stored) {
+            compiled.push(compiledConnectionFromStored(definition));
+            defs.set(definition.name, definition.definition);
+        }
+        this.dynamicConnectionsCache = { compiled, defs };
+    }
+    mergedConnections() {
+        const dynamic = this.dynamicConnectionsCache?.compiled ?? [];
+        if (dynamic.length === 0)
+            return this.manifest.connections;
+        const byName = new Map(this.manifest.connections.map((connection) => [connection.name, connection]));
+        for (const connection of dynamic)
+            byName.set(connection.name, connection);
+        return [...byName.values()];
+    }
+    /** True when a brand-new run would be admitted (or queued) instead of rejected. */
+    hasRunCapacity() {
+        return this.runSemaphore.hasCapacity();
+    }
+    /** Resolves once no runs (new or resumed) are executing or queued. Used by graceful shutdown. */
+    onIdle() {
+        return this.runSemaphore.onIdle();
+    }
+    /** Claim a new-run slot, returning the capacity error instead of throwing. */
+    admitRunOrReject() {
+        try {
+            return this.runSemaphore.admit();
+        }
+        catch (error) {
+            if (error instanceof RunCapacityError)
+                return error;
+            throw error;
+        }
+    }
+    /** Count a resume/continuation entry point toward `onIdle()` without consuming run capacity. */
+    async withRunAdmission(work) {
+        const admission = this.runSemaphore.enter();
+        try {
+            return await work();
+        }
+        finally {
+            admission.release();
+        }
+    }
+    /**
+     * Admission choke point: brand-new runs claim a `maxConcurrentRuns` slot
+     * (throwing `RunCapacityError` when saturated); resumes and scheduler
+     * continuations (`existingRun`) bypass the limit — queueing a resume behind
+     * the run it unblocks would deadlock — but still count toward `onIdle()`.
+     */
+    async run(options) {
+        const admission = options.admission ??
+            (options.existingRun ? this.runSemaphore.enter() : this.runSemaphore.admit());
+        let earlyChannelTurn;
+        try {
+            await admission.ready;
+            if (options.startChannelTurnEarly) {
+                const channel = options.turn?.channel ?? options.channel ?? "local";
+                earlyChannelTurn = this.beginChannelTurn(channel, options.turn);
+            }
+            return await this.executeRun(options, earlyChannelTurn);
+        }
+        catch (error) {
+            if (earlyChannelTurn) {
+                const channel = options.turn?.channel ?? options.channel ?? "local";
+                await this.stopUnclaimedChannelTurn(await earlyChannelTurn, channel);
+            }
+            throw error;
+        }
+        finally {
+            admission.release();
+        }
+    }
+    async executeRun(options, earlyChannelTurn) {
+        this.boot();
+        await this.initializeInstrumentation();
+        await this.ensureSkillsSeeded();
+        await this.ensureDynamicConnections();
+        const spanStartedAt = timestamp();
+        const channel = options.turn?.channel ?? options.channel ?? "local";
+        const channelDefinition = this.manifest.channels.find((candidate) => candidate.name === channel);
+        const targetModel = options.target?.type === "agent" ? options.target.model : undefined;
+        const model = options.model ?? options.turn?.model ?? targetModel;
+        const runInput = {
+            message: options.message,
+            model: model ?? this.manifest.agent.model,
+            channel,
+            eventId: options.turn?.eventId ?? options.eventId ?? null,
+            conversationId: options.turn?.conversationId ?? options.conversationId ?? null,
+            userId: options.turn?.userId ?? options.userId ?? null,
+            projectId: options.projectId ?? options.existingRun?.input.projectId ?? null,
+            delivery: options.turn?.delivery ?? options.delivery ?? null,
+            metadata: options.metadata ?? options.turn?.metadata ?? {},
+            ...(options.eval !== undefined ? { eval: validateEvalRunOptions(options.eval) } : {})
+        };
+        let run = options.existingRun
+            ? await this.state.updateRun(options.existingRun.id, {
+                input: {
+                    ...options.existingRun.input,
+                    ...runInput
+                }
+            })
+            : await this.state.createRun({
+                agentRevision: this.manifest.agentRevision,
+                status: "created",
+                input: runInput
+            });
+        try {
+            await options.onRunCreated?.(run);
+        }
+        catch (error) {
+            this.logger.warn("onRunCreated hook failed", { runId: run.id, error: error instanceof Error ? error.message : String(error) });
+        }
+        await this.state.appendEvent(run.id, "run.accepted", { agentRevision: this.manifest.agentRevision, model: model ?? this.manifest.agent.model });
+        if (this.usesRevisionScopedDurableState() && (this.skillsConfig.writable || this.connectionsConfig.dynamic)) {
+            await this.state.appendEvent(run.id, "agent.scope_fallback", {
+                reason: "missing_agent_id",
+                scope: this.manifest.agentRevision,
+                message: "Durable learned state is scoped to agentRevision because agent.id is not configured."
+            });
+        }
+        run = await this.state.updateRun(run.id, { status: "running" });
+        const heartbeat = this.startRunHeartbeat(run.id);
+        const channelTurnStart = earlyChannelTurn
+            ? await earlyChannelTurn
+            : await this.beginChannelTurn(channel, options.turn);
+        await this.recordChannelTurnStart(channelTurnStart, run, channel);
+        channelTurnStart.claimed = true;
+        const channelLifecycle = channelTurnStart.lifecycle;
+        let channelLifecycleStopped = false;
+        const trustedProvider = options.trustedAttachmentProvider ?? trustedAttachmentProviderForTurn(channelDefinition, options.turn);
+        const stopChannelLifecycle = async () => {
+            if (channelLifecycleStopped)
+                return;
+            channelLifecycleStopped = true;
+            await this.stopChannelTurn(channelLifecycle, run, channel);
+        };
+        try {
+            const resolveAttachment = await this.channelAttachmentResolver(channelDefinition, trustedProvider);
+            const attachments = await materializeTurnAttachments({
+                run,
+                channel,
+                attachments: options.attachments ?? options.turn?.attachments ?? [],
+                ...(trustedProvider ? { trustedProvider } : {}),
+                ...(resolveAttachment ? { resolveAttachment } : {}),
+                env: this.env,
+                fetch: this.fetch,
+                blob: this.blob,
+                state: this.state
+            });
+            const hydratedOptions = { ...options, attachments };
+            if (options.turn)
+                hydratedOptions.turn = { ...options.turn, attachments };
+            const conversation = await this.prepareConversation(run, hydratedOptions, channel);
+            const augmentation = hydratedOptions.turn
+                ? await this.augmentChannelContext(channel, hydratedOptions.turn, run)
+                : undefined;
+            const recentHistory = hydratedOptions.recentHistory ??
+                hydratedOptions.turn?.recentHistory ??
+                augmentation?.recentHistory ??
+                (conversation ? await this.recentHistory(conversation.id) : []);
+            const contextInput = {
+                message: hydratedOptions.message,
+                channel,
+                recentHistory,
+                attachments,
+                run
+            };
+            if (augmentation?.channelContext)
+                contextInput.channelContext = augmentation.channelContext;
+            if (hydratedOptions.promptContext)
+                contextInput.promptContext = hydratedOptions.promptContext;
+            if (hydratedOptions.target)
+                contextInput.target = hydratedOptions.target;
+            const bundle = await this.buildContextBundle(contextInput);
+            const contextBlob = await this.blob.put(`context/${run.id}.json`, JSON.stringify(bundle, null, 2), "application/json");
+            run = await this.state.updateRun(run.id, { contextBundleId: contextBlob.id });
+            await this.state.appendEvent(run.id, "context.bundle_built", { contextBundleId: contextBlob.id });
+            await this.createCheckpoint({
+                runId: run.id,
+                name: "context.bundle_built",
+                data: { contextBundleId: contextBlob.id }
+            });
+            const missingConnections = this.missingRequiredConnections();
+            if (missingConnections.length > 0) {
+                const waitingRun = await this.state.updateRun(run.id, { status: "waiting_for_connection" });
+                await this.state.appendEvent(run.id, "connection.required", {
+                    missingConnections,
+                    recoverable: true
+                });
+                await this.emitSpan("ai.assembly-line.turn", spanStartedAt, this.runSpanAttributes(waitingRun, {
+                    status: "waiting_for_connection"
+                }), {
+                    spanId: this.turnSpanId(waitingRun.id),
+                    status: "ok"
+                });
+                await this.emitSpan("assembly-line.run", spanStartedAt, {
+                    runId: run.id,
+                    status: "waiting_for_connection",
+                    agentRevision: this.manifest.agentRevision
+                });
+                return this.result(waitingRun, `Connection required: ${missingConnections.join(", ")}`, false, false, true);
+            }
+            const resolution = await this.resolveRunCapabilities(run, hydratedOptions, conversation?.id);
+            const sandboxHandle = this.createSandboxHandle(() => run, (nextRun) => {
+                run = nextRun;
+            }, () => bundle);
+            await this.state.appendEvent(run.id, "harness.started", { harness: this.manifest.gateway.runtime?.kind ?? "node" });
+            const baseInstructions = await this.instructionsForRunTarget(run, hydratedOptions.target, bundle.instructions);
+            const targetInstructions = resolution?.instructions
+                ? `${baseInstructions}\n\n${resolution.instructions}`
+                : baseInstructions;
+            let response = options.message;
+            let structuredOutput;
+            const tool = this.selectTool(hydratedOptions);
+            if (tool) {
+                const modelSpanStartedAt = timestamp();
+                await this.state.appendEvent(run.id, "model.request_started", { model: model ?? this.manifest.agent.model, forcedTool: tool.name });
+                await this.state.appendEvent(run.id, "model.response_completed", { model: model ?? this.manifest.agent.model, simulated: true });
+                await this.emitSpan("ai.streamText", modelSpanStartedAt, this.runSpanAttributes(run, {
+                    model: model ?? this.manifest.agent.model,
+                    stepIndex: 0,
+                    forcedTool: tool.name,
+                    simulated: true,
+                    status: "completed"
+                }), {
+                    parentSpanId: this.turnSpanId(run.id),
+                    status: "ok"
+                });
+                const input = hydratedOptions.input ?? inferToolInput(tool, hydratedOptions.message);
+                const outcome = await this.executeTool(run, tool, input, sandboxHandle, hydratedOptions.approve ?? false);
+                run = outcome.run;
+                if (outcome.waitingForApproval || outcome.waitingForInput || outcome.waitingForConnection) {
+                    await stopChannelLifecycle();
+                    await this.emitSpan("ai.assembly-line.turn", spanStartedAt, this.runSpanAttributes(run, {
+                        status: run.status
+                    }), {
+                        spanId: this.turnSpanId(run.id),
+                        status: "ok"
+                    });
+                    return this.result(run, response, outcome.waitingForApproval, outcome.waitingForInput, outcome.waitingForConnection);
+                }
+                response = typeof outcome.modelOutput === "string" ? outcome.modelOutput : JSON.stringify(outcome.modelOutput);
+            }
+            else {
+                const loopInput = {
+                    run,
+                    bundle,
+                    sandboxHandle,
+                    message: hydratedOptions.message,
+                    channel,
+                    instructions: targetInstructions
+                };
+                if (hydratedOptions.turn)
+                    loopInput.turn = hydratedOptions.turn;
+                if (conversation?.id) {
+                    loopInput.conversationId = conversation.id;
+                    loopInput.transcript = await this.loadConversationTranscript(conversation.id, run.id);
+                }
+                // A host-forced model wins over the resolver; the resolver wins over the manifest default.
+                if (model)
+                    loopInput.model = model;
+                else if (resolution?.model)
+                    loopInput.model = resolution.model;
+                if (resolution?.defaultTools)
+                    loopInput.defaultToolNames = resolution.defaultTools;
+                const outcome = await this.runHarnessLoop(loopInput);
+                run = outcome.run;
+                if (outcome.waitingForApproval || outcome.waitingForInput || outcome.waitingForConnection) {
+                    await stopChannelLifecycle();
+                    await this.emitSpan("ai.assembly-line.turn", spanStartedAt, this.runSpanAttributes(run, {
+                        status: run.status
+                    }), {
+                        spanId: this.turnSpanId(run.id),
+                        status: "ok"
+                    });
+                    return this.result(run, outcome.response, outcome.waitingForApproval, outcome.waitingForInput, outcome.waitingForConnection);
+                }
+                if (outcome.failed || outcome.controlStopped) {
+                    await stopChannelLifecycle();
+                    await sandboxHandle.dispose();
+                    return this.result(run, outcome.response, false, false, false);
+                }
+                response = outcome.response;
+                structuredOutput = outcome.output;
+            }
+            const boundaryControl = await this.settleCompletionBoundaryControl(run);
+            if (boundaryControl) {
+                run = boundaryControl;
+                await stopChannelLifecycle();
+                await sandboxHandle.dispose();
+                return this.result(run, response, false, false, false);
+            }
+            await stopChannelLifecycle();
+            const result = await this.completeRun(run, sandboxHandle, response, channel, hydratedOptions.turn, conversation?.id);
+            if (structuredOutput !== undefined)
+                result.output = structuredOutput;
+            await this.emitSpan("ai.assembly-line.turn", spanStartedAt, this.runSpanAttributes(result.run, {
+                status: result.run.status
+            }), {
+                spanId: this.turnSpanId(result.run.id),
+                status: result.run.status === "failed" ? "error" : "ok"
+            });
+            await this.emitSpan("assembly-line.run", spanStartedAt, {
+                runId: run.id,
+                status: result.run.status,
+                agentRevision: this.manifest.agentRevision
+            });
+            return result;
+        }
+        catch (error) {
+            // Fatal model errors terminalize with a durable reason; anything else is
+            // evented + logged but left "running" so the recovery sweep can resume
+            // from the latest continuation (the crash-durability contract).
+            await handleRunExecutionError({ state: this.state, logger: this.logger }, run.id, error);
+            throw error;
+        }
+        finally {
+            heartbeat.stop();
+            await stopChannelLifecycle();
+        }
+    }
+    /** Settle a control request that arrived during a forced direct-tool run (run-outcome.ts). */
+    async settleCompletionBoundaryControl(run) {
+        return settleCompletionBoundaryControlImpl({ state: this.state, runControlIntents: this.runControlIntents }, run);
+    }
+    /** Bump `updatedAt` while a run executes; enforces the wall-clock deadline (run-heartbeat.ts). */
+    startRunHeartbeat(runId) {
+        return startRunHeartbeatImpl({
+            state: this.state,
+            logger: this.logger,
+            runHeartbeatMs: this.runHeartbeatMs,
+            maxRunDurationMs: this.maxRunDurationMs,
+            runControlIntents: this.runControlIntents,
+            runDeadlines: this.runDeadlines,
+            abortRunControllers: (id) => {
+                for (const controller of this.runAbortControllers.get(id) ?? [])
+                    controller.abort();
+            },
+            debugSwallow: (message, fields) => this.debugSwallow(message, fields)
+        }, runId);
+    }
+    registerRunAbort(runId, controller) {
+        return registerRunAbortController(this.runAbortControllers, this.runDeadlines, runId, controller);
+    }
+    conversationContextHost() {
+        const runtime = this;
+        return {
+            state: this.state,
+            manifest: this.manifest,
+            logger: this.logger,
+            coreToolPolicy: this.coreToolPolicy,
+            memoryStore: this.memoryStore,
+            skillStore: this.skillStore,
+            sourceLoader: this.sourceLoader,
+            get contextPolicyPromise() {
+                return runtime.contextPolicyPromise;
+            },
+            set contextPolicyPromise(value) {
+                runtime.contextPolicyPromise = value;
+            },
+            loadChannelModule: (channel) => this.loadChannelModule(channel),
+            channelContext: (channel) => this.channelContext(channel),
+            warnSwallow: (message, fields) => this.warnSwallow(message, fields),
+            memoryScopeForRun: (run) => this.memoryScopeForRun(run),
+            durableAgentScope: () => this.durableAgentScope(),
+            ensureSkillsSeeded: () => this.ensureSkillsSeeded(),
+            skillScope: () => this.skillScope()
+        };
+    }
+    async prepareConversation(run, options, channel) {
+        return prepareConversationImpl(this.conversationContextHost(), run, options, channel);
+    }
+    async recentHistory(conversationId) {
+        return recentHistoryImpl(this.conversationContextHost(), conversationId);
+    }
+    async augmentChannelContext(channelName, turn, run) {
+        return augmentChannelContextImpl(this.conversationContextHost(), channelName, turn, run);
+    }
+    async buildContextBundle(input) {
+        return buildContextBundleImpl(this.conversationContextHost(), input);
+    }
+    harnessLoopHost() {
+        const runtime = this;
+        return {
+            state: this.state,
+            blob: this.blob,
+            manifest: this.manifest,
+            env: this.env,
+            logger: this.logger,
+            models: this.models,
+            agentHarnessOverride: this.agentHarnessOverride,
+            modelHarnesses: this.modelHarnesses,
+            checkpointEveryIteration: this.checkpointEveryIteration,
+            maxModelIterations: this.maxModelIterations,
+            outputValidationMaxRetries: this.outputValidationMaxRetries,
+            now: () => this.now(),
+            shouldStopRun: (runId) => this.runControlIntents.has(runId) || this.runDeadlines.has(runId),
+            runDeadlineExceeded: (runId) => this.runDeadlines.has(runId),
+            registerRunAbort: (runId, controller) => this.registerRunAbort(runId, controller),
+            maxRunDurationMs: this.maxRunDurationMs,
+            runEventBus: this.runEventBus,
+            connectionAuthorizationSessionStore: this.connectionAuthorizationSessionStore,
+            get defaultAgentHarness() {
+                return runtime.defaultAgentHarness;
+            },
+            set defaultAgentHarness(value) {
+                runtime.defaultAgentHarness = value;
+            },
+            get instrumentationConfig() {
+                return runtime.instrumentationConfig;
+            },
+            createConnectionRegistry: (channel, turn) => this.createConnectionRegistry(channel, turn),
+            createConnectionRegistryForRun: (run, fallbackChannel, sandboxHandle) => this.createConnectionRegistryForRun(run, fallbackChannel, sandboxHandle),
+            visibleToolSet: (defaultToolNames, activeSkills) => this.visibleToolSet(defaultToolNames, activeSkills),
+            modelTools: (activeToolNames, connectionRegistry, discoveredConnectionTools) => this.modelTools(activeToolNames, connectionRegistry, discoveredConnectionTools),
+            harnessExecuteTool: (call, state) => this.harnessExecuteTool(call, state),
+            createCheckpoint: (input) => this.createCheckpoint(input),
+            emitSpan: (name, startedAt, attributes, options) => this.emitSpan(name, startedAt, attributes, options),
+            runSpanAttributes: (run, extra) => this.runSpanAttributes(run, extra),
+            turnSpanId: (runId) => this.turnSpanId(runId)
+        };
+    }
+    async resolveAgentHarness(modelSpec) {
+        return resolveAgentHarnessImpl(this.harnessLoopHost(), modelSpec);
+    }
+    piHarness() {
+        return piHarnessImpl(this.harnessLoopHost());
+    }
+    async runHarnessLoop(input) {
+        return runHarnessLoopImpl(this.harnessLoopHost(), input);
+    }
+    /** Load the conversation's stored transcript for resume, or undefined when disabled/absent. */
+    async loadConversationTranscript(conversationId, runId) {
+        return loadResumableConversationTranscriptImpl(this.conversationContextHost(), { state: this.state, createCheckpoint: (input) => this.createCheckpoint(input) }, conversationId, runId);
+    }
+    createHarnessContext(session, loopState, resumed) {
+        return createHarnessContextImpl(this.harnessLoopHost(), session, loopState, resumed);
+    }
+    async persistHarnessContinuation(runId, session, continuation, pause) {
+        return persistHarnessContinuationImpl(this.harnessLoopHost(), runId, session, continuation, pause);
+    }
+    channelIngressHost() {
+        return {
+            state: this.state,
+            manifest: this.manifest,
+            devMode: this.devMode,
+            logger: this.logger,
+            runSemaphore: this.runSemaphore,
+            boot: () => this.boot(),
+            loadChannelModule: (channel) => this.loadChannelModule(channel),
+            channelContext: (channel) => this.channelContext(channel),
+            agentEnabled: () => this.agentEnabled(),
+            admitRunOrReject: () => this.admitRunOrReject(),
+            enqueueConversationTurn: (input) => this.conversationTurnDispatcher.enqueue(input),
+            run: (options) => this.run(options),
+            dispatchAutomationEvent: (event) => this.dispatchAutomationEvent(event)
+        };
+    }
+    async dispatchHttpChannel(channelName, request) {
+        return dispatchHttpChannelImpl(this.channelIngressHost(), channelName, request);
+    }
+    async acceptChannelTurn(channelName, input) {
+        return acceptChannelTurnImpl(this.channelIngressHost(), channelName, input);
+    }
+    async startChannelIngress() {
+        return startChannelIngressImpl(this.channelIngressHost());
+    }
+    replayResumeHost() {
+        return {
+            state: this.state,
+            manifest: this.manifest,
+            coreToolPolicy: this.coreToolPolicy,
+            env: this.env,
+            fetch: this.fetch,
+            connectionAuthorizationSessionStore: this.connectionAuthorizationSessionStore,
+            connectionGrantStore: this.connectionGrantStore,
+            connectionCallbackBaseUrl: this.connectionCallbackBaseUrl,
+            boot: () => this.boot(),
+            initializeInstrumentation: () => this.initializeInstrumentation(),
+            ensureDynamicConnections: () => this.ensureDynamicConnections(),
+            withRunAdmission: (work) => this.withRunAdmission(work),
+            listHydratedCheckpoints: (runId) => this.listHydratedCheckpoints(runId),
+            resolveAgentHarness: (modelSpec) => this.resolveAgentHarness(modelSpec),
+            buildContextBundle: (input) => this.buildContextBundle(input),
+            createSandboxHandle: (getRun, setRun, getBundle) => this.createSandboxHandle(getRun, setRun, getBundle),
+            executeToolWithRecord: (run, tool, toolCall, input, sandboxHandle, approvedToolCall) => this.executeToolWithRecord(run, tool, toolCall, input, sandboxHandle, approvedToolCall),
+            executeConnectionToolWithRecord: (run, registry, toolName, toolCall, input) => this.executeConnectionToolWithRecord(run, registry, toolName, toolCall, input),
+            createConnectionRegistry: (channel, turn) => this.createConnectionRegistry(channel, turn),
+            createConnectionRegistryForRun: (run, fallbackChannel, sandboxHandle) => this.createConnectionRegistryForRun(run, fallbackChannel, sandboxHandle),
+            createConnectionRegistryForSession: (session) => this.createConnectionRegistryForSession(session),
+            mergedConnections: () => this.mergedConnections(),
+            loadConnectionDefinition: (connection) => this.loadConnectionDefinition(connection),
+            startRunHeartbeat: (runId) => this.startRunHeartbeat(runId),
+            createHarnessContext: (session, loopState, resumed) => this.createHarnessContext(session, loopState, resumed),
+            executeHarnessTurn: (harness, input, session, loopState, resumed) => executeHarnessTurnImpl(this.harnessLoopHost(), harness, input, session, loopState, resumed),
+            persistHarnessContinuation: (runId, session, continuation, pause) => this.persistHarnessContinuation(runId, session, continuation, pause),
+            createCheckpoint: (input) => this.createCheckpoint(input),
+            result: (run, response, waitingForApproval, waitingForInput, waitingForConnection) => this.result(run, response, waitingForApproval, waitingForInput, waitingForConnection),
+            completeRun: (run, sandboxHandle, response, channel, turn, conversationId) => this.completeRun(run, sandboxHandle, response, channel, turn, conversationId),
+            runDeliveryChannel: (run) => this.runDeliveryChannel(run)
+        };
+    }
+    async replay(runId) {
+        return replayImpl(this.replayResumeHost(), runId);
+    }
+    /** Resumes never consume run capacity (deadlock risk); they only count toward `onIdle()`. */
+    async resumeApproval(runId) {
+        const result = await this.withRunAdmission(() => this.resumeApprovalNow(runId));
+        await this.conversationTurnDispatcher.settleRunResult(result);
+        return result;
+    }
+    async resumeApprovalNow(runId) {
+        return resumeApprovalNowImpl(this.replayResumeHost(), runId);
+    }
+    async completeConnectionAuthorizationCallback(callback) {
+        const result = await completeConnectionAuthorizationCallbackImpl(this.replayResumeHost(), callback);
+        if (result.runResult)
+            await this.conversationTurnDispatcher.settleRunResult(result.runResult);
+        return result;
+    }
+    /**
+     * Begin (or resume) the authorization flow for a named connection on behalf
+     * of an operator surface such as a dashboard or CLI, outside any run. Backs
+     * the node host's authenticated GET /openeve/connections/authorize route.
+     * Idempotent by construction: an existing usable grant reports "connected"
+     * and a pending session's challenge URL is reused, so this doubles as a
+     * per-connection status probe while a consent flow is in flight. Connections
+     * with subject "user" require the caller to supply the same user identity a
+     * run would carry; otherwise they report unavailable (principal_required).
+     */
+    async beginConnectionAuthorization(connectionName, session = {}) {
+        return beginConnectionAuthorizationImpl(this.toolExecutionHost(), connectionName, session);
+    }
+    /** Resumes never consume run capacity (deadlock risk); they only count toward `onIdle()`. */
+    async resumeInput(runId, answer) {
+        const result = await this.withRunAdmission(() => this.resumeInputNow(runId, answer));
+        await this.conversationTurnDispatcher.settleRunResult(result);
+        return result;
+    }
+    async resumeInputNow(runId, answer) {
+        return resumeInputNowImpl(this.replayResumeHost(), runId, answer);
+    }
+    /** Request cooperative cancellation, or synchronously cancel a parked run. */
+    async cancelRun(runId) {
+        const run = await requestRunControlImpl(this.operatorControlsHost(), runId, "cancel");
+        if (run.status === "cancelled")
+            await this.conversationTurnDispatcher.settleRunRecord(run);
+        return run;
+    }
+    /** Request cooperative suspension of a currently running run. */
+    async suspendRun(runId) {
+        return requestRunControlImpl(this.operatorControlsHost(), runId, "suspend");
+    }
+    /** Resume a deliberately suspended run from its latest durable continuation. */
+    async resumeSuspended(runId) {
+        const result = await this.withRunAdmission(() => resumeSuspendedNowImpl(this.replayResumeHost(), runId));
+        await this.conversationTurnDispatcher.settleRunResult(result);
+        return result;
+    }
+    /** Read the durable ingress kill-switch for this stable agent identity. */
+    async getAgentControl() {
+        return getAgentControlImpl(this.operatorControlsHost());
+    }
+    /** Enable or disable new channel ingress without affecting in-flight runs or resumes. */
+    async setAgentEnabled(enabled, metadata = {}) {
+        const result = await setAgentEnabledImpl(this.operatorControlsHost(), enabled, metadata);
+        if (enabled)
+            this.conversationTurnDispatcher.requestDrain();
+        return result;
+    }
+    /** Quiesce new ingress and background dispatch while in-flight work drains. */
+    async setAgentMaintenance(maintenance, metadata = {}) {
+        const result = await setAgentMaintenanceImpl(this.operatorControlsHost(), maintenance, metadata);
+        if (!maintenance)
+            this.conversationTurnDispatcher.requestDrain();
+        return result;
+    }
+    async agentEnabled() {
+        return (await this.getAgentControl()).acceptingWork;
+    }
+    operatorControlsHost() {
+        return {
+            state: this.state,
+            boot: () => this.boot(),
+            durableAgentScope: () => this.durableAgentScope(),
+            cacheRunControl: (runId, intent) => {
+                if (intent)
+                    this.runControlIntents.set(runId, intent);
+                else
+                    this.runControlIntents.delete(runId);
+            }
+        };
+    }
+    async resumeHarnessLoop(run, harness, restored, resume) {
+        return resumeHarnessLoopImpl(this.replayResumeHost(), run, harness, restored, resume);
+    }
+    subagentExecutionHost() {
+        return {
+            state: this.state,
+            manifest: this.manifest,
+            sourceLoader: this.sourceLoader,
+            resolveAgentHarness: (modelSpec) => this.resolveAgentHarness(modelSpec),
+            replay: (runId) => this.replay(runId),
+            listHydratedCheckpoints: (runId) => this.listHydratedCheckpoints(runId),
+            buildContextBundle: (input) => this.buildContextBundle(input),
+            createSandboxHandle: (getRun, setRun, getBundle) => this.createSandboxHandle(getRun, setRun, getBundle),
+            startRunHeartbeat: (runId) => this.startRunHeartbeat(runId),
+            runHarnessLoop: (input) => this.runHarnessLoop(input),
+            resumeHarnessLoop: (run, harness, restored, resume) => this.resumeHarnessLoop(run, harness, restored, resume),
+            completeRun: (run, sandboxHandle, response, channel, turn, conversationId) => this.completeRun(run, sandboxHandle, response, channel, turn, conversationId),
+            emitSpan: (name, startedAt, attributes, options) => this.emitSpan(name, startedAt, attributes, options),
+            runSpanAttributes: (run, extra) => this.runSpanAttributes(run, extra),
+            turnSpanId: (runId) => this.turnSpanId(runId)
+        };
+    }
+    async runSubagent(parentRunId, subagentName, task) {
+        return runSubagentImpl(this.subagentExecutionHost(), parentRunId, subagentName, task);
+    }
+    async readSubagent(childRunId, cursor) {
+        return readSubagentImpl(this.subagentExecutionHost(), childRunId, cursor);
+    }
+    async sendSubagentFollowup(childRunId, message) {
+        return sendSubagentFollowupImpl(this.subagentExecutionHost(), childRunId, message);
+    }
+    async loadSkill(runId, skillName) {
+        const loaded = await this.skillLoadDetails(skillName);
+        const output = {
+            name: loaded.name,
+            skillName: loaded.name,
+            description: loaded.description,
+            origin: loaded.origin,
+            path: loaded.path,
+            instructions: loaded.instructions
+        };
+        if (loaded.declaredTools.length > 0)
+            output.declaredTools = loaded.declaredTools;
+        await this.state.appendEvent(runId, "skill.loaded", {
+            skill: loaded.name,
+            origin: loaded.origin,
+            path: loaded.path
+        });
+        return output;
+    }
+    async activateSkill(runId, skillName) {
+        await this.loadSkill(runId, skillName);
+        return visibleToolsForSkills(this.manifest);
+    }
+    scheduleExecutionHost() {
+        return {
+            manifest: this.manifest,
+            state: this.state,
+            blob: this.blob,
+            env: this.env,
+            fetch: this.fetch,
+            logger: this.logger,
+            memoryStore: this.memoryStore,
+            skillStore: this.skillStore,
+            scheduleStore: this.scheduleStore,
+            schedulesConfig: this.schedulesConfig,
+            schedulerTickMs: this.schedulerTickMs,
+            scheduleMaxConsecutiveFailures: this.scheduleMaxConsecutiveFailures,
+            sourceLoader: this.sourceLoader,
+            boot: () => this.boot(),
+            now: () => this.now(),
+            admitRunOrReject: () => this.admitRunOrReject(),
+            run: (options) => this.run(options),
+            latestRunFailureMessage: (runId) => this.latestRunFailureMessage(runId),
+            emitSpan: (name, startedAt, attributes, options) => this.emitSpan(name, startedAt, attributes, options),
+            runSpanAttributes: (run, extra) => this.runSpanAttributes(run, extra),
+            turnSpanId: (runId) => this.turnSpanId(runId),
+            createSandboxHandle: (getRun, setRun, getBundle) => this.createSandboxHandle(getRun, setRun, getBundle),
+            createMemoryToolApi: (run) => this.createMemoryToolApi(run),
+            createResourceToolApi: (run, sandboxHandle) => this.createResourceToolApi(run, sandboxHandle),
+            durableStep: (runId, key, fn, options) => this.durableStep(runId, key, fn, options),
+            memoryScopeForRun: (run) => this.memoryScopeForRun(run),
+            mergedConnections: () => this.mergedConnections(),
+            skillScope: () => this.skillScope(),
+            agentEnabled: () => this.agentEnabled()
+        };
+    }
+    async registerManifestSchedules() {
+        return registerManifestSchedulesImpl(this.scheduleExecutionHost());
+    }
+    async registerManifestAutomations() {
+        return this.registerManifestSchedules();
+    }
+    /** @deprecated Use `runDueAutomations`. */
+    async runDueSchedules(options = {}) {
+        return runDueSchedulesImpl(this.scheduleExecutionHost(), options);
+    }
+    async runDueAutomations(options = {}) {
+        return this.runDueSchedules(options);
+    }
+    async dispatchAutomationEvent(event) {
+        return dispatchAutomationEventImpl(this.scheduleExecutionHost(), event);
+    }
+    normalizeScheduleTriggerDefinition(value) {
+        return normalizeScheduleTriggerDefinitionImpl(this.scheduleExecutionHost(), value);
+    }
+    async startSchedulerLoop() {
+        if (!this.shouldStartScheduler())
+            return undefined;
+        return this.scheduler.start(this);
+    }
+    async startSchedulerPollingLoop() {
+        return startSchedulerPollingLoopImpl(this.scheduleExecutionHost());
+    }
+    shouldStartScheduler() {
+        if (this.schedulerEnabled === false)
+            return false;
+        if (this.env.OPENEVE_SCHEDULER_ENABLED === "false" || this.env.OPENEVE_SCHEDULER_ENABLED === "0")
+            return false;
+        return true;
+    }
+    /**
+     * Subscribe to a run's live event stream: every durable event as it is
+     * persisted plus ephemeral `model.response_delta` token deltas. Returns an
+     * unsubscribe function. For catch-up, replay `listEvents(runId)` first and
+     * dedupe by `sequence`.
+     */
+    subscribeRunStream(runId, listener) {
+        return this.runEventBus.subscribe(runId, listener);
+    }
+    /** Staleness-guarded orphaned-run sweep. See {@link RunRecoveryOptions} for tuning. */
+    async recoverIncompleteRuns(options = {}) {
+        if (!(await this.agentEnabled()))
+            return [];
+        const host = {
+            state: this.state,
+            logger: this.logger,
+            now: this.now,
+            runHeartbeatMs: this.runHeartbeatMs,
+            sandboxSyncMaxAttempts: this.sandboxSyncMaxAttempts,
+            deliveryQueueMaxAttempts: this.deliveryQueueMaxAttempts,
+            resumeRunFromContinuation: (run, context) => this.withRunAdmission(() => this.resumeRunFromContinuation(run, context)),
+            listHydratedCheckpoints: (runId) => this.listHydratedCheckpoints(runId)
+        };
+        const recovered = await recoverIncompleteRunsImpl(host, options);
+        for (const run of recovered) {
+            await this.conversationTurnDispatcher.settleRunRecord(run);
+        }
+        await this.conversationTurnDispatcher.recover();
+        return recovered;
+    }
+    /** Resume an orphaned run in place from its latest persisted continuation checkpoint (replay-resume.ts). */
+    async resumeRunFromContinuation(run, context) {
+        return resumeRunFromContinuationImpl(this.replayResumeHost(), run, context);
+    }
+    /** Start delivery, sandbox-sync, conversation-turn, and orphan-recovery workers. */
+    startBackgroundWorkers(options = {}) {
+        return startBackgroundWorkersImpl({
+            env: this.env,
+            logger: this.logger,
+            runRecoveryIntervalMs: this.runRecoveryIntervalMs,
+            startDeliveryWorker: (workerOptions) => this.startDeliveryWorker(workerOptions),
+            startSandboxSyncWorker: (workerOptions) => this.startSandboxSyncWorker(workerOptions),
+            startConversationTurnWorker: (workerOptions) => this.conversationTurnDispatcher.startWorker(workerOptions?.intervalMs),
+            recoverIncompleteRuns: (recoveryOptions) => this.recoverIncompleteRuns(recoveryOptions),
+            agentEnabled: () => this.agentEnabled()
+        }, options);
+    }
+    deliveryQueueHost() {
+        return {
+            state: this.state,
+            logger: this.logger,
+            now: this.now,
+            leaseMs: this.deliveryQueueLeaseMs,
+            batchSize: this.deliveryQueueBatchSize,
+            agentEnabled: () => this.agentEnabled(),
+            sendQueuedDelivery: async (delivery) => {
+                const response = typeof delivery.payload.response === "string" ? delivery.payload.response : "";
+                return this.sendDelivery(delivery, response, undefined);
+            }
+        };
+    }
+    /** Drain due deferred deliveries once: recover expired leases, lease, send, settle. */
+    async runDueDeliveries(options = {}) {
+        return runDueDeliveriesImpl(this.deliveryQueueHost(), options);
+    }
+    startDeliveryWorker(options = {}) {
+        const intervalMs = positiveLimit(options.intervalMs, this.deliveryQueueIntervalMs);
+        return startDeliveryWorkerImpl(this.deliveryQueueHost(), { ...options, intervalMs });
+    }
+    /** The run's originating channel, for routing deliveries on resume/degrade paths. */
+    runDeliveryChannel(run) {
+        return typeof run.input.channel === "string" && run.input.channel ? run.input.channel : "local";
+    }
+    deliverySendHost() {
+        return {
+            state: this.state,
+            blob: this.blob,
+            logger: this.logger,
+            env: this.env,
+            manifest: this.manifest,
+            devMode: this.devMode,
+            deliveryMode: this.deliveryMode,
+            now: this.now,
+            sandboxSyncInline: this.sandboxSyncInline,
+            deliveryQueueLeaseMs: this.deliveryQueueLeaseMs,
+            deliveryQueueMaxAttempts: this.deliveryQueueMaxAttempts,
+            sandboxSyncMaxAttempts: this.sandboxSyncMaxAttempts,
+            result: (run, response, waitingForApproval, waitingForInput, waitingForConnection) => this.result(run, response, waitingForApproval, waitingForInput, waitingForConnection),
+            sandboxSessionKey: (run) => this.sandboxSessionKey(run),
+            debugSwallow: (message, fields) => this.debugSwallow(message, fields),
+            emitSpan: (name, startedAt, attributes, options) => this.emitSpan(name, startedAt, attributes, options),
+            runSpanAttributes: (run, extra) => this.runSpanAttributes(run, extra),
+            turnSpanId: (runId) => this.turnSpanId(runId),
+            captureSandboxSnapshot: (run, sandboxSession, stage) => this.captureSandboxSnapshot(run, sandboxSession, stage),
+            loadChannelModule: (channel) => this.loadChannelModule(channel),
+            channelContext: (channel) => this.channelContext(channel)
+        };
+    }
+    async completeRun(run, sandboxHandle, response, channel, turn, conversationId) {
+        return completeRunImpl(this.deliverySendHost(), run, sandboxHandle, response, channel, turn, conversationId);
+    }
+    async latestRunFailureMessage(runId) {
+        return latestRunFailureMessageImpl(this.deliverySendHost(), runId);
+    }
+    async enqueueSandboxSyncAfterDelivery(run, sandboxSession) {
+        return enqueueSandboxSyncAfterDeliveryImpl(this.deliverySendHost(), run, sandboxSession);
+    }
+    sandboxSyncWorkerHost() {
+        return {
+            state: this.state,
+            blob: this.blob,
+            sandbox: this.sandbox,
+            logger: this.logger,
+            env: this.env,
+            now: this.now,
+            sandboxSyncBatchSize: this.sandboxSyncBatchSize,
+            sandboxSyncLeaseMs: this.sandboxSyncLeaseMs,
+            sandboxSnapshotPolicy: this.sandboxSnapshotPolicy,
+            readSandboxTombstonesWithMissingProjectedFiles: (sandbox) => this.readSandboxTombstonesWithMissingProjectedFiles(sandbox),
+            syncMemoryFromSandbox: (run, sandboxSession, tombstones) => this.syncMemoryFromSandbox(run, sandboxSession, tombstones),
+            syncSkillsFromSandbox: (run, sandboxSession, tombstones) => this.syncSkillsFromSandbox(run, sandboxSession, tombstones),
+            emitSpan: (name, startedAt, attributes, options) => this.emitSpan(name, startedAt, attributes, options),
+            runSpanAttributes: (run, extra) => this.runSpanAttributes(run, extra),
+            turnSpanId: (runId) => this.turnSpanId(runId),
+            warnSwallow: (message, fields) => this.warnSwallow(message, fields),
+            createCheckpoint: (input) => this.createCheckpoint(input),
+            sandboxSessionKey: (run) => this.sandboxSessionKey(run),
+            agentEnabled: () => this.agentEnabled()
+        };
+    }
+    async sandboxSyncDiagnostics(options = {}) {
+        return sandboxSyncDiagnosticsImpl(this.sandboxSyncWorkerHost(), options);
+    }
+    async inspectSandboxSyncJob(jobId, options = {}) {
+        return inspectSandboxSyncJobImpl(this.sandboxSyncWorkerHost(), jobId, options);
+    }
+    async retrySandboxSyncJob(jobId, options = {}) {
+        return retrySandboxSyncJobImpl(this.sandboxSyncWorkerHost(), jobId, options);
+    }
+    async runDueSandboxSyncJobs(options = {}) {
+        return runDueSandboxSyncJobsImpl(this.sandboxSyncWorkerHost(), options);
+    }
+    startSandboxSyncWorker(options = {}) {
+        return startSandboxSyncWorkerImpl(this.sandboxSyncWorkerHost(), options);
+    }
+    async captureSandboxSnapshot(run, sandboxSession, stage) {
+        return captureSandboxSnapshotImpl(this.sandboxSyncWorkerHost(), run, sandboxSession, stage);
+    }
+    async disposeSandboxSession(runId, sandboxSession) {
+        return disposeSandboxSessionImpl(this.sandboxSyncWorkerHost(), runId, sandboxSession);
+    }
+    async beginChannelTurn(channelName, turn) {
+        return beginChannelTurnImpl(this.deliverySendHost(), channelName, turn);
+    }
+    async recordChannelTurnStart(start, run, channelName) {
+        return recordChannelTurnStartImpl(this.deliverySendHost(), start, run, channelName);
+    }
+    async stopUnclaimedChannelTurn(start, channelName) {
+        return stopUnclaimedChannelTurnImpl(this.deliverySendHost(), start, channelName);
+    }
+    async stopChannelTurn(lifecycle, run, channelName) {
+        return stopChannelTurnImpl(this.deliverySendHost(), lifecycle, run, channelName);
+    }
+    async sendDelivery(delivery, response, turn) {
+        return sendDeliveryImpl(this.deliverySendHost(), delivery, response, turn);
+    }
+    visibleToolSet(defaultToolNames, activeSkills) {
+        return visibleToolSetImpl(this.toolExecutionHost(), defaultToolNames, activeSkills);
+    }
+    async skillLoadDetails(skillName) {
+        return skillLoadDetailsImpl(this.toolExecutionHost(), skillName);
+    }
+    async instructionsForRunTarget(run, target, baseInstructions) {
+        return instructionsForRunTargetImpl({ appendEvent: (runId, type, data) => this.state.appendEvent(runId, type, data), skillLoadDetails: (skillName) => this.skillLoadDetails(skillName) }, run, target, baseInstructions);
+    }
+    async modelTools(activeToolNames, connectionRegistry, discoveredConnectionTools = new Map()) {
+        return modelToolsImpl(this.toolExecutionHost(), activeToolNames, connectionRegistry, discoveredConnectionTools);
+    }
+    async harnessExecuteTool(call, state) {
+        return harnessExecuteToolImpl(this.toolExecutionHost(), call, state);
+    }
+    createConnectionRegistry(channel, turn) {
+        return createConnectionRegistryImpl(this.toolExecutionHost(), channel, turn);
+    }
+    createConnectionRegistryForRun(run, fallbackChannel, sandboxHandle) {
+        return createConnectionRegistryForRunImpl(this.toolExecutionHost(), run, fallbackChannel, sandboxHandle);
+    }
+    createConnectionRegistryForSession(session) {
+        return createConnectionRegistryForSessionImpl(this.toolExecutionHost(), session);
+    }
+    async executeConnectionToolWithRecord(run, registry, toolName, toolCall, input) {
+        return executeConnectionToolWithRecordImpl(this.toolExecutionHost(), run, registry, toolName, toolCall, input);
+    }
+    async loadConnectionDefinition(connection) {
+        const inline = this.dynamicConnectionsCache?.defs.get(connection.name);
+        if (inline)
+            return inline;
+        const module = await this.sourceLoader.load(connection.source);
+        return module.default;
+    }
+    async loadChannelModule(channel) {
+        return loadChannelModuleImpl((source) => this.sourceLoader.load(source), channel);
+    }
+    async channelAttachmentResolver(channel, trustedProvider) {
+        return channelAttachmentResolverImpl({
+            loadChannelModule: (target) => this.loadChannelModule(target),
+            channelContext: (target) => this.channelContext(target),
+            channelProvider: compiledChannelProvider,
+            warnSwallow: (message, fields) => this.warnSwallow(message, fields)
+        }, channel, trustedProvider);
+    }
+    channelContext(channel) {
+        return {
+            channel,
+            agentScope: this.durableAgentScope(),
+            connections: this.connections,
+            env: this.env,
+            fetch: this.fetch,
+            state: this.state,
+            blob: this.blob
+        };
+    }
+    missingRequiredConnections() {
+        return this.manifest.connections
+            .filter((connection) => connection.required && connection.protocol === "declaration")
+            .map((connection) => connection.name)
+            .filter((name) => this.connections[name] === undefined);
+    }
+    async emitSpan(name, startedAt, attributes, options = {}) {
+        return emitTelemetrySpanImpl(this.telemetry, { name, startedAt, attributes, options, traceIdForRun: (runId) => this.traceIdForRun(runId), randomHex, timestamp });
+    }
+    async initializeInstrumentation() {
+        if (this.instrumentationLoaded || !this.manifest.instrumentation) {
+            this.instrumentationLoaded = true;
+            return;
+        }
+        const instrumentation = await this.loadInstrumentationModule();
+        const defaultExport = instrumentation.default;
+        const definition = isInstrumentationDefinition(defaultExport) ? defaultExport : undefined;
+        // Host/gateway-supplied instrumentation wins over instrumentation.ts, mirroring
+        // the telemetry-sink precedence below.
+        if (definition && !this.hostInstrumentationProvided) {
+            this.instrumentationConfig = {
+                recordInputs: definition.recordInputs ?? false,
+                recordOutputs: definition.recordOutputs ?? false,
+                functionId: definition.functionId ?? definition.serviceName ?? this.agentName(),
+                serviceName: definition.serviceName ?? this.agentName(),
+                contentCapture: normalizeCapturePolicy(definition.captureContent)
+            };
+        }
+        const setupResult = definition?.setup
+            ? await definition.setup({
+                agentName: this.agentName(),
+                manifest: this.manifest,
+                env: this.env
+            })
+            : undefined;
+        const setupSink = telemetrySinkFromSetupResult(setupResult);
+        const exportedSink = instrumentation.telemetry ?? definition?.telemetry;
+        const sink = setupSink ?? exportedSink;
+        if (!this.hostTelemetryProvided && isTelemetrySink(sink)) {
+            this.telemetry = sink;
+        }
+        this.instrumentationLoaded = true;
+    }
+    agentName() {
+        return this.manifest.agent.name ?? this.manifest.agent.description ?? `openeve-${this.manifest.agentRevision.slice(0, 12)}`;
+    }
+    traceIdForRun(runId) {
+        return createHash("sha256").update(runId).digest("hex").slice(0, 32);
+    }
+    spanIdFor(runId, scope) {
+        return createHash("sha256").update(runId).update(":").update(scope).digest("hex").slice(0, 16);
+    }
+    runSpanAttributes(run, extra = {}) {
+        return runSpanAttributesImpl(this.manifest.agentRevision, this.instrumentationConfig, run, extra);
+    }
+    /** Tool argument/result span attributes, gated on the content-capture policy. */
+    toolContentAttributes(input, output) {
+        const policy = this.instrumentationConfig.contentCapture;
+        if (!policy.includeToolIO)
+            return {};
+        const attributes = { "gen_ai.tool.input": redactTruncateJson(input, policy) };
+        if (output !== undefined)
+            attributes["gen_ai.tool.output"] = redactTruncateJson(output, policy);
+        return attributes;
+    }
+    turnSpanId(runId) {
+        return this.spanIdFor(runId, "turn");
+    }
+    toolExecutionHost() {
+        return {
+            state: this.state,
+            env: this.env,
+            fetch: this.fetch,
+            manifest: this.manifest,
+            coreToolPolicy: this.coreToolPolicy,
+            skillStore: this.skillStore,
+            memoryStore: this.memoryStore,
+            sandbox: this.sandbox,
+            connections: this.connections,
+            connectionGrantStore: this.connectionGrantStore,
+            connectionAuthorizationSessionStore: this.connectionAuthorizationSessionStore,
+            connectionCallbackBaseUrl: this.connectionCallbackBaseUrl,
+            toolOutputMaxChars: this.toolOutputMaxChars,
+            toolTimeoutMs: this.toolTimeoutMs,
+            sandboxSyncMaxAttempts: this.sandboxSyncMaxAttempts,
+            skillsConfig: this.skillsConfig,
+            schedulesConfig: this.schedulesConfig,
+            connectionsConfig: this.connectionsConfig,
+            ensureSkillsSeeded: () => this.ensureSkillsSeeded(),
+            skillScope: () => this.skillScope(),
+            scheduleScopeForRun: (run) => this.scheduleScopeForRun(run),
+            memoryScopeForRun: (run) => this.memoryScopeForRun(run),
+            sandboxSessionKey: (run) => this.sandboxSessionKey(run),
+            mergedConnections: () => this.mergedConnections(),
+            loadConnectionDefinition: (connection) => this.loadConnectionDefinition(connection),
+            loadTool: (tool, run) => this.loadTool(tool, run),
+            runSubagent: (parentRunId, subagentName, task) => this.runSubagent(parentRunId, subagentName, task),
+            projectSkillIntoSandbox: (run, sandbox, skillName) => this.projectSkillIntoSandbox(run, sandbox, skillName),
+            hydrateLogicalPathForTool: (run, sandbox, path, options) => this.hydrateLogicalPathForTool(run, sandbox, path, options),
+            recordSandboxTombstone: (run, sandbox, path) => this.recordSandboxTombstone(run, sandbox, path),
+            createCheckpoint: (input) => this.createCheckpoint(input),
+            listHydratedCheckpoints: (runId) => this.listHydratedCheckpoints(runId),
+            emitSpan: (name, startedAt, attributes, options) => this.emitSpan(name, startedAt, attributes, options),
+            runSpanAttributes: (run, extra) => this.runSpanAttributes(run, extra),
+            turnSpanId: (runId) => this.turnSpanId(runId),
+            toolContentAttributes: (input, output) => this.toolContentAttributes(input, output),
+            saveSkill: (input) => this.saveSkill(input),
+            listSkills: () => this.listSkills(),
+            deleteSkill: (name) => this.deleteSkill(name),
+            createDynamicSchedule: (input) => this.createDynamicSchedule(input),
+            listDynamicSchedules: (scope) => this.listDynamicSchedules(scope),
+            updateDynamicSchedule: (scope, id, patch) => this.updateDynamicSchedule(scope, id, patch),
+            deleteDynamicSchedule: (scope, id) => this.deleteDynamicSchedule(scope, id),
+            saveConnectionDefinition: (input) => this.saveConnectionDefinition(input),
+            listConnectionDefinitions: (scope) => this.listConnectionDefinitions(scope),
+            deleteConnectionDefinition: (name, scope) => this.deleteConnectionDefinition(name, scope),
+            listResourcesForRun: (run, scope, input) => this.listResourcesForRun(run, scope, input),
+            readResourceForRun: (run, scope, input) => this.readResourceForRun(run, scope, input),
+            projectResourcesForRun: (run, scope, sandbox, input) => this.projectResourcesForRun(run, scope, sandbox, input)
+        };
+    }
+    selectTool(options) {
+        return selectToolImpl(this.toolExecutionHost(), options);
+    }
+    async executeTool(run, tool, input, sandboxHandle, approved, idempotencyKey) {
+        return executeToolImpl(this.toolExecutionHost(), run, tool, input, sandboxHandle, approved, idempotencyKey);
+    }
+    async executeToolWithRecord(run, tool, toolCall, input, sandboxHandle, approvedToolCall = false) {
+        return executeToolWithRecordImpl(this.toolExecutionHost(), run, tool, toolCall, input, sandboxHandle, approvedToolCall);
+    }
+    async durableStep(runId, key, fn, options) {
+        return durableStepImpl(this.toolExecutionHost(), runId, key, fn, options);
+    }
+    wrapSandbox(runId, session) {
+        return wrapSandboxImpl(this.toolExecutionHost(), runId, session);
+    }
+    createMemoryToolApi(run) {
+        return createMemoryToolApiImpl(this.toolExecutionHost(), run);
+    }
+    createResourceToolApi(run, sandboxHandle) {
+        return createResourceToolApiImpl(this.toolExecutionHost(), run, sandboxHandle);
+    }
+    resourceProjectionHost() {
+        return {
+            state: this.state,
+            blob: this.blob,
+            memoryStore: this.memoryStore,
+            skillStore: this.skillStore,
+            resourceProjectionPolicy: this.resourceProjectionPolicy,
+            memoryEmbeddingProvider: this.memoryEmbeddingProvider,
+            memoryEmbeddingsEnabled: this.memoryEmbeddingsEnabled,
+            skillScope: () => this.skillScope(),
+            durableAgentScope: () => this.durableAgentScope()
+        };
+    }
+    async listResourcesForRun(run, scope, input = {}) {
+        return listResourcesForRunImpl(this.resourceProjectionHost(), run, scope, input);
+    }
+    async readResourceForRun(run, scope, input) {
+        return readResourceForRunImpl(this.resourceProjectionHost(), run, scope, input);
+    }
+    async projectResourcesForRun(run, scope, sandbox, input) {
+        return projectResourcesForRunImpl(this.resourceProjectionHost(), run, scope, sandbox, input);
+    }
+    async projectSkillIntoSandbox(run, sandbox, skillName) {
+        return projectSkillIntoSandboxImpl(this.resourceProjectionHost(), run, sandbox, skillName);
+    }
+    async hydrateLogicalPathForTool(run, sandbox, path, options = {}) {
+        return hydrateLogicalPathForToolImpl(this.resourceProjectionHost(), run, sandbox, path, options);
+    }
+    async recordSandboxTombstone(run, sandbox, path) {
+        return recordSandboxTombstoneImpl(this.resourceProjectionHost(), run, sandbox, path);
+    }
+    async readSandboxTombstonesWithMissingProjectedFiles(sandbox) {
+        return readSandboxTombstonesWithMissingProjectedFilesImpl(this.resourceProjectionHost(), sandbox);
+    }
+    memoryScopeForRun(run) {
+        return memoryScopeForRunImpl(this.resourceProjectionHost(), run);
+    }
+    async backfillMemoryDocumentsFromFileIndexes(options = {}) {
+        return backfillMemoryDocumentsFromFileIndexesImpl(this.resourceProjectionHost(), options);
+    }
+    async runMemoryEmbeddingBackfill(options = {}) {
+        return runMemoryEmbeddingBackfillImpl(this.resourceProjectionHost(), options);
+    }
+    hookDispatcher;
+    dispatchHookEvent(runId, event) {
+        if (!this.manifest.hooks?.length)
+            return;
+        this.hookDispatcher ??= createHookDispatcher({
+            agentName: this.agentName(),
+            hooks: this.manifest.hooks,
+            loadModule: (source) => this.sourceLoader.load(source),
+            logger: this.logger
+        });
+        return this.hookDispatcher(runId, event);
+    }
+    /** Per-run capability resolution from `resolvers.ts` (run-resolver.ts). */
+    resolveRunCapabilities(run, options, conversationId) {
+        const input = { runId: run.id, message: options.message };
+        if (options.channel !== undefined)
+            input.channel = options.channel;
+        if (conversationId !== undefined)
+            input.conversationId = conversationId;
+        if (options.metadata !== undefined)
+            input.metadata = options.metadata;
+        return resolveRunCapabilitiesImpl({
+            manifest: this.manifest,
+            env: this.env,
+            loadModule: (source) => this.sourceLoader.load(source),
+            appendEvent: (runId, type, data) => this.state.appendEvent(runId, type, data)
+        }, input);
+    }
+    async loadTool(tool, run) {
+        const stub = resolveEvalToolStub(this.evalStubCursors, run, tool.name) ?? this.toolStubs[tool.name];
+        if (stub) {
+            return {
+                description: tool.description,
+                inputSchema: tool.inputSchema,
+                execute: async (input) => stub(input)
+            };
+        }
+        // Only builtin-sourced entries resolve to the built-in implementation; an
+        // authored tool that shares a built-in's name is an override and loads its module.
+        if (tool.source.path.startsWith("__builtin__")) {
+            const builtIn = builtInToolDefinition(tool.name);
+            if (builtIn)
+                return builtIn;
+        }
+        const module = await this.sourceLoader.load(tool.source);
+        return module.default;
+    }
+    async loadInstrumentationModule() {
+        if (!this.manifest.instrumentation)
+            return {};
+        return this.sourceLoader.load(this.manifest.instrumentation);
+    }
+    async result(run, response, waitingForApproval, waitingForInput, waitingForConnection) {
+        const result = {
+            run,
+            events: await this.state.listEvents(run.id),
+            toolCalls: await this.state.listToolCalls(run.id),
+            deliveries: await this.state.listDeliveries(run.id),
+            response
+        };
+        if (waitingForApproval !== undefined)
+            result.waitingForApproval = waitingForApproval;
+        if (waitingForInput !== undefined)
+            result.waitingForInput = waitingForInput;
+        if (waitingForConnection !== undefined)
+            result.waitingForConnection = waitingForConnection;
+        return result;
+    }
+}
+export async function runLocalAgent(options) {
+    const runtime = new OpenEveRuntime(options);
+    return runtime.run(options);
+}
+export function runtimeAdapter(options = {}) {
+    return { kind: "runtime", options };
+}
+//# sourceMappingURL=index.js.map