@assemblyline-agents/runtime 5.0.10 → 6.0.1

package/dist/index.js

@@ -1,2159 +1,29 @@
-import { createHash } from "node:crypto";
-import { join, resolve } from "node:path";
-import { builtInToolDefinition } from "./builtin-tools.js";
-import { InMemoryModelCredentialStore } from "./model-credential-stores.js";
-import { CredentialBroker, environmentCredentialStore } from "./credential-broker.js";
-import { channelCredentialEnvironment } from "./channel-credential-environment.js";
-import { performConfiguredChannelOperation } from "./channel-operation.js";
-import { instrumentationSetupContext } from "./instrumentation-environment.js";
+export { AssemblyLineRuntime } from "./assembly-line-runtime.js";
 export * from "./public-api.js";
 export { builtInToolDefaults, FILES_MOUNT_TOOL_NAME, FILES_SEARCH_TOOL_NAME, HISTORY_SEARCH_TOOL_NAME, PAIR_TOOL_NAME } from "./builtin-tools.js";
 export { inspectAgentCapabilities } from "./capability-inspection.js";
 export { CONNECTION_PAIRING_UNAVAILABLE_EVENT, executePairTool } from "./builtin-tool-executors.js";
-import { evalRunOptionsForRun, resolveEvalToolStub, validateEvalRunOptions } from "./eval-run-options.js";
-import { rememberDefaultOutboundRoute } from "./default-outbound-route.js";
-import { audienceFromRun, audienceUserKey, normalizeAgentAudience } from "./audience.js";
-import { AgentSourceModuleLoader } from "./source-loader.js";
-import { SandboxAuthoredToolExecutor, resolveAuthoredToolExecutionPolicy } from "./sandbox-authored-tool-executor.js";
-import { AgentEventHandlerRegistry } from "./agent-event-handlers.js";
-import { createMainAgentHookController as createMainAgentHookControllerImpl, createSubagentHookController as createSubagentHookControllerImpl } from "./agent-hook-controller-factory.js";
-import { durableAgentSurfaceScope, flattenSubagents, surfaceForPath, surfaceForRun } from "./agent-surface.js";
-import { recoverAgentHookController, removeTerminalAgentHookState, resolvedInstructionsForRun as resolvedHookInstructionsForRun } from "./agent-hook-run-lifecycle.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";
-export { MAX_CHANNEL_TURN_COALESCING_WINDOW_MS, QUEUED_CHANNEL_TURN_COALESCING_KEY, QUEUED_CHANNEL_TURN_KEY, QUEUED_CHANNEL_TURN_MERGED_INTO_KEY, QUEUED_CHANNEL_TURN_PARTS_KEY } from "./conversation-turn-coalescing.js";
-import { ARTIFACT_DIR_NAME, ASSEMBLY_LINE_MANIFEST_SCHEMA_VERSION, manifestCredentialNames, resolveNonSecretRuntimeConfig, resolveRuntimeConfig } from "@assemblyline-agents/core";
-import { resolveBooleanEnv, resolveNonNegativeIntegerEnv, resolvePositiveIntegerEnv } from "./env-config.js";
-import { humanInputModeForChannel, withHumanInputMode } from "./human-input-routing.js";
-import { RunEventBus, withRunEventPublishing } from "./run-stream.js";
-import { failRun as failRunImpl, handleRunExecutionError, logTerminalRunEvent, settleCompletionBoundaryControlImpl } from "./run-outcome.js";
-import { eventRenewsRunProgress, RunProgressSupervisor } from "./run-heartbeat.js";
-import { redactTruncateJson } from "./content-capture.js";
-import { isJsonObject, safeJson } from "./json-util.js";
-import { sandboxSessionKeyForRun } from "./sandbox-session-key.js";
+export { MAX_CHANNEL_TURN_COALESCING_WINDOW_MS, QUEUED_CHANNEL_TURN_COALESCING_KEY, QUEUED_CHANNEL_TURN_KEY, QUEUED_CHANNEL_TURN_MERGED_INTO_KEY, QUEUED_CHANNEL_TURN_PARTS_KEY, } from "./conversation-turn-coalescing.js";
 export { sandboxSessionKeyForRun } from "./sandbox-session-key.js";
-import { conversationInitiator, defaultUserPrincipal, initiatorFromRun, normalizeAgentPrincipal, principalFromRun, principalUserId } from "./principals.js";
-import { InMemoryConnectionEventStore } from "./connection-event-store.js";
-import { acceptConnectionEvent, checkConnectionEvents, drainConnectionEventInbox, reconcileConnectionEvents } from "./connection-events.js";
-import { InMemoryConnectionAuthorizationSessionStore, InMemoryConnectionGrantStore, RuntimeConnectionRegistry } from "./connections.js";
 export { createConnectionAssetApi } from "./connection-assets.js";
-export { FileConnectionEventStore, InMemoryConnectionEventStore } from "./connection-event-store.js";
+export { FileConnectionEventStore, InMemoryConnectionEventStore, } from "./connection-event-store.js";
 export { connectionEventUrl } from "./connection-events.js";
-import { InMemoryConnectionDefinitionStore, InMemoryScheduleStore, InMemorySkillStore, compiledConnectionFromStored, isHostAllowed, resolveSkillsConfig, resolveSchedulesConfig, resolveConnectionsConfig } from "./self-improvement.js";
-import { InMemoryLearningStore } from "./learning-store.js";
-import { RuntimeLearningManager } from "./runtime-learning.js";
-import { materializeTurnAttachments } from "./attachments.js";
-import { mergeJsonObjects, processRuntimeTurnMedia } from "./turn-media.js";
-export { mergeJsonObjects, processTurnMedia } from "./turn-media.js";
-export { attachmentFetchTimeoutMs, attachmentRemoteUrl, attachmentTrustedForProvider, firstDownloadableUrl } from "./attachments.js";
+export { mergeJsonObjects, processTurnMedia, } from "./turn-media.js";
+export { mediaProcessorForChannel } from "./media-processor.js";
+export { attachmentRemoteUrl, attachmentTrustedForProvider } from "./attachments.js";
+export { attachmentFetchTimeoutMs, firstDownloadableUrl } from "./attachment-download.js";
 export { assertExternalHttpUrl, fetchExternalHttp, isPublicAddress } from "./outbound-http-policy.js";
-import { LocalSandboxAdapter } from "./local-sandbox.js";
-import { schedulerAdapterForKind } from "./scheduler.js";
-import { isTelemetrySink, telemetrySinkFromSetupResult } from "./telemetry.js";
-import { InMemoryStateAdapter, LocalBlobAdapter, StateMemoryStore, 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, latestRunFailureMessageImpl, recordChannelTurnStartImpl, sendDeliveryImpl, stopUnclaimedChannelTurnImpl, stopChannelTurnImpl } from "./delivery-send.js";
-import { backfillMemoryDocumentsFromFileIndexesImpl, hydrateLogicalPathForToolImpl, listResourcesForRunImpl, memoryScopeForRunImpl, projectLoadedSkillsIntoSandboxImpl, projectResourcesForRunImpl, projectSkillIntoSandboxImpl, readResourceForRunImpl, readSandboxTombstonesWithMissingProjectedFilesImpl, recordSandboxTombstoneImpl, runMemoryEmbeddingBackfillImpl } from "./resource-projection.js";
-import { createSkillBundleIndex, createSkillResourceReader } from "./skill-bundles.js";
-import { createSandboxHandleImpl } from "./sandbox-handle.js";
-import { RuntimeWorkspaceManager } from "./workspace-runtime.js";
-import { DynamicScheduleRuntimeMethods } from "./dynamic-schedule-runtime.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 { recordRunReplayStarted, rerunFromSnapshot } from "./run-replay.js";
 export { RunReplayError } from "./run-replay.js";
