@assemblyline-agents/runtime 1.0.0 → 3.0.0

package/dist/index.js

@@ -1,91 +1,109 @@
 import { createHash } from "node:crypto";
 import { join, resolve } from "node:path";
 import { builtInToolDefinition } from "./builtin-tools.js";
-export { builtInToolDefaults } from "./builtin-tools.js";
-import { createHookDispatcher } from "./hook-dispatch.js";
+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 { resolveEvalToolStub, validateEvalRunOptions } from "./eval-run-options.js";
-import { resolveRunCapabilitiesImpl } from "./run-resolver.js";
+import { rememberDefaultOutboundRoute } from "./default-outbound-route.js";
+import { audienceFromRun, audienceUserKey, normalizeAgentAudience } from "./audience.js";
 import { AgentSourceModuleLoader } from "./source-loader.js";
+import { AgentEventHandlerRegistry } from "./agent-event-handlers.js";
+import { immutableAgentRunContext } from "./agent-hook-evaluation.js";
+import { hookCapabilityCatalog } from "./agent-hook-context.js";
+import { flattenSubagents, rootAgentSurface, subagentSurface, surfaceForPath, surfaceForRun, durableAgentSurfaceScope } from "./agent-surface.js";
+import { createRuntimeAgentHookController, 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";
-import { OPENEVE_MANIFEST_SCHEMA_VERSION, applyEnvAliases, hasCurrentSandboxFilesystemContract, sandboxFilesystemContractMetadata } from "@assemblyline-agents/core";
+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 } 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 { handleRunExecutionError, logTerminalRunEvent, settleCompletionBoundaryControlImpl } from "./run-outcome.js";
-import { registerRunAbortController, startRunHeartbeatImpl } from "./run-heartbeat.js";
+import { failRun as failRunImpl, handleRunExecutionError, logTerminalRunEvent, settleCompletionBoundaryControlImpl } from "./run-outcome.js";
+import { cacheRunControlSignal, registerRunAbortController, startRunHeartbeatImpl, trackActiveRunHeartbeat } 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 { sandboxSessionKeyForRun } from "./sandbox-session-key.js";
-import { InMemoryConnectionAuthorizationSessionStore, InMemoryConnectionGrantStore, materializeConnectionCredentialsIntoSandbox } from "./connections.js";
-import { InMemoryConnectionDefinitionStore, InMemoryScheduleStore, InMemorySkillStore, compiledConnectionFromStored, isHostAllowed, liveSkills, resolveSkillsConfig, resolveSchedulesConfig, resolveConnectionsConfig, seedSkills, writeSkill } from "./self-improvement.js";
+import { 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 { 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";
-// Attachment helpers for channel modules implementing `resolveAttachment`.
+import { mergeJsonObjects, processRuntimeTurnMedia } from "./turn-media.js";
+export { mergeJsonObjects, processTurnMedia } from "./turn-media.js";
 export { attachmentFetchTimeoutMs, attachmentRemoteUrl, attachmentTrustedForProvider, firstDownloadableUrl } from "./attachments.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, memoryBodyText, positiveLimit } from "./storage.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, enqueueSandboxSyncAfterDeliveryImpl, latestRunFailureMessageImpl, recordChannelTurnStartImpl, sendDeliveryImpl, stopUnclaimedChannelTurnImpl, stopChannelTurnImpl } from "./delivery-send.js";
-import { backfillMemoryDocumentsFromFileIndexesImpl, hydrateLogicalPathForToolImpl, listResourcesForRunImpl, memoryScopeForRunImpl, projectResourcesForRunImpl, projectSkillIntoSandboxImpl, readResourceForRunImpl, readSandboxTombstonesWithMissingProjectedFilesImpl, recordSandboxTombstoneImpl, runMemoryEmbeddingBackfillImpl } from "./resource-projection.js";
+import { 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, WorkspaceRuntimeMethods } from "./workspace-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 { readSubagentImpl, runSubagentImpl, sendSubagentFollowupImpl } from "./subagent-execution.js";
-import { createHarnessContextImpl, DEFAULT_MAX_MODEL_ITERATIONS, DEFAULT_OUTPUT_VALIDATION_MAX_RETRIES, executeHarnessTurnImpl, persistHarnessContinuationImpl, piHarnessImpl, resolveAgentHarnessImpl, runHarnessLoopImpl } from "./harness-loop.js";
+import { 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, startChannelIngressImpl } from "./channel-ingress.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 { instructionsForRunTargetImpl } from "./run-resolver.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";
-// State record types, capability facets (RunStore & friends), the
-// StateAdapter intersection, StateStores, and the capability guards.
 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, composeStateStores, 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 { defaultRunStaleAfterMs } from "./run-recovery.js";
 export { BoundedSemaphore, RunCapacityError, retryAfterSeconds } from "./concurrency.js";
 import { BoundedSemaphore, RunCapacityError } from "./concurrency.js";
 import { DEFAULT_MODEL_OUTPUT_MAX_CHARS } from "@assemblyline-agents/core";
-export { FileConnectionAuthorizationSessionStore, FileConnectionGrantStore, InMemoryConnectionAuthorizationSessionStore, InMemoryConnectionGrantStore, RuntimeConnectionRegistry, connectionToolAccess } from "./connections.js";
-export { FileConnectionDefinitionStore, FileScheduleStore, FileSkillStore, InMemoryConnectionDefinitionStore, InMemoryScheduleStore, InMemorySkillStore, computeNextRun, resolveSkillsConfig, resolveSchedulesConfig, resolveConnectionsConfig } from "./self-improvement.js";
-export { LocalSandboxAdapter } from "./local-sandbox.js";
-export { FileMemoryStore, FileStateAdapter, InMemoryMemoryStore, InMemoryStateAdapter, LocalBlobAdapter, StateMemoryStore } from "./storage.js";
-export { gatewaySchedulerAdapter, localSchedulerAdapter, postgresSchedulerAdapter, schedulerAdapterForKind } from "./scheduler.js";
-export { createOpenTelemetrySink } from "./telemetry.js";
-export { createJsonConsoleLogger, noopLogger, normalizeLogLevel } from "./logging.js";
-export { capabilityCatalogForManifest, capabilityForModel, capabilityMatchesId, connectionSearchResultForModel, normalizeCapabilityKind, normalizeCapabilityRouterInput, normalizeDeferredToolSearchInput, routerShouldSearchConnections, scoreCapability, searchCapabilityCatalog, tokenizeCapabilityQuery } from "./capability-catalog.js";
-export { fetchJson, fetchWithPolicy, readBodyCapped, retryAfterMs, HttpResponseTooLargeError } from "./http.js";
-import { hydrateSandboxFilesystem, memoryPathFromSandboxRelativePath, scanSandboxFiles, visibleToolsForSkills } from "./sandbox-fs.js";
-export { buildDefaultContextBundle, hydrateSandboxFilesystem, syncSandboxFilesystem, visibleToolsForSkills } from "./sandbox-fs.js";
-export { queryAgentRuns } from "./runs-query.js";
-export { UsageAccountingError, createUsageRecord, matchesUsageQuery, microsToUsd, queryUsageRecords, reconcileUsageRecord, sha256Json, summarizeUsageRecords, usageTokensAreAuthoritative, usageRecordInput, usdToMicros } from "./usage-records.js";
-export { reconcileOpenAIOrganization, reconcileOpenRouterUsage, usageReconciliationReport } from "./usage-reconciliation.js";
-import { isValidSandboxSkillBody, resolveResourceProjectionPolicy, sandboxFileContentsToUtf8, sha256Text, skillNameFromSandboxRelativePath, skillNameFromSkillPath } from "./resource-projection-util.js";
+import { 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, stringValue, timestamp, } from "./runtime-util.js";
-export { currentModulePath, durableAgentScopeForManifest } from "./runtime-util.js";
-export { loadRuntimeBundle } from "./runtime-bundle.js";
-export class AssemblyLineRuntime {
+export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
     manifest;
     state;
     runEventBus = new RunEventBus();
+    eventHandlers;
+    agentHookControllers = new Map();
+    agentStateHandles = new Map();
     blob;
     sandbox;
     scheduler;
+    mediaProcessors;
     deliveryMode;
     toolStubs;
     /** Per-run {results:[...]} stub cursors; in-memory by design (see eval-run-options.ts). */
@@ -103,19 +121,21 @@ export class AssemblyLineRuntime {
     connections;
     env;
     fetch;
+    attachmentHostResolver;
     logger;
     connectionGrantStore;
     connectionAuthorizationSessionStore;
+    connectionEventStore;
     connectionCallbackBaseUrl;
     skillStore;
+    learningStore;
     memoryStore;
     scheduleStore;
     connectionDefinitionStore;
     skillsConfig;
     schedulesConfig;
     connectionsConfig;
-    skillsSeeded = false;
-    skillScopeMigrated = false;
+    runtimeLearning;
     connectionScopeMigrated = false;
     dynamicConnectionsCache;
     schedulerEnabled;
@@ -150,31 +170,39 @@ export class AssemblyLineRuntime {
     hostInstrumentationProvided;
     instrumentationConfig;
     sourceLoader;
+    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();
     /** Deadline-fired runs (read by shouldStopRun) + their in-flight abort controllers. */
     runDeadlines = new Set();
     runAbortControllers = new Map();
     maxRunDurationMs;
     constructor(options) {
+        super();
         this.manifest = options.manifest;
         const normalizedState = normalizeRuntimeState(options.state ?? new InMemoryStateAdapter());
         // Events fan out to live streams; terminal outcomes become log lines at
         // this one choke point (logger read lazily — assigned below).
-        this.state = withRunEventPublishing(normalizedState.state, this.runEventBus, (runId, event) => logTerminalRunEvent(this.logger, runId, event), (runId, event) => this.dispatchHookEvent(runId, event));
+        this.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 ?? {};
-        this.env = applyEnvAliases(options.env ?? process.env).env;
+        this.env = { ...(options.env ?? process.env) };
         this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+        this.attachmentHostResolver = options.attachmentHostResolver;
         this.logger = options.logger ??
-            createJsonConsoleLogger({ level: normalizeLogLevel(this.env.OPENEVE_LOG_LEVEL) ?? "info" });
+            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,
@@ -185,7 +213,7 @@ export class AssemblyLineRuntime {
         this.models = options.models;
         this.agentHarnessOverride = options.agentHarness;
         this.modelHarnesses = options.modelHarnesses ?? {};
-        this.checkpointEveryIteration = resolveBooleanEnv(this.env.OPENEVE_CHECKPOINT_EVERY_ITERATION, true);
+        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;
@@ -201,11 +229,13 @@ export class AssemblyLineRuntime {
         };
         this.connectionGrantStore = options.connectionGrantStore ?? new InMemoryConnectionGrantStore();
         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.OPENEVE_MEMORY_EMBEDDINGS_ENABLED, Boolean(options.memoryEmbeddingProvider));
+            resolveBooleanEnv(this.env.ASSEMBLY_LINE_MEMORY_EMBEDDINGS_ENABLED, Boolean(options.memoryEmbeddingProvider));
         const memoryEmbeddingStoreAvailable = this.state.supportsMemoryEmbeddings?.() ?? true;
         this.memoryEmbeddingsEnabled = memoryEmbeddingsRequested && memoryEmbeddingStoreAvailable;
         if (memoryEmbeddingsRequested && !memoryEmbeddingStoreAvailable) {
@@ -221,27 +251,48 @@ export class AssemblyLineRuntime {
         this.connectionsConfig = resolveConnectionsConfig(this.manifest.agent.dynamicConnections, this.env);
         this.schedulerEnabled = options.schedulerEnabled;
         this.schedulerTickMs = options.schedulerTickMs ?? 60_000;
-        this.scheduleMaxConsecutiveFailures = resolvePositiveIntegerEnv(this.env.OPENEVE_SCHEDULE_MAX_FAILURES, 5);
+        this.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.OPENEVE_SANDBOX_SYNC_INLINE, false);
-        this.sandboxSyncLeaseMs = options.sandboxSyncLeaseMs ?? resolvePositiveIntegerEnv(this.env.OPENEVE_SANDBOX_SYNC_LEASE_MS, 5 * 60_000);
-        this.sandboxSyncBatchSize = options.sandboxSyncBatchSize ?? resolvePositiveIntegerEnv(this.env.OPENEVE_SANDBOX_SYNC_BATCH_SIZE, 10);
-        this.sandboxSyncMaxAttempts = options.sandboxSyncMaxAttempts ?? resolvePositiveIntegerEnv(this.env.OPENEVE_SANDBOX_SYNC_MAX_ATTEMPTS, 5);
-        this.deliveryQueueLeaseMs = options.deliveryQueueLeaseMs ?? resolvePositiveIntegerEnv(this.env.OPENEVE_DELIVERY_QUEUE_LEASE_MS, 60_000);
-        this.toolOutputMaxChars = resolvePositiveIntegerEnv(this.env.OPENEVE_TOOL_OUTPUT_MAX_CHARS, DEFAULT_MODEL_OUTPUT_MAX_CHARS);
-        this.toolTimeoutMs = resolveNonNegativeIntegerEnv(this.env.OPENEVE_TOOL_TIMEOUT_MS, 600_000);
-        this.deliveryQueueBatchSize = options.deliveryQueueBatchSize ?? resolvePositiveIntegerEnv(this.env.OPENEVE_DELIVERY_QUEUE_BATCH_SIZE, 10);
-        this.deliveryQueueMaxAttempts = options.deliveryQueueMaxAttempts ?? resolvePositiveIntegerEnv(this.env.OPENEVE_DELIVERY_QUEUE_MAX_ATTEMPTS, 5);
-        this.deliveryQueueIntervalMs = options.deliveryQueueIntervalMs ?? resolvePositiveIntegerEnv(this.env.OPENEVE_DELIVERY_QUEUE_INTERVAL_MS, 15_000);
-        this.runHeartbeatMs = options.runHeartbeatMs ?? resolvePositiveIntegerEnv(this.env.OPENEVE_RUN_HEARTBEAT_MS, 30_000);
-        this.maxRunDurationMs = options.maxRunDurationMs ?? resolveNonNegativeIntegerEnv(this.env.OPENEVE_MAX_RUN_DURATION_MS, 3_600_000);
-        this.runRecoveryIntervalMs = options.runRecoveryIntervalMs ?? resolvePositiveIntegerEnv(this.env.OPENEVE_RUN_RECOVERY_INTERVAL_MS, 60_000);
-        this.maxModelIterations = resolvePositiveIntegerEnv(this.env.OPENEVE_MAX_MODEL_ITERATIONS, DEFAULT_MAX_MODEL_ITERATIONS);
-        this.outputValidationMaxRetries = resolveNonNegativeIntegerEnv(this.env.OPENEVE_OUTPUT_VALIDATION_MAX_RETRIES, DEFAULT_OUTPUT_VALIDATION_MAX_RETRIES);
+        this.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.maxRunDurationMs = options.maxRunDurationMs ?? resolveNonNegativeIntegerEnv(this.env.ASSEMBLY_LINE_MAX_RUN_DURATION_MS, 3_600_000);
+        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.OPENEVE_MAX_CONCURRENT_RUNS, Infinity),
-            maxQueued: options.maxQueuedRuns ?? resolvePositiveIntegerEnv(this.env.OPENEVE_MAX_QUEUED_RUNS, 0)
+            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,
@@ -258,13 +309,21 @@ export class AssemblyLineRuntime {
         this.sourceLoader = new AgentSourceModuleLoader({
             manifest: this.manifest,
             sourceBundle: this.sourceBundle,
-            ...(options.artifactRoot ? { cacheRoot: join(resolve(options.artifactRoot), ".assembly-line", "module-cache") } : {})
+            ...(options.artifactRoot ? { cacheRoot: join(resolve(options.artifactRoot), ARTIFACT_DIR_NAME, "module-cache") } : {})
+        });
+        this.skillBundleIndex = createSkillBundleIndex(this.manifest);
+        this.skillResourceReader = createSkillResourceReader({
+            manifest: this.manifest,
+            ...(options.resourcesRoot ? { resourcesRoot: options.resourcesRoot } : {}),
+            manifestRoot: this.manifest.root,
+            sourceBundle: this.sourceBundle
         });
     }
     boot() {
-        if (this.manifest.schemaVersion !== OPENEVE_MANIFEST_SCHEMA_VERSION) {
-            throw new Error(`Unsupported OpenEve manifest schema ${this.manifest.schemaVersion}.`);
+        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 missing = this.manifest.preflight.filter((requirement) => requirement.kind === "env" &&
                 requirement.required &&
@@ -348,46 +407,41 @@ export class AssemblyLineRuntime {
             this.logger.warn("provider ingress security warning", { warning });
         }
     }
-    skillScope() {
-        return this.durableAgentScope();
-    }
-    connectionScope() {
-        return this.durableAgentScope();
-    }
-    durableAgentScope() {
-        return durableAgentScopeForManifest(this.manifest);
-    }
-    usesRevisionScopedDurableState() {
-        return this.durableAgentScope() === this.manifest.agentRevision;
-    }
+    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 userId = typeof run.input.userId === "string" ? run.input.userId : undefined;
-        const conversationId = typeof run.input.conversationId === "string" ? run.input.conversationId : undefined;
-        return userId ?? conversationId ?? this.manifest.agentRevision;
+        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() {
-        if (this.skillsSeeded)
-            return;
-        await this.migrateLegacySkillScope();
-        await seedSkills(this.skillStore, this.skillScope(), this.manifest.skills);
-        this.skillsSeeded = true;
-    }
-    async migrateLegacySkillScope() {
-        if (this.skillScopeMigrated)
-            return;
-        this.skillScopeMigrated = true;
-        const scope = this.skillScope();
-        const legacyScope = this.manifest.agentRevision;
-        if (scope === legacyScope)
-            return;
-        const current = await this.skillStore.list(scope);
-        if (current.length > 0)
-            return;
-        for (const skill of await this.skillStore.list(legacyScope)) {
-            await this.skillStore.put(scope, skill);
-        }
-    }
+    async ensureSkillsSeeded(surfacePath = "root") { return this.runtimeLearning.ensureSkillsSeeded(surfacePath); }
     async migrateLegacyConnectionScope() {
         if (this.connectionScopeMigrated)
             return;
@@ -404,30 +458,24 @@ export class AssemblyLineRuntime {
         }
     }
     /** Live skill catalog (durable store, post-seed) for context assembly and inspection. */
-    async listSkills() {
-        await this.ensureSkillsSeeded();
-        return liveSkills(this.skillStore, this.skillScope());
-    }
+    async listSkills(surfacePath = "root") { return this.runtimeLearning.listSkills(surfacePath); }
     /** Persist an agent/user authored skill, honoring the write-approval gate. */
-    async saveSkill(input) {
-        if (!this.skillsConfig.writable) {
-            throw new Error("Skill writing is disabled (selfImprovement.writable is false).");
-        }
-        await this.ensureSkillsSeeded();
-        const writeInput = { name: input.name, body: input.body };
-        if (input.origin)
-            writeInput.origin = input.origin;
-        const record = await writeSkill(this.skillStore, this.skillScope(), writeInput, {
-            requireApproval: this.skillsConfig.writeApproval
-        });
-        return { name: record.name, pending: record.pending ?? false };
-    }
-    async deleteSkill(name) {
-        if (!this.skillsConfig.writable) {
-            throw new Error("Skill writing is disabled (selfImprovement.writable is false).");
-        }
-        await this.ensureSkillsSeeded();
-        await this.skillStore.delete(this.skillScope(), name);
+    async 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);
     }
     async createDynamicSchedule(input) {
         if (!this.schedulesConfig.dynamic) {
@@ -538,301 +586,53 @@ export class AssemblyLineRuntime {
         this.dynamicConnectionsCache = undefined;
     }
     async syncMemoryFromSandbox(run, sandboxSession, tombstones) {
-        const scope = this.memoryScopeForRun(run);
-        const deleted = [];
-        const tombstonedPaths = new Set(tombstones
-            .map((tombstone) => tombstone.path)
-            .filter((path) => path.startsWith("/memory/")));
-        for (const path of tombstonedPaths) {
-            await this.state.deleteMemoryDocument(scope, path);
-            deleted.push(path);
-        }
-        let files;
-        try {
-            files = await scanSandboxFiles(sandboxSession, "/memory");
-        }
-        catch {
-            return { written: [], deleted };
-        }
-        const written = [];
-        for (const file of files) {
-            const path = memoryPathFromSandboxRelativePath(file.relativePath);
-            if (!path || tombstonedPaths.has(path))
-                continue;
-            const content = sandboxFileContentsToUtf8(file.contents);
-            const current = await this.memoryStore.read(scope, { path });
-            if (current && memoryBodyText(current) === content)
-                continue;
-            await this.memoryStore.write(scope, {
-                path,
-                content,
-                mode: "replace",
-                metadata: {
-                    tags: ["sandbox"],
-                    sourceRefs: [`sandbox:${run.id}`]
-                }
-            });
-            written.push(path);
-        }
-        if (written.length > 0 || deleted.length > 0) {
-            await this.state.appendEvent(run.id, "memory.documents_synced", {
-                written,
-                deleted
-            });
-        }
-        return { written, deleted };
+        return syncMemoryFromSandbox(this.sandboxStateSyncHost(), run, sandboxSession, tombstones);
     }
     /** Reconcile skill files the agent explicitly edited/deleted under `/skills`. */
     async syncSkillsFromSandbox(run, sandboxSession, tombstones) {
-        let files;
-        try {
-            files = await scanSandboxFiles(sandboxSession, "/skills");
-        }
-        catch {
-            files = [];
-        }
-        const skillScope = this.skillScope();
-        const before = await this.skillStore.list(skillScope);
-        const beforeByName = new Map(before.map((skill) => [skill.name, skill]));
-        const deletedSkillNames = new Set(tombstones
-            .map((tombstone) => skillNameFromSkillPath(tombstone.path))
-            .filter((name) => Boolean(name)));
-        const sandboxSkills = [];
-        const invalid = [];
-        for (const file of files) {
-            const name = skillNameFromSandboxRelativePath(file.relativePath);
-            if (!name) {
-                if (file.relativePath.endsWith("SKILL.md"))
-                    invalid.push(file.relativePath);
-                continue;
-            }
-            const body = sandboxFileContentsToUtf8(file.contents);
-            if (!isValidSandboxSkillBody(body)) {
-                invalid.push(`/skills/${file.relativePath}`);
-                continue;
-            }
-            sandboxSkills.push({ name, body });
-        }
-        const changed = sandboxSkills.filter((skill) => {
-            if (deletedSkillNames.has(skill.name))
-                return false;
-            return beforeByName.get(skill.name)?.bodySha256 !== sha256Text(skill.body);
-        });
-        if (!this.skillsConfig.writable) {
-            if (changed.length > 0 || deletedSkillNames.size > 0 || invalid.length > 0) {
-                throw new Error("Sandbox skill writes are blocked because self-improvement is disabled.");
-            }
-            return;
-        }
-        if (invalid.length > 0) {
-            throw new Error(`Invalid sandbox skill file(s): ${invalid.join(", ")}`);
-        }
-        const created = [];
-        const updated = [];
-        const deleted = [];
-        for (const name of deletedSkillNames) {
-            if (!beforeByName.has(name))
-                continue;
-            await this.skillStore.delete(skillScope, name);
-            deleted.push(name);
-        }
-        for (const skill of changed) {
-            const existing = beforeByName.get(skill.name);
-            await writeSkill(this.skillStore, skillScope, {
-                name: skill.name,
-                body: skill.body,
-                origin: "agent"
-            }, {
-                requireApproval: this.skillsConfig.writeApproval
-            });
-            if (existing)
-                updated.push(skill.name);
-            else
-                created.push(skill.name);
-        }
-        if (created.length || updated.length || deleted.length) {
-            await this.state.appendEvent(run.id, "skill.synced", {
-                created,
-                updated,
-                deleted,
-                pending: this.skillsConfig.writeApproval
-            });
-        }
+        return syncSkillsFromSandbox(this.sandboxStateSyncHost(), run, sandboxSession, tombstones);
     }
-    createSandboxHandle(getRun, setRun, getBundle) {
-        const runtime = this;
-        let sandboxSession;
-        let acquiring;
-        const acquire = async () => {
-            const run = getRun();
-            sandboxSession = await runtime.acquireSandboxForRun(run);
-            const updatedRun = await runtime.state.updateRun(run.id, { sandboxId: sandboxSession.id });
-            setRun(updatedRun);
-            await runtime.state.appendEvent(run.id, "sandbox.acquired", { sandboxId: sandboxSession.id, root: sandboxSession.root });
-            await runtime.createCheckpoint({ runId: run.id, name: "sandbox.acquired", data: { sandboxId: sandboxSession.id } });
-            await hydrateSandboxFilesystem(sandboxSession, getBundle(), {
-                fullHydration: runtime.legacyFullSandboxHydration(),
-                blob: runtime.blob
-            });
-            await runtime.state.appendEvent(run.id, "filesystem.hydrated", {
-                memory: "/memory",
-                history: "/history",
-                files: "/files",
-                workspace: "/workspace",
-                mode: runtime.legacyFullSandboxHydration() ? "full" : "minimal"
-            });
-            await runtime.createCheckpoint({
-                runId: run.id,
-                name: "filesystem.hydrated",
-                data: {
-                    memory: "/memory",
-                    history: "/history",
-                    files: "/files",
-                    workspace: "/workspace",
-                    mode: runtime.legacyFullSandboxHydration() ? "full" : "minimal"
-                }
-            });
-            await materializeConnectionCredentialsIntoSandbox(run, runtime.createConnectionRegistryForRun(run, "local"), sandboxSession, (eventType, payload) => runtime.state.appendEvent(run.id, eventType, payload));
-            return sandboxSession;
-        };
+    sandboxStateSyncHost() {
         return {
-            current() {
-                return sandboxSession;
-            },
-            async get() {
-                if (sandboxSession)
-                    return sandboxSession;
-                // Memoize the in-flight acquisition: parallel tool calls must share
-                // one sandbox session instead of racing to create two.
-                acquiring ??= acquire().catch((error) => {
-                    acquiring = undefined;
-                    throw error;
-                });
-                return acquiring;
-            },
-            async getWrapped() {
-                const run = getRun();
-                return runtime.wrapSandbox(run.id, await this.get());
-            },
-            async dispose() {
-                if (!sandboxSession)
-                    return;
-                await runtime.disposeSandboxSession(getRun().id, sandboxSession);
-            }
+            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) {
-        const sessionKey = this.sandboxSessionKey(run);
-        const provider = this.sandbox.provider ?? "sandbox";
-        const existing = await this.state.getSandboxSession(sessionKey);
-        const reconnectManifest = existing?.manifest ?? {};
-        const reconnectCompatible = hasCurrentSandboxFilesystemContract(reconnectManifest);
-        const reconnectInput = {
-            runId: run.id,
-            sandboxId: existing?.sandboxId ?? "",
-            sessionKey,
-            manifest: reconnectManifest
-        };
-        const root = stringValue(reconnectManifest.sandboxRoot);
-        if (root)
-            reconnectInput.root = root;
-        if (existing?.sandboxId && reconnectCompatible) {
-            const connected = await this.sandbox.connect?.(reconnectInput)
-                .catch(this.debugSwallow("sandbox connect probe failed", { runId: run.id, sessionKey }));
-            if (connected) {
-                await this.upsertSandboxSessionForRun(run, sessionKey, provider, connected, existing.dirty, existing.syncJobId, {
-                    ...existing.manifest,
-                    sandboxRoot: connected.root,
-                    ...sandboxFilesystemContractMetadata(connected.provider === "local" ? "emulated" : "physical")
-                }, "live");
-                await this.state.appendEvent(run.id, "sandbox.reused", { sandboxId: connected.id, sessionKey, mode: "connect" });
-                return connected;
-            }
-            const woken = await this.sandbox.wake?.(reconnectInput)
-                .catch(this.debugSwallow("sandbox wake probe failed", { runId: run.id, sessionKey }));
-            if (woken) {
-                await this.upsertSandboxSessionForRun(run, sessionKey, provider, woken, existing.dirty, existing.syncJobId, {
-                    ...existing.manifest,
-                    sandboxRoot: woken.root,
-                    ...sandboxFilesystemContractMetadata(woken.provider === "local" ? "emulated" : "physical")
-                }, "live");
-                await this.state.appendEvent(run.id, "sandbox.reused", { sandboxId: woken.id, sessionKey, mode: "wake" });
-                return woken;
-            }
-        }
-        const lookup = (!existing || reconnectCompatible) ? await this.sandbox.lookup?.({
-            sessionKey,
-            runId: run.id,
-            agentRevision: run.agentRevision,
-            manifest: {
-                ...reconnectManifest,
-                ...sandboxFilesystemContractMetadata(this.sandbox.provider === "local" ? "emulated" : "physical")
-            }
-        }).catch(this.debugSwallow("sandbox lookup probe failed", { runId: run.id, sessionKey })) : undefined;
-        if (lookup) {
-            const lookupInput = {
-                runId: run.id,
-                sandboxId: lookup.sandboxId,
-                sessionKey,
-                manifest: lookup.manifest ?? reconnectManifest
-            };
-            if (lookup.root)
-                lookupInput.root = lookup.root;
-            const connected = await this.sandbox.connect?.(lookupInput)
-                .catch(this.debugSwallow("sandbox connect probe failed", { runId: run.id, sessionKey })) ??
-                await this.sandbox.wake?.(lookupInput)
-                    .catch(this.debugSwallow("sandbox wake probe failed", { runId: run.id, sessionKey }));
-            if (connected) {
-                await this.upsertSandboxSessionForRun(run, sessionKey, provider, connected, existing?.dirty ?? false, existing?.syncJobId, {
-                    ...(lookup.manifest ?? existing?.manifest ?? {}),
-                    sandboxRoot: connected.root,
-                    ...sandboxFilesystemContractMetadata(connected.provider === "local" ? "emulated" : "physical")
-                }, "live");
-                await this.state.appendEvent(run.id, "sandbox.reused", { sandboxId: connected.id, sessionKey, mode: lookup.state ?? "lookup" });
-                return connected;
-            }
-        }
-        const createInput = {
-            sessionKey,
-            metadata: {
-                sessionKey,
-                runId: run.id,
-                agentRevision: run.agentRevision,
-                ...sandboxFilesystemContractMetadata(this.sandbox.provider === "local" ? "emulated" : "physical")
-            }
-        };
-        if (existing?.snapshotId && reconnectCompatible)
-            createInput.snapshotId = existing.snapshotId;
-        const created = this.sandbox.create
-            ? await this.sandbox.create(run, createInput)
-            : await this.sandbox.acquire(run);
-        await this.upsertSandboxSessionForRun(run, sessionKey, provider, created, existing?.dirty ?? false, existing?.syncJobId, {
-            ...(existing?.manifest ?? {}),
-            sandboxRoot: created.root,
-            ...sandboxFilesystemContractMetadata(created.provider === "local" ? "emulated" : "physical")
-        }, existing?.dirty ? "dirty" : "live");
-        await this.state.appendEvent(run.id, "sandbox.created", { sandboxId: created.id, sessionKey });
-        return created;
-    }
-    async upsertSandboxSessionForRun(run, sessionKey, provider, session, dirty, syncJobId, manifest, state) {
-        return this.state.upsertSandboxSession({
-            sessionKey,
-            provider: session.provider ?? provider,
-            sandboxId: session.id,
-            runId: run.id,
-            state: dirty ? "dirty" : state,
-            dirty,
-            lastSeenAt: timestamp(),
-            ...(syncJobId ? { syncJobId } : {}),
-            manifest
-        });
+        return acquireSandboxSessionForRun({
+            manifest: this.manifest,
+            state: this.state,
+            sandbox: this.sandbox,
+            sessionKey: (candidate) => this.sandboxSessionKey(candidate),
+            swallow: (message, fields) => this.debugSwallow(message, fields)
+        }, run);
     }
     legacyFullSandboxHydration() {
-        return this.env.OPENEVE_LEGACY_FULL_SANDBOX_HYDRATION === "1" ||
-            this.env.OPENEVE_LEGACY_FULL_SANDBOX_HYDRATION === "true";
+        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) {
@@ -924,22 +724,59 @@ export class AssemblyLineRuntime {
         await this.ensureSkillsSeeded();
         await this.ensureDynamicConnections();
         const spanStartedAt = timestamp();
-        const channel = options.turn?.channel ?? options.channel ?? "local";
+        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 targetModel = options.target?.type === "agent" ? options.target.model : undefined;
-        const model = options.model ?? options.turn?.model ?? targetModel;
+        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,
-            model: model ?? this.manifest.agent.model,
+            agentSurface: "root",
             channel,
             eventId: options.turn?.eventId ?? options.eventId ?? null,
-            conversationId: options.turn?.conversationId ?? options.conversationId ?? null,
-            userId: options.turn?.userId ?? options.userId ?? 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,
-            delivery: options.turn?.delivery ?? options.delivery ?? 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: {
@@ -958,14 +795,20 @@ export class AssemblyLineRuntime {
         catch (error) {
             this.logger.warn("onRunCreated hook failed", { runId: run.id, error: error instanceof Error ? error.message : String(error) });
         }
-        await this.state.appendEvent(run.id, "run.accepted", { agentRevision: this.manifest.agentRevision, model: model ?? this.manifest.agent.model });
-        if (this.usesRevisionScopedDurableState() && (this.skillsConfig.writable || this.connectionsConfig.dynamic)) {
+        await this.state.appendEvent(run.id, "run.accepted", { agentRevision: this.manifest.agentRevision });
+        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
@@ -983,43 +826,101 @@ export class AssemblyLineRuntime {
             await this.stopChannelTurn(channelLifecycle, run, channel);
         };
         try {
-            const resolveAttachment = await this.channelAttachmentResolver(channelDefinition, trustedProvider);
-            const attachments = await materializeTurnAttachments({
-                run,
+            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,
-                attachments: options.attachments ?? options.turn?.attachments ?? [],
-                ...(trustedProvider ? { trustedProvider } : {}),
-                ...(resolveAttachment ? { resolveAttachment } : {}),
-                env: this.env,
-                fetch: this.fetch,
-                blob: this.blob,
-                state: this.state
+                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) : []);
+                (conversation ? await this.recentHistory(conversation.id, run.id) : []);
             const contextInput = {
                 message: hydratedOptions.message,
                 channel,
                 recentHistory,
                 attachments,
+                capabilities,
                 run
             };
-            if (augmentation?.channelContext)
-                contextInput.channelContext = augmentation.channelContext;
+            const channelContext = mergeJsonObjects(media.channelContext, augmentation?.channelContext);
+            if (channelContext)
+                contextInput.channelContext = channelContext;
             if (hydratedOptions.promptContext)
                 contextInput.promptContext = hydratedOptions.promptContext;
             if (hydratedOptions.target)
                 contextInput.target = hydratedOptions.target;
-            const bundle = await this.buildContextBundle(contextInput);
+            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 });
@@ -1028,44 +929,31 @@ export class AssemblyLineRuntime {
                 name: "context.bundle_built",
                 data: { contextBundleId: contextBlob.id }
             });
-            const missingConnections = this.missingRequiredConnections();
-            if (missingConnections.length > 0) {
-                const waitingRun = await this.state.updateRun(run.id, { status: "waiting_for_connection" });
-                await this.state.appendEvent(run.id, "connection.required", {
-                    missingConnections,
-                    recoverable: true
-                });
-                await this.emitSpan("ai.assembly-line.turn", spanStartedAt, this.runSpanAttributes(waitingRun, {
-                    status: "waiting_for_connection"
-                }), {
-                    spanId: this.turnSpanId(waitingRun.id),
-                    status: "ok"
-                });
-                await this.emitSpan("assembly-line.run", spanStartedAt, {
-                    runId: run.id,
-                    status: "waiting_for_connection",
-                    agentRevision: this.manifest.agentRevision
-                });
-                return this.result(waitingRun, `Connection required: ${missingConnections.join(", ")}`, false, false, true);
-            }
-            const resolution = await this.resolveRunCapabilities(run, hydratedOptions, conversation?.id);
             const sandboxHandle = this.createSandboxHandle(() => run, (nextRun) => {
                 run = nextRun;
             }, () => bundle);
             await this.state.appendEvent(run.id, "harness.started", { harness: this.manifest.gateway.runtime?.kind ?? "node" });
-            const baseInstructions = await this.instructionsForRunTarget(run, hydratedOptions.target, bundle.instructions);
-            const targetInstructions = resolution?.instructions
-                ? `${baseInstructions}\n\n${resolution.instructions}`
-                : baseInstructions;
+            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: model ?? this.manifest.agent.model, forcedTool: tool.name });
-                await this.state.appendEvent(run.id, "model.response_completed", { model: model ?? this.manifest.agent.model, simulated: true });
+                await this.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: model ?? this.manifest.agent.model,
+                    model: capabilities.model,
                     stepIndex: 0,
                     forcedTool: tool.name,
                     simulated: true,
@@ -1096,21 +984,23 @@ export class AssemblyLineRuntime {
                     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;
-                    loopInput.transcript = await this.loadConversationTranscript(conversation.id, run.id);
+                    if (!options.contextSnapshot)
+                        loopInput.transcript = await this.loadConversationTranscript(conversation.id, run.id);
                 }
-                // A host-forced model wins over the resolver; the resolver wins over the manifest default.
-                if (model)
-                    loopInput.model = model;
-                else if (resolution?.model)
-                    loopInput.model = resolution.model;
-                if (resolution?.defaultTools)
-                    loopInput.defaultToolNames = resolution.defaultTools;
                 const outcome = await this.runHarnessLoop(loopInput);
                 run = outcome.run;
                 if (outcome.waitingForApproval || outcome.waitingForInput || outcome.waitingForConnection) {
@@ -1156,10 +1046,12 @@ export class AssemblyLineRuntime {
             return result;
         }
         catch (error) {
-            // Fatal model errors terminalize with a durable reason; anything else is
-            // evented + logged but left "running" so the recovery sweep can resume
-            // from the latest continuation (the crash-durability contract).
-            await handleRunExecutionError({ state: this.state, logger: this.logger }, run.id, error);
+            await handleRunExecutionError({
+                state: this.state,
+                logger: this.logger,
+                deliveryQueueMaxAttempts: this.deliveryQueueMaxAttempts,
+                now: () => this.now()
+            }, run.id, error);
             throw error;
         }
         finally {
@@ -1173,7 +1065,7 @@ export class AssemblyLineRuntime {
     }
     /** Bump `updatedAt` while a run executes; enforces the wall-clock deadline (run-heartbeat.ts). */
     startRunHeartbeat(runId) {
-        return startRunHeartbeatImpl({
+        return trackActiveRunHeartbeat(this.activeRunExecutions, runId, startRunHeartbeatImpl({
             state: this.state,
             logger: this.logger,
             runHeartbeatMs: this.runHeartbeatMs,
@@ -1185,10 +1077,10 @@ export class AssemblyLineRuntime {
                     controller.abort();
             },
             debugSwallow: (message, fields) => this.debugSwallow(message, fields)
-        }, runId);
+        }, runId));
     }
     registerRunAbort(runId, controller) {
-        return registerRunAbortController(this.runAbortControllers, this.runDeadlines, runId, controller);
+        return registerRunAbortController(this.runAbortControllers, this.runDeadlines, runId, controller, this.runControlIntents);
     }
     conversationContextHost() {
         const runtime = this;
@@ -1199,6 +1091,7 @@ export class AssemblyLineRuntime {
             coreToolPolicy: this.coreToolPolicy,
             memoryStore: this.memoryStore,
             skillStore: this.skillStore,
+            skillBundleIndex: this.skillBundleIndex,
             sourceLoader: this.sourceLoader,
             get contextPolicyPromise() {
                 return runtime.contextPolicyPromise;
@@ -1211,15 +1104,16 @@ export class AssemblyLineRuntime {
             warnSwallow: (message, fields) => this.warnSwallow(message, fields),
             memoryScopeForRun: (run) => this.memoryScopeForRun(run),
             durableAgentScope: () => this.durableAgentScope(),
-            ensureSkillsSeeded: () => this.ensureSkillsSeeded(),
-            skillScope: () => this.skillScope()
+            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) {
-        return recentHistoryImpl(this.conversationContextHost(), conversationId);
+    async recentHistory(conversationId, excludeRunId) {
+        return recentHistoryImpl(this.conversationContextHost(), conversationId, excludeRunId);
     }
     async augmentChannelContext(channelName, turn, run) {
         return augmentChannelContextImpl(this.conversationContextHost(), channelName, turn, run);
@@ -1258,28 +1152,34 @@ export class AssemblyLineRuntime {
                 return runtime.instrumentationConfig;
             },
             createConnectionRegistry: (channel, turn) => this.createConnectionRegistry(channel, turn),
-            createConnectionRegistryForRun: (run, fallbackChannel, sandboxHandle) => this.createConnectionRegistryForRun(run, fallbackChannel, sandboxHandle),
+            createConnectionRegistryForRun: (run, fallbackChannel, sandboxHandle, selectedConnections) => this.createConnectionRegistryForRun(run, fallbackChannel, sandboxHandle, selectedConnections),
+            missingRequiredConnections: (selected) => this.missingRequiredConnections(selected),
             visibleToolSet: (defaultToolNames, activeSkills) => this.visibleToolSet(defaultToolNames, activeSkills),
-            modelTools: (activeToolNames, connectionRegistry, discoveredConnectionTools) => this.modelTools(activeToolNames, connectionRegistry, discoveredConnectionTools),
+            modelTools: (run, activeToolNames, connectionRegistry, discoveredConnectionTools, options) => this.modelTools(run, activeToolNames, 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) {
-        return resolveAgentHarnessImpl(this.harnessLoopHost(), modelSpec);
-    }
-    piHarness() {
-        return piHarnessImpl(this.harnessLoopHost());
+        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) }, 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);
@@ -1328,29 +1228,37 @@ export class AssemblyLineRuntime {
             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) => this.createConnectionRegistryForRun(run, fallbackChannel, sandboxHandle),
+            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) => executeHarnessTurnImpl(this.harnessLoopHost(), harness, input, 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)
+            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));
@@ -1361,9 +1269,22 @@ export class AssemblyLineRuntime {
         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;
     }
     /**
@@ -1379,6 +1300,65 @@ export class AssemblyLineRuntime {
     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(),
+                env: this.env,
+                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));
@@ -1431,12 +1411,7 @@ export class AssemblyLineRuntime {
             state: this.state,
             boot: () => this.boot(),
             durableAgentScope: () => this.durableAgentScope(),
-            cacheRunControl: (runId, intent) => {
-                if (intent)
-                    this.runControlIntents.set(runId, intent);
-                else
-                    this.runControlIntents.delete(runId);
-            }
+            cacheRunControl: (runId, intent) => cacheRunControlSignal(this.runControlIntents, this.activeRunExecutions, this.runAbortControllers, runId, intent)
         };
     }
     async resumeHarnessLoop(run, harness, restored, resume) {
@@ -1451,6 +1426,7 @@ export class AssemblyLineRuntime {
             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),
@@ -1471,7 +1447,15 @@ export class AssemblyLineRuntime {
         return sendSubagentFollowupImpl(this.subagentExecutionHost(), childRunId, message);
     }
     async loadSkill(runId, skillName) {
-        const loaded = await this.skillLoadDetails(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,
@@ -1556,7 +1540,7 @@ export class AssemblyLineRuntime {
     shouldStartScheduler() {
         if (this.schedulerEnabled === false)
             return false;
-        if (this.env.OPENEVE_SCHEDULER_ENABLED === "false" || this.env.OPENEVE_SCHEDULER_ENABLED === "0")
+        if (this.env.ASSEMBLY_LINE_SCHEDULER_ENABLED === "false" || this.env.ASSEMBLY_LINE_SCHEDULER_ENABLED === "0")
             return false;
         return true;
     }
@@ -1580,6 +1564,8 @@ export class AssemblyLineRuntime {
             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)
         };
@@ -1594,7 +1580,7 @@ export class AssemblyLineRuntime {
     async resumeRunFromContinuation(run, context) {
         return resumeRunFromContinuationImpl(this.replayResumeHost(), run, context);
     }
-    /** Start delivery, sandbox-sync, conversation-turn, and orphan-recovery workers. */
+    /** Start delivery, sandbox-sync, conversation-turn, background-review, and orphan-recovery workers. */
     startBackgroundWorkers(options = {}) {
         return startBackgroundWorkersImpl({
             env: this.env,
@@ -1603,6 +1589,8 @@ export class AssemblyLineRuntime {
             startDeliveryWorker: (workerOptions) => this.startDeliveryWorker(workerOptions),
             startSandboxSyncWorker: (workerOptions) => this.startSandboxSyncWorker(workerOptions),
             startConversationTurnWorker: (workerOptions) => this.conversationTurnDispatcher.startWorker(workerOptions?.intervalMs),
+            startBackgroundReviewWorker: (workerOptions) => this.startBackgroundReviewWorker(workerOptions),
+            startConnectionEventWorker: (workerOptions) => this.startConnectionEventWorker(workerOptions),
             recoverIncompleteRuns: (recoveryOptions) => this.recoverIncompleteRuns(recoveryOptions),
             agentEnabled: () => this.agentEnabled()
         }, options);
@@ -1647,6 +1635,10 @@ export class AssemblyLineRuntime {
             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),
@@ -1664,9 +1656,6 @@ export class AssemblyLineRuntime {
     async latestRunFailureMessage(runId) {
         return latestRunFailureMessageImpl(this.deliverySendHost(), runId);
     }
-    async enqueueSandboxSyncAfterDelivery(run, sandboxSession) {
-        return enqueueSandboxSyncAfterDeliveryImpl(this.deliverySendHost(), run, sandboxSession);
-    }
     sandboxSyncWorkerHost() {
         return {
             state: this.state,
@@ -1681,6 +1670,7 @@ export class AssemblyLineRuntime {
             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),
@@ -1729,14 +1719,14 @@ export class AssemblyLineRuntime {
     visibleToolSet(defaultToolNames, activeSkills) {
         return visibleToolSetImpl(this.toolExecutionHost(), defaultToolNames, activeSkills);
     }
-    async skillLoadDetails(skillName) {
-        return skillLoadDetailsImpl(this.toolExecutionHost(), skillName);
+    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(skillName) }, 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(activeToolNames, connectionRegistry, discoveredConnectionTools = new Map()) {
-        return modelToolsImpl(this.toolExecutionHost(), activeToolNames, connectionRegistry, discoveredConnectionTools);
+    async modelTools(run, activeToolNames, connectionRegistry, discoveredConnectionTools = new Map(), options) {
+        return modelToolsImpl(this.toolExecutionHost(), run, activeToolNames, connectionRegistry, discoveredConnectionTools, options);
     }
     async harnessExecuteTool(call, state) {
         return harnessExecuteToolImpl(this.toolExecutionHost(), call, state);
@@ -1744,8 +1734,8 @@ export class AssemblyLineRuntime {
     createConnectionRegistry(channel, turn) {
         return createConnectionRegistryImpl(this.toolExecutionHost(), channel, turn);
     }
-    createConnectionRegistryForRun(run, fallbackChannel, sandboxHandle) {
-        return createConnectionRegistryForRunImpl(this.toolExecutionHost(), run, fallbackChannel, sandboxHandle);
+    createConnectionRegistryForRun(run, fallbackChannel, sandboxHandle, selectedConnections) {
+        return createConnectionRegistryForRunImpl(this.toolExecutionHost(), run, fallbackChannel, sandboxHandle, selectedConnections);
     }
     createConnectionRegistryForSession(session) {
         return createConnectionRegistryForSessionImpl(this.toolExecutionHost(), session);
@@ -1779,12 +1769,18 @@ export class AssemblyLineRuntime {
             env: this.env,
             fetch: this.fetch,
             state: this.state,
-            blob: this.blob
+            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() {
+    missingRequiredConnections(selected) {
+        const selectedNames = new Set(selected);
         return this.manifest.connections
-            .filter((connection) => connection.required && connection.protocol === "declaration")
+            .filter((connection) => selectedNames.has(connection.name) && connection.required && connection.protocol === "declaration")
             .map((connection) => connection.name)
             .filter((name) => this.connections[name] === undefined);
     }
@@ -1796,11 +1792,11 @@ export class AssemblyLineRuntime {
             this.instrumentationLoaded = true;
             return;
         }
-        const instrumentation = await this.loadInstrumentationModule();
+        const instrumentation = this.manifest.instrumentation
+            ? await this.sourceLoader.load(this.manifest.instrumentation)
+            : {};
         const defaultExport = instrumentation.default;
         const definition = isInstrumentationDefinition(defaultExport) ? defaultExport : undefined;
-        // Host/gateway-supplied instrumentation wins over instrumentation.ts, mirroring
-        // the telemetry-sink precedence below.
         if (definition && !this.hostInstrumentationProvided) {
             this.instrumentationConfig = {
                 recordInputs: definition.recordInputs ?? false,
@@ -1826,7 +1822,7 @@ export class AssemblyLineRuntime {
         this.instrumentationLoaded = true;
     }
     agentName() {
-        return this.manifest.agent.name ?? this.manifest.agent.description ?? `openeve-${this.manifest.agentRevision.slice(0, 12)}`;
+        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);
@@ -1853,11 +1849,13 @@ export class AssemblyLineRuntime {
     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,
@@ -1867,11 +1865,13 @@ export class AssemblyLineRuntime {
             toolOutputMaxChars: this.toolOutputMaxChars,
             toolTimeoutMs: this.toolTimeoutMs,
             sandboxSyncMaxAttempts: this.sandboxSyncMaxAttempts,
-            skillsConfig: this.skillsConfig,
+            skillsConfigForRun: (run) => this.skillsConfigForRun(run),
             schedulesConfig: this.schedulesConfig,
             connectionsConfig: this.connectionsConfig,
-            ensureSkillsSeeded: () => this.ensureSkillsSeeded(),
-            skillScope: () => this.skillScope(),
+            surfaceForRun: (run) => surfaceForRun(this.manifest, run),
+            agentStateForRun: (runId) => this.agentStateForRun(runId),
+            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),
@@ -1884,13 +1884,14 @@ export class AssemblyLineRuntime {
             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) => this.saveSkill(input),
-            listSkills: () => this.listSkills(),
-            deleteSkill: (name) => this.deleteSkill(name),
+            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),
@@ -1930,11 +1931,14 @@ export class AssemblyLineRuntime {
             blob: this.blob,
             memoryStore: this.memoryStore,
             skillStore: this.skillStore,
+            skillBundleIndex: this.skillBundleIndex,
+            skillResourceReader: this.skillResourceReader,
             resourceProjectionPolicy: this.resourceProjectionPolicy,
             memoryEmbeddingProvider: this.memoryEmbeddingProvider,
             memoryEmbeddingsEnabled: this.memoryEmbeddingsEnabled,
-            skillScope: () => this.skillScope(),
-            durableAgentScope: () => this.durableAgentScope()
+            skillScopeForRun: (run) => this.skillScopeForRun(run),
+            durableAgentScope: () => this.durableAgentScope(),
+            surfaceForRun: (run) => surfaceForRun(this.manifest, run)
         };
     }
     async listResourcesForRun(run, scope, input = {}) {
@@ -1949,6 +1953,9 @@ export class AssemblyLineRuntime {
     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);
     }
@@ -1967,33 +1974,117 @@ export class AssemblyLineRuntime {
     async runMemoryEmbeddingBackfill(options = {}) {
         return runMemoryEmbeddingBackfillImpl(this.resourceProjectionHost(), options);
     }
-    hookDispatcher;
-    dispatchHookEvent(runId, event) {
-        if (!this.manifest.hooks?.length)
-            return;
-        this.hookDispatcher ??= createHookDispatcher({
-            agentName: this.agentName(),
-            hooks: this.manifest.hooks,
-            loadModule: (source) => this.sourceLoader.load(source),
-            logger: this.logger
+    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) {
+        await this.dispatchHookEvent(runId, event);
+        await this.runtimeLearning.handleRuntimeEvent(runId, event.type);
+    }
+    async createAgentHookController(run, options, channel, conversationId, attachments) {
+        const disabledTools = this.disabledToolsForRun(run);
+        const surface = rootAgentSurface(this.manifest);
+        const liveSkills = (await this.listSkills(surface.path)).map((skill) => skill.name).sort();
+        const baseCatalog = hookCapabilityCatalog(this.manifest, surface);
+        const created = await createRuntimeAgentHookController({
+            manifest: this.manifest,
+            state: this.state,
+            blob: this.blob,
+            sourceLoader: this.sourceLoader,
+            eventHandlers: this.eventHandlers,
+            logger: this.logger,
+            agentScope: this.durableAgentScope(),
+            conversationId,
+            run: immutableAgentRunContext({
+                id: run.id,
+                message: options.message,
+                channel,
+                conversationId,
+                ...(typeof run.input.userId === "string" ? { userId: run.input.userId } : {}),
+                ...(principalFromRun(run) ? { principal: principalFromRun(run) } : {}),
+                ...(initiatorFromRun(run) ? { initiator: initiatorFromRun(run) } : {}),
+                audience: audienceFromRun(run),
+                ...((options.metadata ?? options.turn?.metadata) ? {
+                    metadata: (options.metadata ?? options.turn?.metadata)
+                } : {}),
+                attachments
+            }),
+            surface,
+            catalog: { ...baseCatalog, skills: new Set(liveSkills) },
+            defaultSkills: liveSkills,
+            disabledTools,
+            createCheckpoint: (input) => this.createCheckpoint(input),
+            listCheckpoints: (runId) => this.listHydratedCheckpoints(runId)
         });
-        return this.hookDispatcher(runId, event);
-    }
-    /** Per-run capability resolution from `resolvers.ts` (run-resolver.ts). */
-    resolveRunCapabilities(run, options, conversationId) {
-        const input = { runId: run.id, message: options.message };
-        if (options.channel !== undefined)
-            input.channel = options.channel;
-        if (conversationId !== undefined)
-            input.conversationId = conversationId;
-        if (options.metadata !== undefined)
-            input.metadata = options.metadata;
-        return resolveRunCapabilitiesImpl({
+        this.agentStateHandles.set(run.id, created.agentState);
+        this.agentHookControllers.set(run.id, created.controller);
+        return created.controller;
+    }
+    async createSubagentHookController(run, subagent, message, conversationId) {
+        const surface = subagentSurface(subagent);
+        const liveSkills = (await this.listSkills(surface.path)).map((skill) => skill.name).sort();
+        const baseCatalog = hookCapabilityCatalog(this.manifest, surface);
+        const created = await createRuntimeAgentHookController({
             manifest: this.manifest,
-            env: this.env,
-            loadModule: (source) => this.sourceLoader.load(source),
-            appendEvent: (runId, type, data) => this.state.appendEvent(runId, type, data)
-        }, input);
+            state: this.state,
+            blob: this.blob,
+            sourceLoader: this.sourceLoader,
+            eventHandlers: this.eventHandlers,
+            logger: this.logger,
+            agentScope: `${this.durableAgentScope()}:subagent:${subagent.path}`,
+            conversationId,
+            agentSource: subagent.agentSource,
+            surface,
+            catalog: {
+                ...baseCatalog,
+                skills: new Set(liveSkills),
+                models: new Set(subagent.possibleModels),
+                connections: new Set(subagent.connections),
+                ...(subagent.maxReasoning !== undefined ? { maxReasoning: subagent.maxReasoning } : {})
+            },
+            defaultSkills: liveSkills,
+            run: immutableAgentRunContext({
+                id: run.id,
+                message,
+                channel: "subagent",
+                conversationId,
+                ...(typeof run.input.userId === "string" ? { userId: run.input.userId } : {}),
+                ...(principalFromRun(run) ? { principal: principalFromRun(run) } : {}),
+                ...(initiatorFromRun(run) ? { initiator: initiatorFromRun(run) } : {}),
+                audience: audienceFromRun(run),
+                ...(isJsonObject(run.input.metadata) ? { metadata: run.input.metadata } : {}),
+                attachments: []
+            }),
+            disabledTools: this.disabledToolsForRun(run),
+            createCheckpoint: (input) => this.createCheckpoint(input),
+            listCheckpoints: (runId) => this.listHydratedCheckpoints(runId)
+        });
+        this.agentStateHandles.set(run.id, created.agentState);
+        this.agentHookControllers.set(run.id, created.controller);
+        return created.controller;
+    }
+    disabledToolsForRun(run) {
+        const disabledTools = new Set(Object.entries(this.coreToolPolicy).filter(([, mode]) => mode === "disabled").map(([name]) => name));
+        return disabledTools;
+    }
+    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 = resolveEvalToolStub(this.evalStubCursors, run, tool.name) ?? this.toolStubs[tool.name];
@@ -2004,8 +2095,6 @@ export class AssemblyLineRuntime {
                 execute: async (input) => stub(input)
             };
         }
-        // Only builtin-sourced entries resolve to the built-in implementation; an
-        // authored tool that shares a built-in's name is an override and loads its module.
         if (tool.source.path.startsWith("__builtin__")) {
             const builtIn = builtInToolDefinition(tool.name);
             if (builtIn)
@@ -2014,26 +2103,8 @@ export class AssemblyLineRuntime {
         const module = await this.sourceLoader.load(tool.source);
         return module.default;
     }
-    async loadInstrumentationModule() {
-        if (!this.manifest.instrumentation)
-            return {};
-        return this.sourceLoader.load(this.manifest.instrumentation);
-    }
     async result(run, response, waitingForApproval, waitingForInput, waitingForConnection) {
-        const result = {
-            run,
-            events: await this.state.listEvents(run.id),
-            toolCalls: await this.state.listToolCalls(run.id),
-            deliveries: await this.state.listDeliveries(run.id),
-            response
-        };
-        if (waitingForApproval !== undefined)
-            result.waitingForApproval = waitingForApproval;
-        if (waitingForInput !== undefined)
-            result.waitingForInput = waitingForInput;
-        if (waitingForConnection !== undefined)
-            result.waitingForConnection = waitingForConnection;
-        return result;
+        return buildRunAgentResult(this.state, run, response, waitingForApproval, waitingForInput, waitingForConnection);
     }
 }
 export async function runLocalAgent(options) {