-import { buildRunAgentResult } from "./run-result.js";
-import { createSubagentRunImpl, executeSubagentRunImpl, finalizeSubagentHandoffImpl, readSubagentImpl, resumeSubagentImpl, runSubagentImpl, sendSubagentFollowupImpl } from "./subagent-execution.js";
-import { acceptBackgroundSubagentHandoff } from "./subagent-handoff.js";
-import { createHarnessContextImpl, DEFAULT_MAX_MODEL_ITERATIONS, DEFAULT_OUTPUT_VALIDATION_MAX_RETRIES, executeHarnessTurnImpl, persistHarnessContinuationImpl, resolveAgentHarnessImpl, runHarnessLoopImpl } from "./harness-loop.js";
-import { getAgentControlImpl, requestRunControlImpl, setAgentEnabledImpl, setAgentMaintenanceImpl } from "./operator-controls.js";
-import { acceptChannelTurnImpl, channelAttachmentResolverImpl, dispatchHttpChannelImpl, loadChannelModuleImpl, observeChannelMessageImpl, startChannelAgentTurnImpl, 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 { BackgroundSubagentCoordinator } from "./background-subagents.js";
-import { instructionsForRunTargetImpl } from "./target-instructions.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";
 export * from "./state.js";
 export * from "./principals.js";
 export * from "./audience.js";
 export { evalRunOptionsForRun, validateEvalRunOptions } from "./eval-run-options.js";
-export { InMemoryConversationStore, InMemoryConversationTurnStore, InMemoryFileIndexStore, InMemoryMemoryStateStore, InMemoryRunStore, InMemorySandboxSessionStore, InMemoryScheduleStateStore, InMemoryUsageStore, InMemoryWorkspaceStore, composeStateStores, normalizeMemoryPath, normalizeRuntimeState } from "./state-stores.js";
+export { InMemoryConversationStore, InMemoryConversationTurnStore, InMemoryFileIndexStore, InMemoryMemoryStateStore, InMemoryRunStore, InMemorySandboxSessionStore, InMemoryScheduleStateStore, InMemoryUsageStore, InMemoryWorkspaceStore, composeStateStores, normalizeMemoryPath, normalizeRuntimeState, } from "./state-stores.js";
 export * from "./workspace.js";
-export { applyDeliveryPatch, createDeliveryRecord, deliveryQueueRetryDelayMs, isDeliveryDue, normalizeDeliveryRecord, stateSupportsDeliveryQueue } from "./delivery-queue.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";
-import { visibleToolsForSkills } from "./sandbox-fs.js";
-import { resolveResourceProjectionPolicy } from "./resource-projection-util.js";
-import { syncMemoryFromSandbox, syncSkillsFromSandbox } from "./sandbox-state-sync.js";
-import { acquireSandboxForRun as acquireSandboxSessionForRun } from "./sandbox-session-lifecycle.js";
-import { resolveSandboxSnapshotPolicy } from "./sandbox-snapshot-policy.js";
-import { inferToolInput } from "./channel-http-util.js";
-import { connectionPrincipalKeyForGrant, durableAgentScopeForManifest, isInstrumentationDefinition, normalizeCapturePolicy, randomHex, timestamp, } from "./runtime-util.js";
-export class AssemblyLineRuntime extends DynamicScheduleRuntimeMethods {
-    manifest;
-    authoredToolExecution;
-    state;
-    runEventBus = new RunEventBus();
-    eventHandlers;
-    agentHookControllers = new Map();
-    agentStateHandles = new Map();
-    blob;
-    sandbox;
-    scheduler;
-    scheduleStore;
-    schedulesConfig;
-    mediaProcessors;
-    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;
-    modelCredentialStore;
-    defaultAgentHarness;
-    checkpointEveryIteration;
-    checkpointRetention;
-    checkpointBlobStorageEnabled;
-    devMode;
-    sourceBundle;
-    connections;
-    env;
-    /** Fully resolved non-secret runtime configuration. */
-    config;
-    fetch;
-    attachmentHostResolver;
-    logger;
-    connectionGrantStore;
-    credentialBroker;
-    gatewayCredentials;
-    connectionAuthorizationSessionStore;
-    connectionEventStore;
-    connectionCallbackBaseUrl;
-    skillStore;
-    learningStore;
-    memoryStore;
-    connectionDefinitionStore;
-    skillsConfig;
-    connectionsConfig;
-    runtimeLearning;
-    connectionScopeMigrated = false;
-    dynamicConnectionsCache;
-    schedulerEnabled;
-    schedulerTickMs;
-    scheduleMaxConsecutiveFailures;
-    now;
-    sandboxSnapshotPolicy;
-    sandboxSyncInline;
-    sandboxSyncLeaseMs;
-    sandboxSyncBatchSize;
-    sandboxSyncMaxAttempts;
-    deliveryQueueLeaseMs;
-    toolOutputMaxChars;
-    toolTimeoutMs;
-    deliveryQueueBatchSize;
-    deliveryQueueMaxAttempts;
-    deliveryQueueIntervalMs;
-    runHeartbeatMs;
-    runRecoveryIntervalMs;
-    maxModelIterations;
-    outputValidationMaxRetries;
-    runSemaphore;
-    conversationTurnDispatcher;
-    backgroundSubagents;
-    memoryEmbeddingProvider;
-    memoryEmbeddingsEnabled;
-    resourceProjectionPolicy;
-    coreToolPolicy;
-    telemetry;
-    instrumentationLoaded = false;
-    providerIngressSecurityLogged = false;
-    hostTelemetryProvided;
-    hostInstrumentationProvided;
-    instrumentationConfig;
-    sourceLoader;
-    sandboxAuthoredToolExecutor;
-    skillBundleIndex;
-    skillResourceReader;
-    contextPolicyPromise;
-    /** Fast local view of durable control intents, refreshed by run heartbeats. */
-    runControlIntents = new Map();
-    /** Runs currently owned by this process, used to route immediate control signals without leaking orphan ids. */
-    activeRunExecutions = new Set();
-    runProgress;
-    runStallTimeoutMs;
-    constructor(options) {
-        super();
-        this.manifest = options.manifest;
-        this.authoredToolExecution = resolveAuthoredToolExecutionPolicy(options.authoredToolExecution, options.devMode ?? false);
-        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.handleRuntimeEvent(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.mediaProcessors = options.mediaProcessors ?? [];
-        this.deliveryMode = options.deliveryMode ?? "send";
-        this.toolStubs = options.toolStubs ?? {};
-        this.devMode = options.devMode ?? false;
-        this.sourceBundle = options.sourceBundle ?? {};
-        this.connections = options.connections ?? {};
-        const resolvedEnvironment = resolveRuntimeConfig(this.manifest.productionConfig, options.env ?? process.env);
-        this.config = Object.freeze(resolveNonSecretRuntimeConfig({}, resolvedEnvironment, {}, manifestCredentialNames(this.manifest)));
-        this.env = Object.freeze(resolvedEnvironment);
-        this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
-        this.attachmentHostResolver = options.attachmentHostResolver;
-        this.logger = options.logger ??
-            createJsonConsoleLogger({ level: normalizeLogLevel(this.env.ASSEMBLY_LINE_LOG_LEVEL) ?? "info" });
-        this.eventHandlers = new AgentEventHandlerRegistry(this.agentName(), (runId, type, data) => this.state.appendEvent(runId, type, data), this.logger);
-        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.modelCredentialStore = options.modelCredentialStore ?? new InMemoryModelCredentialStore();
-        this.checkpointEveryIteration = resolveBooleanEnv(this.env.ASSEMBLY_LINE_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.gatewayCredentials = Object.freeze({ ...(options.gatewayCredentials ?? {}) });
-        this.credentialBroker = new CredentialBroker({
-            store: options.credentialStore ?? environmentCredentialStore(options.env ?? process.env),
-            grantStore: this.connectionGrantStore,
-            audit: async (record) => {
-                if (record.runId) {
-                    await this.state.appendEvent(record.runId, "connections.credential_used", {
-                        credential: record.credential,
-                        connection: record.connection,
-                        principal: record.principal,
-                        purpose: record.purpose,
-                        delivery: record.delivery,
-                        success: record.success,
-                        ...(record.expiresAt !== undefined ? { expiresAt: record.expiresAt } : {})
-                    });
-                }
-            }
-        });
-        this.connectionAuthorizationSessionStore = options.connectionAuthorizationSessionStore ?? new InMemoryConnectionAuthorizationSessionStore();
-        this.connectionEventStore = options.connectionEventStore ?? new InMemoryConnectionEventStore();
-        this.connectionCallbackBaseUrl = options.connectionCallbackBaseUrl;
-        this.skillStore = options.skillStore ?? new InMemorySkillStore();
-        this.learningStore = options.learningStore ?? new InMemoryLearningStore();
-        this.memoryEmbeddingProvider = options.memoryEmbeddingProvider;
-        const memoryEmbeddingsRequested = options.memoryEmbeddingsEnabled ??
-            resolveBooleanEnv(this.env.ASSEMBLY_LINE_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.ASSEMBLY_LINE_SCHEDULE_MAX_FAILURES, 5);
-        this.now = options.now ?? (() => new Date());
-        this.workspaceRuntime = new RuntimeWorkspaceManager({
-            state: this.state,
-            blob: this.blob,
-            agentScope: this.durableAgentScope(),
-            now: this.now,
-            env: this.env,
-            ...(this.memoryEmbeddingProvider ? { embeddingProvider: this.memoryEmbeddingProvider } : {}),
-            sandboxSessionKey: (run) => this.sandboxSessionKey(run)
-        });
-        this.runtimeLearning = new RuntimeLearningManager({
-            state: this.state, manifest: this.manifest,
-            env: this.env, logger: this.logger,
-            learningStore: this.learningStore,
-            skillStore: this.skillStore, memoryStore: this.memoryStore,
-            skillsConfigForSurface: (surfacePath) => this.skillsConfigForSurface(surfacePath),
-            skillScopeForSurface: (surfacePath) => this.skillScopeForSurface(surfacePath),
-            anySkillsEnabled: () => this.anySkillsEnabled(),
-            memoryScopeForRun: (run) => this.memoryScopeForRun(run),
-            resolveAgentHarness: (modelSpec) => this.resolveAgentHarness(modelSpec),
-            now: () => this.now()
-        });
-        this.sandboxSnapshotPolicy = resolveSandboxSnapshotPolicy(this.manifest, this.env, options.sandboxSnapshotPolicy);
-        this.sandboxSyncInline = options.sandboxSyncInline ?? resolveBooleanEnv(this.env.ASSEMBLY_LINE_SANDBOX_SYNC_INLINE, false);
-        this.sandboxSyncLeaseMs = options.sandboxSyncLeaseMs ?? resolvePositiveIntegerEnv(this.env.ASSEMBLY_LINE_SANDBOX_SYNC_LEASE_MS, 5 * 60_000);
-        this.sandboxSyncBatchSize = options.sandboxSyncBatchSize ?? resolvePositiveIntegerEnv(this.env.ASSEMBLY_LINE_SANDBOX_SYNC_BATCH_SIZE, 10);
-        this.sandboxSyncMaxAttempts = options.sandboxSyncMaxAttempts ?? resolvePositiveIntegerEnv(this.env.ASSEMBLY_LINE_SANDBOX_SYNC_MAX_ATTEMPTS, 5);
-        this.deliveryQueueLeaseMs = options.deliveryQueueLeaseMs ?? resolvePositiveIntegerEnv(this.env.ASSEMBLY_LINE_DELIVERY_QUEUE_LEASE_MS, 60_000);
-        this.toolOutputMaxChars = resolvePositiveIntegerEnv(this.env.ASSEMBLY_LINE_TOOL_OUTPUT_MAX_CHARS, DEFAULT_MODEL_OUTPUT_MAX_CHARS);
-        this.toolTimeoutMs = resolveNonNegativeIntegerEnv(this.env.ASSEMBLY_LINE_TOOL_TIMEOUT_MS, 600_000);
-        this.deliveryQueueBatchSize = options.deliveryQueueBatchSize ?? resolvePositiveIntegerEnv(this.env.ASSEMBLY_LINE_DELIVERY_QUEUE_BATCH_SIZE, 10);
-        this.deliveryQueueMaxAttempts = options.deliveryQueueMaxAttempts ?? resolvePositiveIntegerEnv(this.env.ASSEMBLY_LINE_DELIVERY_QUEUE_MAX_ATTEMPTS, 5);
-        this.deliveryQueueIntervalMs = options.deliveryQueueIntervalMs ?? resolvePositiveIntegerEnv(this.env.ASSEMBLY_LINE_DELIVERY_QUEUE_INTERVAL_MS, 15_000);
-        this.runHeartbeatMs = options.runHeartbeatMs ?? resolvePositiveIntegerEnv(this.env.ASSEMBLY_LINE_RUN_HEARTBEAT_MS, 30_000);
-        this.runStallTimeoutMs = options.runStallTimeoutMs ?? resolveNonNegativeIntegerEnv(this.env.ASSEMBLY_LINE_RUN_STALL_TIMEOUT_MS, 3_600_000);
-        this.runProgress = new RunProgressSupervisor({
-            state: this.state,
-            logger: this.logger,
-            runHeartbeatMs: this.runHeartbeatMs,
-            runStallTimeoutMs: this.runStallTimeoutMs,
-            runControlIntents: this.runControlIntents,
-            activeRuns: this.activeRunExecutions,
-            debugSwallow: (message, fields) => this.debugSwallow(message, fields)
-        });
-        this.runRecoveryIntervalMs = options.runRecoveryIntervalMs ?? resolvePositiveIntegerEnv(this.env.ASSEMBLY_LINE_RUN_RECOVERY_INTERVAL_MS, 60_000);
-        this.maxModelIterations = resolvePositiveIntegerEnv(this.env.ASSEMBLY_LINE_MAX_MODEL_ITERATIONS, DEFAULT_MAX_MODEL_ITERATIONS);
-        this.outputValidationMaxRetries = resolveNonNegativeIntegerEnv(this.env.ASSEMBLY_LINE_OUTPUT_VALIDATION_MAX_RETRIES, DEFAULT_OUTPUT_VALIDATION_MAX_RETRIES);
-        this.runSemaphore = new BoundedSemaphore({
-            maxConcurrent: options.maxConcurrentRuns ?? resolvePositiveIntegerEnv(this.env.ASSEMBLY_LINE_MAX_CONCURRENT_RUNS, Infinity),
-            maxQueued: options.maxQueuedRuns ?? resolvePositiveIntegerEnv(this.env.ASSEMBLY_LINE_MAX_QUEUED_RUNS, 0)
-        });
-        this.conversationTurnDispatcher = new ConversationTurnDispatcher({
-            state: this.state, logger: this.logger,
-            agentScope: this.durableAgentScope(),
-            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.resourcesRoot ? { resourcesRoot: options.resourcesRoot } : {}),
-            ...(options.artifactRoot ? {
-                cacheRoot: join(resolve(options.artifactRoot), ARTIFACT_DIR_NAME, "module-cache"),
-                packageRoot: resolve(options.artifactRoot)
-            } : {})
-        });
-        this.sandboxAuthoredToolExecutor = new SandboxAuthoredToolExecutor(this.sourceLoader);
-        this.skillBundleIndex = createSkillBundleIndex(this.manifest);
-        this.skillResourceReader = createSkillResourceReader({
-            manifest: this.manifest,
-            ...(options.resourcesRoot ? { resourcesRoot: options.resourcesRoot } : {}),
-            manifestRoot: this.manifest.root,
-            sourceBundle: this.sourceBundle
-        });
-        this.backgroundSubagents = new BackgroundSubagentCoordinator({
-            state: this.state,
-            logger: this.logger,
-            withRunAdmission: (work) => this.withRunAdmission(work),
-            execute: (childRunId) => executeSubagentRunImpl(this.subagentExecutionHost(), childRunId),
-            finalize: (timeline) => finalizeSubagentHandoffImpl(this.subagentExecutionHost(), timeline),
-            replay: (runId) => this.replay(runId),
-            cancel: (runId) => this.cancelRun(runId),
-            enqueueConversationTurn: (input) => this.conversationTurnDispatcher.enqueue(input)
-        });
-    }
-    boot() {
-        if (this.manifest.schemaVersion !== ASSEMBLY_LINE_MANIFEST_SCHEMA_VERSION) {
-            throw new Error(`Unsupported Assembly Line manifest schema ${this.manifest.schemaVersion}.`);
-        }
-        this.sourceLoader.ensureCacheReady();
-        if (!this.devMode) {
-            const credentials = new Set(manifestCredentialNames(this.manifest));
-            const missing = this.manifest.preflight.filter((requirement) => requirement.kind === "env" &&
-                requirement.required &&
-                requirement.adapter !== this.manifest.gateway.deploy?.kind &&
-                !credentials.has(requirement.name) &&
-                ![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, ...this.gatewayCredentials });
-        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 });
-        await this.runProgress.renew(input.runId);
-        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, ...this.gatewayCredentials });
-        if (warnings.length === 0)
-            return;
-        this.providerIngressSecurityLogged = true;
-        for (const warning of warnings) {
-            this.logger.warn("provider ingress security warning", { warning });
-        }
-    }
-    skillScope() { return this.skillScopeForSurface("root"); }
-    skillScopeForSurface(surfacePath) {
-        surfaceForPath(this.manifest, surfacePath);
-        return durableAgentSurfaceScope(this.durableAgentScope(), surfacePath);
-    }
-    skillScopeForRun(run) {
-        return this.skillScopeForSurface(surfaceForRun(this.manifest, run).path);
-    }
-    skillsConfigForSurface(surfacePath) {
-        if (surfacePath === "root")
-            return this.skillsConfig;
-        const surface = surfaceForPath(this.manifest, surfacePath);
-        return resolveSkillsConfig({
-            ...(this.manifest.agent.selfImprovement ?? {}),
-            ...(surface.selfImprovement ?? {})
-        }, this.env);
-    }
-    skillsConfigForRun(run) {
-        return this.skillsConfigForSurface(surfaceForRun(this.manifest, run).path);
-    }
-    anySkillsEnabled() {
-        return ["root", ...flattenSubagents(this.manifest.subagents).map((subagent) => subagent.path)]
-            .some((surfacePath) => this.skillsConfigForSurface(surfacePath).enabled);
-    }
-    connectionScope() { return this.durableAgentScope(); }
-    durableAgentScope() { return durableAgentScopeForManifest(this.manifest); }
-    usesRevisionScopedDurableState() { return this.durableAgentScope() === this.manifest.agentRevision; }
-    scheduleScopeForRun(run) {
-        const audience = audienceFromRun(run);
-        return audienceUserKey(audience)
-            ?? (!audience.private ? audience.conversationId : undefined)
-            ?? this.durableAgentScope();
-    }
-    /** Seed the durable skill store from compiled manifest skills (idempotent). */
-    async ensureSkillsSeeded(surfacePath = "root") { return this.runtimeLearning.ensureSkillsSeeded(surfacePath); }
-    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(surfacePath = "root") { return this.runtimeLearning.listSkills(surfacePath); }
-    /** Persist an agent/user authored skill, honoring the write-approval gate. */
-    async saveSkill(input, surfacePath = "root") { return this.runtimeLearning.saveSkill(input, surfacePath); }
-    async deleteSkill(name, surfacePath = "root") { return this.runtimeLearning.deleteSkill(name, surfacePath); }
-    async listSkillRevisions(name, surfacePath = "root") { return this.runtimeLearning.listSkillRevisions(name, surfacePath); }
-    async restoreSkillRevision(name, revision, surfacePath = "root") { return this.runtimeLearning.restoreSkillRevision(name, revision, surfacePath); }
-    async listPendingSkillChanges(surfacePath = "root") { return this.runtimeLearning.listPendingSkillChanges(surfacePath); }
-    async approveSkillChange(id, surfacePath = "root") { return this.runtimeLearning.approveSkillChange(id, surfacePath); }
-    async rejectSkillChange(id, surfacePath = "root") { return this.runtimeLearning.rejectSkillChange(id, surfacePath); }
-    async recordRunFeedback(runId, feedback) {
-        return this.runtimeLearning.recordRunFeedback(runId, feedback);
-    }
-    async listBackgroundReviews(surfacePath = "root") { return this.runtimeLearning.listBackgroundReviews(surfacePath); }
-    async runDueBackgroundReviews(options = {}) {
-        return this.runtimeLearning.runDueBackgroundReviews(options);
-    }
-    startBackgroundReviewWorker(options = {}) {
-        return this.runtimeLearning.startBackgroundReviewWorker(options);
-    }
-    /** 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) {
-        return syncMemoryFromSandbox(this.sandboxStateSyncHost(), run, sandboxSession, tombstones);
-    }
-    /** Reconcile skill files the agent explicitly edited/deleted under `/skills`. */
-    async syncSkillsFromSandbox(run, sandboxSession, tombstones) {
-        return syncSkillsFromSandbox(this.sandboxStateSyncHost(), run, sandboxSession, tombstones);
-    }
-    sandboxStateSyncHost() {
-        return {
-            state: this.state,
-            memoryStore: this.memoryStore,
-            skillStore: this.skillStore,
-            skillBundleIndex: this.skillBundleIndex,
-            learningStore: this.learningStore,
-            skillsConfigForRun: (run) => this.skillsConfigForRun(run),
-            memoryScopeForRun: (candidate) => this.memoryScopeForRun(candidate),
-            skillScopeForRun: (run) => this.skillScopeForRun(run)
-        };
-    }
-    createSandboxHandle(getRun, setRun, getBundle) {
-        return createSandboxHandleImpl({
-            state: this.state,
-            blob: this.blob,
-            acquireSandboxForRun: (run) => this.acquireSandboxForRun(run),
-            createCheckpoint: (input) => this.createCheckpoint(input),
-            legacyFullSandboxHydration: () => this.legacyFullSandboxHydration(),
-            hydrateWorkspace: (run, session) => this.workspaceRuntime.service.hydrate(run, session, this.sandboxSessionKey(run)),
-            projectLoadedSkills: (run, session) => this.projectLoadedSkillsIntoSandbox(run, session),
-            createConnectionRegistryForRun: (run, channel, selectedConnections) => this.createConnectionRegistryForRun(run, channel, undefined, selectedConnections),
-            wrapSandbox: (runId, session) => this.wrapSandbox(runId, session),
-            disposeSandboxSession: (runId, session) => this.disposeSandboxSession(runId, session)
-        }, getRun, setRun, getBundle);
-    }
-    sandboxSessionKey(run) {
-        return sandboxSessionKeyForRun(this.durableAgentScope(), run);
-    }
-    async acquireSandboxForRun(run) {
-        return acquireSandboxSessionForRun({
-            manifest: this.manifest,
-            env: this.env,
-            state: this.state,
-            sandbox: this.sandbox,
-            sessionKey: (candidate) => this.sandboxSessionKey(candidate),
-            swallow: (message, fields) => this.debugSwallow(message, fields)
-        }, run);
-    }
-    legacyFullSandboxHydration() {
-        return this.env.ASSEMBLY_LINE_LEGACY_FULL_SANDBOX_HYDRATION === "1" ||
-            this.env.ASSEMBLY_LINE_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.existingRun && typeof options.existingRun.input.channel === "string"
-            ? options.existingRun.input.channel
-            : undefined) ?? options.turn?.channel ?? options.channel ?? "local";
-        const channelDefinition = this.manifest.channels.find((candidate) => candidate.name === channel);
-        const suppliedConversationId = (options.existingRun && typeof options.existingRun.input.conversationId === "string"
-            ? options.existingRun.input.conversationId
-            : undefined) ?? options.turn?.conversationId ?? options.conversationId;
-        const legacyUserId = options.turn?.userId ?? options.userId;
-        const principal = (options.existingRun ? principalFromRun(options.existingRun) : undefined)
-            ?? normalizeAgentPrincipal(options.turn?.principal ?? options.principal)
-            ?? defaultUserPrincipal(legacyUserId, channel);
-        const initiator = (options.existingRun ? initiatorFromRun(options.existingRun) : undefined)
-            ?? normalizeAgentPrincipal(options.turn?.initiator ?? options.initiator)
-            ?? principal;
-        // Channel turns derive their audience from the authenticated turn, so it
-        // cannot disagree with the principal or conversation; other callers are
-        // trusted embedders and default to a private direct run.
-        const audience = (options.existingRun ? normalizeAgentAudience(options.existingRun.input.audience) : undefined)
-            ?? normalizeAgentAudience(options.turn?.audience ?? options.audience)
-            ?? { private: true };
-        const replyTarget = options.existingRun && isJsonObject(options.existingRun.input.replyTarget)
-            ? options.existingRun.input.replyTarget
-            : safeJson({
-                channel,
-                conversationId: suppliedConversationId ?? null,
-                delivery: options.turn?.delivery ?? options.delivery ?? null
-            });
-        const runInput = {
-            message: options.message,
-            agentSurface: "root",
-            channel,
-            eventId: options.turn?.eventId ?? options.eventId ?? null,
-            conversationId: suppliedConversationId ?? options.existingRun?.input.conversationId ?? null,
-            autoConversation: suppliedConversationId
-                ? false
-                : options.existingRun
-                    ? options.existingRun.input.autoConversation === true
-                    : true,
-            userId: principalUserId(principal) ?? legacyUserId ?? null,
-            principal: principal ? safeJson(principal) : null,
-            initiator: initiator ? safeJson(initiator) : null,
-            audience: safeJson(audience),
-            projectId: options.projectId ?? options.existingRun?.input.projectId ?? null,
-            workspaceId: options.workspaceId ?? options.existingRun?.input.workspaceId ?? null,
-            tenantId: options.tenantId ?? options.existingRun?.input.tenantId ?? null,
-            delivery: isJsonObject(replyTarget.delivery) ? replyTarget.delivery : null,
-            replyTarget,
-            metadata: options.metadata ?? options.turn?.metadata ?? {},
-            sandboxCredentials: options.sandboxCredentials ?? (options.existingRun && isJsonObject(options.existingRun.input.sandboxCredentials) ? options.existingRun.input.sandboxCredentials : {}),
-            ...(options.replay !== undefined ? { replay: safeJson(options.replay) } : {}),
-            ...(options.eval !== undefined ? { eval: validateEvalRunOptions(options.eval) } : {})
-        };
-        await rememberDefaultOutboundRoute({ manifest: this.manifest, state: this.state, agentScope: this.durableAgentScope(), now: this.now() }, options, runInput);
-        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 });
-        try {
-            await acceptBackgroundSubagentHandoff(this.state, run);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            run = await failRunImpl({ state: this.state }, run.id, {
-                reason: "subagent.handoff_failed",
-                error: message
-            });
-            return this.result(run, `Artifact handoff failed: ${message}`, false, false, false);
-        }
-        if (options.replay)
-            await recordRunReplayStarted(this.state, run.id, options.replay);
-        if (this.usesRevisionScopedDurableState() && (this.skillsConfig.enabled || 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."
-            });
-        }
-        const preExecution = await this.state.getRun(run.id);
-        if (preExecution?.status === "cancelled") {
-            return this.result(preExecution, "Run was cancelled before execution started.");
-        }
-        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 channelModule = channelDefinition
-                ? await this.loadChannelModule(channelDefinition)
-                : undefined;
-            const humanInputMode = humanInputModeForChannel(channelModule);
-            run = await this.state.updateRun(run.id, {
-                input: withHumanInputMode(run.input, humanInputMode)
-            });
-            await this.state.appendEvent(run.id, "human_input.route_selected", {
-                channel,
-                mode: humanInputMode
-            });
-            const turnAttachments = options.attachments ?? options.turn?.attachments ?? [];
-            let attachments = [];
-            if (turnAttachments.length > 0) {
-                if (typeof run.input.conversationId !== "string" || !run.input.conversationId) {
-                    run = await this.state.updateRun(run.id, {
-                        input: { ...run.input, conversationId: run.id }
-                    });
-                }
-                const fileWorkspace = await this.workspaceRuntime.service.resolveForRun(run);
-                const resolveAttachment = await this.channelAttachmentResolver(channelDefinition, trustedProvider);
-                attachments = await materializeTurnAttachments({
-                    run,
-                    workspaceId: fileWorkspace.id,
-                    channel,
-                    attachments: turnAttachments,
-                    ...(trustedProvider ? { trustedProvider } : {}),
-                    ...(resolveAttachment ? { resolveAttachment } : {}),
-                    allowRemoteDownload: options.allowRemoteAttachments === true,
-                    env: this.env,
-                    fetch: this.fetch,
-                    ...(this.attachmentHostResolver ? { hostResolver: this.attachmentHostResolver } : {}),
-                    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);
-            if (!conversation)
-                throw new Error("Every run must resolve a conversation before agent hook evaluation.");
-            hydratedOptions.conversationId = conversation.id;
-            const persistedInitiator = conversationInitiator(conversation.metadata) ?? initiatorFromRun(run);
-            if (persistedInitiator) {
-                hydratedOptions.initiator = persistedInitiator;
-                if (hydratedOptions.turn)
-                    hydratedOptions.turn = { ...hydratedOptions.turn, initiator: persistedInitiator };
-            }
-            if (run.input.conversationId !== conversation.id || persistedInitiator) {
-                run = await this.state.updateRun(run.id, {
-                    input: {
-                        ...run.input,
-                        conversationId: conversation.id,
-                        ...(persistedInitiator ? { initiator: safeJson(persistedInitiator) } : {})
-                    }
-                });
-            }
-            const hookController = await this.createAgentHookController(run, hydratedOptions, channel, conversation.id, attachments);
-            const capabilitySnapshot = await hookController.evaluate(options.existingRun ? "recovery" : "run_start");
-            const capabilities = capabilitySnapshot.declaration;
-            run = await this.state.updateRun(run.id, {
-                input: {
-                    ...run.input,
-                    model: capabilities.model,
-                    agentSandbox: capabilities.sandbox ?? null,
-                    agentConnections: capabilities.connections,
-                    agentSubagents: capabilities.subagents,
-                    attachmentMetadata: attachments
-                }
-            });
-            const media = await processRuntimeTurnMedia(this, run, attachments, hydratedOptions, channel, principalUserId(principal) ?? legacyUserId, conversation.id);
-            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, run.id) : []);
-            const contextInput = {
-                message: hydratedOptions.message,
-                channel,
-                recentHistory,
-                attachments,
-                capabilities,
-                run
-            };
-            const channelContext = mergeJsonObjects(media.channelContext, augmentation?.channelContext);
-            if (channelContext)
-                contextInput.channelContext = channelContext;
-            const activeWork = await this.backgroundSubagents.listForRoot(run);
-            if (hydratedOptions.promptContext || activeWork.length > 0) {
-                contextInput.promptContext = {
-                    ...(hydratedOptions.promptContext ?? {}),
-                    ...(activeWork.length > 0
-                        ? {
-                            activeWork: {
-                                items: activeWork,
-                                guidance: "These background tasks are still active. You may answer new messages while they run. Do not claim they are complete. Use manage_work to inspect or cancel them."
-                            }
-                        }
-                        : {})
-                };
-            }
-            if (hydratedOptions.target)
-                contextInput.target = hydratedOptions.target;
-            let bundle = options.contextSnapshot ? structuredClone(options.contextSnapshot) : 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 sandboxHandle = this.createSandboxHandle(() => run, (nextRun) => {
-                run = nextRun;
-            }, () => bundle);
-            await this.state.appendEvent(run.id, "harness.started", { harness: this.manifest.gateway.runtime?.kind ?? "node" });
-            const targetInstructions = await this.instructionsForRunTarget(run, hydratedOptions.target, bundle.instructions);
-            let response = options.message;
-            let structuredOutput;
-            const tool = this.selectTool(hydratedOptions);
-            if (tool) {
-                if (!capabilities.tools.includes(tool.name) && tool.visibility !== "deferred") {
-                    const message = `Forced tool ${tool.name} is not enabled by the current agent capability snapshot.`;
-                    const error = new Error(message);
-                    error.name = "AgentCapabilityViolationError";
-                    run = await failRunImpl({ state: this.state }, run.id, {
-                        reason: "run.capability_violation",
-                        error: message,
-                        data: { toolName: tool.name }
-                    });
-                    throw error;
-                }
-                const modelSpanStartedAt = timestamp();
-                await this.state.appendEvent(run.id, "model.request_started", { model: capabilities.model, forcedTool: tool.name });
-                await this.state.appendEvent(run.id, "model.response_completed", { model: capabilities.model, simulated: true });
-                await this.emitSpan("ai.streamText", modelSpanStartedAt, this.runSpanAttributes(run, {
-                    model: capabilities.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;
-                const stalled = await this.runProgress.failIfStalled(run);
-                if (stalled) {
-                    run = stalled;
-                    await stopChannelLifecycle();
-                    await sandboxHandle.dispose();
-                    return this.result(run, "Run stalled without durable progress.", false, false, false);
-                }
-                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,
-                    controller: hookController,
-                    refreshBundle: async (nextCapabilities) => {
-                        contextInput.capabilities = nextCapabilities;
-                        run = await this.state.getRun(run.id) ?? run;
-                        contextInput.run = run;
-                        bundle = await this.buildContextBundle(contextInput);
-                        return bundle;
-                    },
-                    instructions: targetInstructions
-                };
-                if (hydratedOptions.turn)
-                    loopInput.turn = hydratedOptions.turn;
-                if (conversation?.id) {
-                    loopInput.conversationId = conversation.id;
-                    if (!options.contextSnapshot)
-                        loopInput.transcript = await this.loadConversationTranscript(conversation.id, run.id);
-                }
-                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) {
-            await handleRunExecutionError({
-                state: this.state,
-                logger: this.logger,
-                deliveryQueueMaxAttempts: this.deliveryQueueMaxAttempts,
-                now: () => this.now()
-            }, 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 and supervise its progress lease. */
-    startRunHeartbeat(runId) {
-        return this.runProgress.start(runId);
-    }
-    conversationContextHost() {
-        const runtime = this;
-        return {
-            state: this.state,
-            manifest: this.manifest,
-            logger: this.logger,
-            coreToolPolicy: this.coreToolPolicy,
-            memoryStore: this.memoryStore,
-            skillStore: this.skillStore,
-            skillBundleIndex: this.skillBundleIndex,
-            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: (surfacePath) => this.ensureSkillsSeeded(surfacePath),
-            skillScopeForSurface: (surfacePath) => this.skillScopeForSurface(surfacePath),
-            surfaceForRun: (run) => surfaceForRun(this.manifest, run)
-        };
-    }
-    async prepareConversation(run, options, channel) {
-        return prepareConversationImpl(this.conversationContextHost(), run, options, channel);
-    }
-    async recentHistory(conversationId, excludeRunId) {
-        return recentHistoryImpl(this.conversationContextHost(), conversationId, excludeRunId);
-    }
-    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,
-            modelCredentialStore: this.modelCredentialStore,
-            agentHarnessOverride: this.agentHarnessOverride,
-            checkpointEveryIteration: this.checkpointEveryIteration,
-            maxModelIterations: this.maxModelIterations,
-            outputValidationMaxRetries: this.outputValidationMaxRetries,
-            now: () => this.now(),
-            shouldStopRun: (runId) => this.runProgress.shouldStop(runId),
-            runStalled: (runId) => this.runProgress.isStalled(runId),
-            registerRunAbort: (runId, controller) => this.runProgress.registerAbort(runId, controller),
-            runStallTimeoutMs: this.runStallTimeoutMs,
-            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, selectedConnections) => this.createConnectionRegistryForRun(run, fallbackChannel, sandboxHandle, selectedConnections),
-            missingRequiredConnections: (selected) => this.missingRequiredConnections(selected),
-            visibleToolSet: (defaultToolNames, activeSkills) => this.visibleToolSet(defaultToolNames, activeSkills),
-            modelTools: (run, activeToolNames, sandboxHandle, connectionRegistry, discoveredConnectionTools, options) => this.modelTools(run, activeToolNames, sandboxHandle, connectionRegistry, discoveredConnectionTools, options),
-            harnessExecuteTool: (call, state) => this.harnessExecuteTool(call, state),
-            createCheckpoint: (input) => this.createCheckpoint(input),
-            hydrateCheckpointData: (data) => this.hydrateCheckpointData(data),
-            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) {
-        const resolvedModel = modelSpec ?? this.manifest.possibleModels[0];
-        if (!resolvedModel)
-            throw new Error("No compiled model is available for harness resolution.");
-        return resolveAgentHarnessImpl(this.harnessLoopHost(), resolvedModel);
-    }
-    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),
-            hydrateCheckpointData: (data) => this.hydrateCheckpointData(data)
-        }, 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,
-            credentialBroker: this.credentialBroker,
-            connectionCallbackBaseUrl: this.connectionCallbackBaseUrl,
-            boot: () => this.boot(),
-            initializeInstrumentation: () => this.initializeInstrumentation(),
-            ensureDynamicConnections: () => this.ensureDynamicConnections(),
-            withRunAdmission: (work) => this.withRunAdmission(work),
-            listHydratedCheckpoints: (runId) => this.listHydratedCheckpoints(runId),
-            hydrateCheckpointData: (data) => this.hydrateCheckpointData(data),
-            resolveAgentHarness: (modelSpec) => this.resolveAgentHarness(modelSpec),
-            ensureAgentHookController: (run) => this.ensureAgentHookController(run),
-            resolvedInstructionsForRun: (run, bundle, capabilities) => resolvedHookInstructionsForRun(this.manifest, run, bundle.instructions, capabilities),
-            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, selectedConnections) => this.createConnectionRegistryForRun(run, fallbackChannel, sandboxHandle, selectedConnections),
-            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, refreshCapabilities) => executeHarnessTurnImpl(this.harnessLoopHost(), harness, input, session, loopState, resumed, refreshCapabilities),
-            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),
-            enqueueConversationTurn: (input) => this.conversationTurnDispatcher.enqueue(input)
-        };
-    }
-    async replay(runId) {
-        return replayImpl(this.replayResumeHost(), runId);
-    }
-    /** Start a new, isolated run from a terminal run's verified durable input snapshot. */
-    async rerun(runId, lifecycle) {
-        return rerunFromSnapshot({ runId, state: this.state, blob: this.blob, manifest: this.manifest, run: (options) => this.run(options) }, lifecycle);
-    }
-    /** 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 authorizationSession = callback.params.state
-            ? await this.connectionAuthorizationSessionStore.getSessionByState(callback.params.state)
-            : undefined;
-        const result = await completeConnectionAuthorizationCallbackImpl(this.replayResumeHost(), callback);
-        if (result.runResult)
-            await this.conversationTurnDispatcher.settleRunResult(result.runResult);
-        if (authorizationSession) {
-            await this.reconcileConnectionEvents({
-                connection: authorizationSession.connectionName,
-                principal: authorizationSession.principal,
-                force: true
-            }).catch((error) => this.logger.warn("connection event reconcile after authorization failed", {
-                connection: authorizationSession.connectionName,
-                error: error instanceof Error ? error.message : String(error)
-            }));
-        }
-        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 /assembly-line/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);
-    }
-    connectionEventsHost(publicUrl) {
-        const resolvedPublicUrl = publicUrl ?? this.connectionCallbackBaseUrl;
-        return {
-            manifest: this.manifest,
-            env: this.env,
-            fetch: this.fetch,
-            logger: this.logger,
-            agentScope: this.durableAgentScope(),
-            store: this.connectionEventStore,
-            grantStore: this.connectionGrantStore,
-            ...(resolvedPublicUrl ? { publicUrl: resolvedPublicUrl } : {}),
-            createRegistry: (principal) => new RuntimeConnectionRegistry({
-                connections: this.mergedConnections(),
-                config: this.env,
-                credentialBroker: this.credentialBroker,
-                fetch: this.fetch,
-                session: {
-                    channel: "connection-event",
-                    principal,
-                    ...(principal.type === "user" ? { userId: principal.id } : {})
-                },
-                agentId: this.manifest.agent.id ?? this.manifest.agentRevision,
-                grantStore: this.connectionGrantStore,
-                authorizationSessionStore: this.connectionAuthorizationSessionStore,
-                ...(this.connectionCallbackBaseUrl ? { callbackBaseUrl: this.connectionCallbackBaseUrl } : {}),
-                loadDefinition: async (connection) => this.loadConnectionDefinition(connection)
-            }),
-            dispatchAutomationEvent: (event) => this.dispatchAutomationEvent(event),
-            appendAudit: (type, data) => this.state.appendRuntimeControlEvent(this.durableAgentScope(), type, data)
-        };
-    }
-    async reconcileConnectionEvents(options = {}) {
-        return reconcileConnectionEvents(this.connectionEventsHost(options.publicUrl), options);
-    }
-    async checkConnectionEvents(connection) {
-        return checkConnectionEvents(this.connectionEventsHost(), connection);
-    }
-    async acceptConnectionEvent(connectionName, bindingId, request) {
-        return acceptConnectionEvent(this.connectionEventsHost(), connectionName, bindingId, request);
-    }
-    async runDueConnectionEvents(options = {}) {
-        return drainConnectionEventInbox(this.connectionEventsHost(), options);
-    }
-    startConnectionEventWorker(options = {}) {
-        const intervalMs = positiveLimit(options.intervalMs, 1_000);
-        const tick = () => this.runDueConnectionEvents({
-            ...(options.batchSize !== undefined ? { limit: options.batchSize } : {}),
-            ...(options.leaseForMs !== undefined ? { leaseForMs: options.leaseForMs } : {})
-        }).catch((error) => this.logger.warn("connection event worker tick failed", { error: error instanceof Error ? error.message : String(error) }));
-        void tick();
-        const timer = setInterval(() => void tick(), intervalMs);
-        timer.unref?.();
-        const reconcile = () => this.reconcileConnectionEvents().catch((error) => this.logger.warn("connection event reconcile tick failed", {
-            error: error instanceof Error ? error.message : String(error)
-        }));
-        void reconcile();
-        const reconcileTimer = setInterval(() => void reconcile(), 60_000);
-        reconcileTimer.unref?.();
-        return { stop: () => { clearInterval(timer); clearInterval(reconcileTimer); } };
-    }
-    /** 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) => this.runProgress.cacheControl(runId, intent)
-        };
-    }
-    async resumeHarnessLoop(run, harness, restored, resume) {
-        return resumeHarnessLoopImpl(this.replayResumeHost(), run, harness, restored, resume);
-    }
-    subagentExecutionHost() {
-        return {
-            state: this.state,
-            blob: this.blob,
-            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),
-            createSubagentHookController: (run, subagent, message, conversationId) => this.createSubagentHookController(run, subagent, message, conversationId),
-            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 resumeSubagent(parentRunId, childRunId, subagentName, message) {
-        return resumeSubagentImpl(this.subagentExecutionHost(), parentRunId, childRunId, subagentName, message);
-    }
-    async queueSubagent(parentRunId, subagentName, task) {
-        const child = await createSubagentRunImpl(this.subagentExecutionHost(), parentRunId, subagentName, task, { background: true });
-        this.backgroundSubagents.requestDrain();
-        return child;
-    }
-    async listBackgroundWork(rootRunId, includeTerminal = false) {
-        const root = await this.state.getRun(rootRunId);
-        if (!root)
-            throw new Error(`Run not found: ${rootRunId}`);
-        return this.backgroundSubagents.listForRoot(root, includeTerminal);
-    }
-    async getBackgroundWork(rootRunId, childRunId) {
-        const root = await this.state.getRun(rootRunId);
-        if (!root)
-            throw new Error(`Run not found: ${rootRunId}`);
-        return this.backgroundSubagents.getForRoot(root, childRunId);
-    }
-    async cancelBackgroundWork(rootRunId, childRunId) {
-        const root = await this.state.getRun(rootRunId);
-        if (!root)
-            throw new Error(`Run not found: ${rootRunId}`);
-        return this.backgroundSubagents.cancelForRoot(root, childRunId);
-    }
-    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 run = await this.state.getRun(runId);
-        if (!run)
-            throw new Error(`Run not found: ${runId}`);
-        const controller = await this.ensureAgentHookController(run);
-        const snapshot = await controller.refreshIfDirty();
-        if (!snapshot.declaration.skills.includes(skillName)) {
-            throw new Error(`Skill ${skillName} is not enabled by the current agent capability snapshot.`);
-        }
-        const loaded = await this.skillLoadDetails(run, 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.ASSEMBLY_LINE_SCHEDULER_ENABLED === "false" || this.env.ASSEMBLY_LINE_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,
-            connectionAuthorizationSessionStore: this.connectionAuthorizationSessionStore,
-            missingRequiredConnections: (selected) => this.missingRequiredConnections(selected),
-            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, subagent, background-review, 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),
-            startBackgroundSubagentWorker: (workerOptions) => this.backgroundSubagents.startWorker(workerOptions?.intervalMs),
-            startBackgroundReviewWorker: (workerOptions) => this.startBackgroundReviewWorker(workerOptions),
-            startConnectionEventWorker: (workerOptions) => this.startConnectionEventWorker(workerOptions),
-            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,
-            workspaceFilesForDelivery: async (run) => {
-                const workspace = await this.workspaceRuntime.service.resolveForRun(run);
-                return (await this.workspaceRuntime.service.loadManifest(workspace)).manifest.entries;
-            },
-            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);
-    }
-    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),
-            syncWorkspace: (run, sandboxSession, syncJob) => this.workspaceRuntime.sync(run, sandboxSession, syncJob),
-            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(run, skillName) {
-        return skillLoadDetailsImpl(this.toolExecutionHost(), run, skillName);
-    }
-    async instructionsForRunTarget(run, target, baseInstructions) {
-        return instructionsForRunTargetImpl({ appendEvent: (runId, type, data) => this.state.appendEvent(runId, type, data), skillLoadDetails: (skillName) => this.skillLoadDetails(run, skillName) }, run, target, baseInstructions);
-    }
-    async modelTools(run, activeToolNames, sandboxHandle, connectionRegistry, discoveredConnectionTools = new Map(), options) {
-        return modelToolsImpl(this.toolExecutionHost(), run, activeToolNames, sandboxHandle, connectionRegistry, discoveredConnectionTools, options);
-    }
-    async harnessExecuteTool(call, state) {
-        return harnessExecuteToolImpl(this.toolExecutionHost(), call, state);
-    }
-    createConnectionRegistry(channel, turn) {
-        return createConnectionRegistryImpl(this.toolExecutionHost(), channel, turn);
-    }
-    createConnectionRegistryForRun(run, fallbackChannel, sandboxHandle, selectedConnections) {
-        return createConnectionRegistryForRunImpl(this.toolExecutionHost(), run, fallbackChannel, sandboxHandle, selectedConnections);
-    }
-    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: channelCredentialEnvironment(channel, this.env, this.gatewayCredentials),
-            fetch: this.fetch,
-            state: this.state,
-            blob: this.blob,
-            agent: {
-                start: (turn) => startChannelAgentTurnImpl(this.channelIngressHost(), channel.name, turn),
-                observe: (observation) => observeChannelMessageImpl(this.channelIngressHost(), channel, observation),
-                cancel: (runId) => this.cancelRun(runId)
-            }
-        };
-    }
-    missingRequiredConnections(selected) {
-        const selectedNames = new Set(selected);
-        return this.manifest.connections
-            .filter((connection) => selectedNames.has(connection.name) && 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 = this.manifest.instrumentation
-            ? await this.sourceLoader.load(this.manifest.instrumentation)
-            : {};
-        const defaultExport = instrumentation.default;
-        const definition = isInstrumentationDefinition(defaultExport) ? defaultExport : undefined;
-        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(instrumentationSetupContext(definition, this.agentName(), this.manifest, this.env, this.gatewayCredentials))
-            : 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 ?? `assembly-line-${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,
-            blob: this.blob,
-            env: this.env,
-            fetch: this.fetch,
-            manifest: this.manifest,
-            coreToolPolicy: this.coreToolPolicy,
-            skillStore: this.skillStore,
-            skillBundleIndex: this.skillBundleIndex,
-            memoryStore: this.memoryStore,
-            sandbox: this.sandbox,
-            connections: this.connections,
-            connectionGrantStore: this.connectionGrantStore,
-            credentialBroker: this.credentialBroker,
-            connectionAuthorizationSessionStore: this.connectionAuthorizationSessionStore,
-            connectionCallbackBaseUrl: this.connectionCallbackBaseUrl,
-            toolOutputMaxChars: this.toolOutputMaxChars,
-            authoredToolExecution: this.authoredToolExecution,
-            toolTimeoutMs: this.toolTimeoutMs,
-            sandboxSyncMaxAttempts: this.sandboxSyncMaxAttempts,
-            skillsConfigForRun: (run) => this.skillsConfigForRun(run),
-            schedulesConfig: this.schedulesConfig,
-            connectionsConfig: this.connectionsConfig,
-            surfaceForRun: (run) => surfaceForRun(this.manifest, run),
-            agentStateForRun: (runId) => this.agentStateForRun(runId),
-            reportRunProgress: async (runId, data = {}) => {
-                await this.state.appendEvent(runId, "run.progress_reported", data);
-            },
-            performChannelOperation: (run, operation, input, channelName) => performConfiguredChannelOperation({
-                run,
-                operation,
-                arguments: input,
-                ...(channelName ? { channelName } : {}),
-                channels: this.manifest.channels,
-                loadModule: (channel) => this.loadChannelModule(channel),
-                context: (channel) => this.channelContext(channel)
-            }),
-            ensureSkillsSeeded: (run) => this.ensureSkillsSeeded(surfaceForRun(this.manifest, run).path),
-            skillScopeForRun: (run) => this.skillScopeForRun(run),
-            scheduleScopeForRun: (run) => this.scheduleScopeForRun(run),
-            memoryScopeForRun: (run) => this.memoryScopeForRun(run),
-            sandboxSessionKey: (run) => this.sandboxSessionKey(run),
-            mergedConnections: () => this.mergedConnections(),
-            loadConnectionDefinition: (connection) => this.loadConnectionDefinition(connection),
-            resolveToolStub: (run, toolName) => this.resolveToolStub(run, toolName),
-            loadTool: (tool, run) => this.loadTool(tool, run),
-            shouldSandboxAuthoredTool: (tool, run) => this.shouldSandboxAuthoredTool(tool, run),
-            describeSandboxedTool: (tool, sandboxHandle) => this.sandboxAuthoredToolExecutor.describe(tool, sandboxHandle),
-            executeSandboxedTool: (tool, input, context, sandboxHandle, signal) => this.sandboxAuthoredToolExecutor.execute(tool, input, context, sandboxHandle, signal),
-            runSubagent: (parentRunId, subagentName, task) => this.runSubagent(parentRunId, subagentName, task),
-            queueSubagent: (parentRunId, subagentName, task) => this.queueSubagent(parentRunId, subagentName, task),
-            resumeSubagent: (parentRunId, childRunId, subagentName, message) => this.resumeSubagent(parentRunId, childRunId, subagentName, message),
-            listBackgroundWork: (rootRunId, includeTerminal) => this.listBackgroundWork(rootRunId, includeTerminal),
-            getBackgroundWork: (rootRunId, childRunId) => this.getBackgroundWork(rootRunId, childRunId),
-            cancelBackgroundWork: (rootRunId, childRunId) => this.cancelBackgroundWork(rootRunId, childRunId),
-            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),
-            executeWorkspaceTool: (run, toolName, input, sandboxHandle) => this.workspaceRuntime.executeTool(run, toolName, input, sandboxHandle),
-            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, run) => this.saveSkill(input, surfaceForRun(this.manifest, run).path),
-            listSkills: (run) => this.listSkills(surfaceForRun(this.manifest, run).path),
-            deleteSkill: (name, run) => this.deleteSkill(name, surfaceForRun(this.manifest, run).path),
-            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) {
-        const abortController = new AbortController();
-        const unregisterAbort = this.runProgress.registerAbort(run.id, abortController);
-        try {
-            return await executeToolImpl(this.toolExecutionHost(), run, tool, input, sandboxHandle, approved, idempotencyKey, abortController.signal);
-        }
-        finally {
-            unregisterAbort();
-        }
-    }
-    async executeToolWithRecord(run, tool, toolCall, input, sandboxHandle, approvedToolCall = false) {
-        const abortController = new AbortController();
-        const unregisterAbort = this.runProgress.registerAbort(run.id, abortController);
-        try {
-            return await executeToolWithRecordImpl(this.toolExecutionHost(), run, tool, toolCall, input, sandboxHandle, approvedToolCall, abortController.signal);
-        }
-        finally {
-            unregisterAbort();
-        }
-    }
-    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,
-            skillBundleIndex: this.skillBundleIndex,
-            skillResourceReader: this.skillResourceReader,
-            resourceProjectionPolicy: this.resourceProjectionPolicy,
-            memoryEmbeddingProvider: this.memoryEmbeddingProvider,
-            memoryEmbeddingsEnabled: this.memoryEmbeddingsEnabled,
-            skillScopeForRun: (run) => this.skillScopeForRun(run),
-            durableAgentScope: () => this.durableAgentScope(),
-            surfaceForRun: (run) => surfaceForRun(this.manifest, run)
-        };
-    }
-    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 projectLoadedSkillsIntoSandbox(run, sandbox) {
-        return projectLoadedSkillsIntoSandboxImpl(this.resourceProjectionHost(), run, sandbox);
-    }
-    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);
-    }
-    async dispatchHookEvent(runId, event) {
-        await this.eventHandlers?.dispatch(runId, event);
-        if (this.eventHandlers)
-            removeTerminalAgentHookState(runId, event, this.eventHandlers, this.agentHookControllers, this.agentStateHandles);
-    }
-    async handleRuntimeEvent(runId, event) {
-        if (eventRenewsRunProgress(event.type))
-            await this.runProgress.renew(runId);
-        await this.dispatchHookEvent(runId, event);
-        await this.runtimeLearning.handleRuntimeEvent(runId, event.type);
-    }
-    async createAgentHookController(run, options, channel, conversationId, attachments) {
-        const created = await createMainAgentHookControllerImpl(this.agentHookControllerFactoryHost(), run, options, channel, conversationId, attachments);
-        return this.rememberAgentHookController(run.id, created);
-    }
-    async createSubagentHookController(run, subagent, message, conversationId) {
-        const created = await createSubagentHookControllerImpl(this.agentHookControllerFactoryHost(), run, subagent, message, conversationId);
-        return this.rememberAgentHookController(run.id, created);
-    }
-    agentHookControllerFactoryHost() {
-        return {
-            manifest: this.manifest,
-            state: this.state,
-            blob: this.blob,
-            sourceLoader: this.sourceLoader,
-            eventHandlers: this.eventHandlers,
-            logger: this.logger,
-            durableAgentScope: () => this.durableAgentScope(),
-            listSkillNames: async (surfacePath) => (await this.listSkills(surfacePath)).map((skill) => skill.name).sort(),
-            disabledToolsForRun: () => new Set(Object.entries(this.coreToolPolicy).filter(([, mode]) => mode === "disabled").map(([name]) => name)),
-            createCheckpoint: (input) => this.createCheckpoint(input),
-            listCheckpoints: (runId) => this.listHydratedCheckpoints(runId)
-        };
-    }
-    rememberAgentHookController(runId, created) {
-        this.agentStateHandles.set(runId, created.agentState);
-        this.agentHookControllers.set(runId, created.controller);
-        return created.controller;
-    }
-    agentStateForRun(runId) {
-        const handle = this.agentStateHandles.get(runId);
-        if (!handle)
-            throw new Error(`Agent state is unavailable before hook evaluation for run ${runId}.`);
-        return handle;
-    }
-    async ensureAgentHookController(run) {
-        const existing = this.agentHookControllers.get(run.id);
-        if (existing)
-            return existing;
-        return recoverAgentHookController({
-            run,
-            manifest: this.manifest,
-            createMain: (message, metadata, channel, conversationId, attachments) => this.createAgentHookController(run, { message, ...(metadata ? { metadata } : {}) }, channel, conversationId, attachments),
-            createSubagent: (subagent, message, conversationId) => this.createSubagentHookController(run, subagent, message, conversationId)
-        });
-    }
-    async loadTool(tool, run) {
-        const stub = run ? this.resolveToolStub(run, tool.name) : this.toolStubs[tool.name];
-        if (stub) {
-            return {
-                description: tool.description,
-                inputSchema: tool.inputSchema,
-                execute: async (input) => stub(input)
-            };
-        }
-        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;
-    }
-    resolveToolStub(run, toolName) {
-        return resolveEvalToolStub(this.evalStubCursors, run, toolName) ?? this.toolStubs[toolName];
-    }
-    shouldSandboxAuthoredTool(tool, run) {
-        if (tool.source.path.startsWith("__builtin__"))
-            return false;
-        if (this.toolStubs[tool.name] || evalRunOptionsForRun(run)?.toolStubs?.[tool.name])
-            return false;
-        return this.authoredToolExecution === "sandbox" || tool.execution === "sandbox";
-    }
-    async result(run, response, waitingForApproval, waitingForInput, waitingForConnection) {
-        return buildRunAgentResult(this.state, run, response, waitingForApproval, waitingForInput, waitingForConnection);
-    }
-}
-export async function runLocalAgent(options) { return new AssemblyLineRuntime(options).run(options); }
-export function runtimeAdapter(options = {}) { return { kind: "runtime", options }; }
 //# sourceMappingURL=index.js.map