@assemblyline-agents/runtime 2.0.0 → 3.1.0

package/dist/index.js

@@ -1,34 +1,48 @@
 import { createHash } from "node:crypto";
 import { join, resolve } from "node:path";
 import { builtInToolDefinition } from "./builtin-tools.js";
-export { builtInToolDefaults } from "./builtin-tools.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 { 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 { ARTIFACT_DIR_NAME, OPENEVE_MANIFEST_SCHEMA_VERSION, applyEnvAliases } 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 { failRun as failRunImpl, handleRunExecutionError, logTerminalRunEvent, settleCompletionBoundaryControlImpl } from "./run-outcome.js";
-import { registerRunAbortController, startRunHeartbeatImpl } from "./run-heartbeat.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 { conversationInitiator, defaultUserPrincipal, initiatorFromRun, normalizeAgentPrincipal, principalFromRun, principalUserId } from "./principals.js";
-import { InMemoryConnectionAuthorizationSessionStore, InMemoryConnectionGrantStore, materializeConnectionCredentialsIntoSandbox } from "./connections.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";
@@ -37,17 +51,23 @@ 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";
@@ -55,41 +75,25 @@ 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 { FileLearningStore, InMemoryLearningStore } from "./learning-store.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, 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 { 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();
@@ -99,6 +103,7 @@ export class AssemblyLineRuntime {
     blob;
     sandbox;
     scheduler;
+    mediaProcessors;
     deliveryMode;
     toolStubs;
     /** Per-run {results:[...]} stub cursors; in-memory by design (see eval-run-options.ts). */
@@ -116,9 +121,11 @@ export class AssemblyLineRuntime {
     connections;
     env;
     fetch;
+    attachmentHostResolver;
     logger;
     connectionGrantStore;
     connectionAuthorizationSessionStore;
+    connectionEventStore;
     connectionCallbackBaseUrl;
     skillStore;
     learningStore;
@@ -163,14 +170,19 @@ 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
@@ -179,15 +191,17 @@ export class AssemblyLineRuntime {
         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", {
@@ -199,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;
@@ -215,12 +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) {
@@ -236,37 +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,
-            skillsConfig: this.skillsConfig, learningStore: this.learningStore,
+            learningStore: this.learningStore,
             skillStore: this.skillStore, memoryStore: this.memoryStore,
-            skillScope: () => this.skillScope(),
+            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,
@@ -285,10 +311,17 @@ export class AssemblyLineRuntime {
             sourceBundle: this.sourceBundle,
             ...(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) {
@@ -374,17 +407,41 @@ export class AssemblyLineRuntime {
             this.logger.warn("provider ingress security warning", { warning });
         }
     }
-    skillScope() { return this.durableAgentScope(); }
+    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() { return this.runtimeLearning.ensureSkillsSeeded(); }
+    async ensureSkillsSeeded(surfacePath = "root") { return this.runtimeLearning.ensureSkillsSeeded(surfacePath); }
     async migrateLegacyConnectionScope() {
         if (this.connectionScopeMigrated)
             return;
@@ -401,19 +458,19 @@ export class AssemblyLineRuntime {
         }
     }
     /** Live skill catalog (durable store, post-seed) for context assembly and inspection. */
-    async listSkills() { return this.runtimeLearning.listSkills(); }
+    async listSkills(surfacePath = "root") { return this.runtimeLearning.listSkills(surfacePath); }
     /** Persist an agent/user authored skill, honoring the write-approval gate. */
-    async saveSkill(input) { return this.runtimeLearning.saveSkill(input); }
-    async deleteSkill(name) { return this.runtimeLearning.deleteSkill(name); }
-    async listSkillRevisions(name) { return this.runtimeLearning.listSkillRevisions(name); }
-    async restoreSkillRevision(name, revision) { return this.runtimeLearning.restoreSkillRevision(name, revision); }
-    async listPendingSkillChanges() { return this.runtimeLearning.listPendingSkillChanges(); }
-    async approveSkillChange(id) { return this.runtimeLearning.approveSkillChange(id); }
-    async rejectSkillChange(id) { return this.runtimeLearning.rejectSkillChange(id); }
+    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() { return this.runtimeLearning.listBackgroundReviews(); }
+    async listBackgroundReviews(surfacePath = "root") { return this.runtimeLearning.listBackgroundReviews(surfacePath); }
     async runDueBackgroundReviews(options = {}) {
         return this.runtimeLearning.runDueBackgroundReviews(options);
     }
@@ -540,83 +597,26 @@ export class AssemblyLineRuntime {
             state: this.state,
             memoryStore: this.memoryStore,
             skillStore: this.skillStore,
+            skillBundleIndex: this.skillBundleIndex,
             learningStore: this.learningStore,
-            skillsConfig: this.skillsConfig,
+            skillsConfigForRun: (run) => this.skillsConfigForRun(run),
             memoryScopeForRun: (candidate) => this.memoryScopeForRun(candidate),
-            skillScope: () => this.skillScope()
+            skillScopeForRun: (run) => this.skillScopeForRun(run)
         };
     }
     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"
-                }
-            });
-            const selectedConnections = Array.isArray(run.input.agentConnections)
-                ? new Set(run.input.agentConnections.filter((name) => typeof name === "string"))
-                : new Set();
-            await materializeConnectionCredentialsIntoSandbox(run, runtime.createConnectionRegistryForRun(run, "local", undefined, selectedConnections), sandboxSession, (eventType, payload) => runtime.state.appendEvent(run.id, eventType, payload));
-            return sandboxSession;
-        };
-        return {
-            current() {
-                return sandboxSession;
-            },
-            async get() {
-                if (sandboxSession)
-                    return sandboxSession;
-                // Memoize the in-flight acquisition: parallel tool calls must share
-                // one sandbox session instead of racing to create two.
-                acquiring ??= acquire().catch((error) => {
-                    acquiring = undefined;
-                    throw error;
-                });
-                return acquiring;
-            },
-            async getWrapped() {
-                const run = getRun();
-                return runtime.wrapSandbox(run.id, await this.get());
-            },
-            async reset() {
-                const active = sandboxSession ?? (acquiring ? await acquiring : undefined);
-                if (active)
-                    await runtime.disposeSandboxSession(getRun().id, active);
-                sandboxSession = undefined;
-                acquiring = undefined;
-            },
-            async dispose() {
-                if (!sandboxSession)
-                    return;
-                await runtime.disposeSandboxSession(getRun().id, sandboxSession);
-            }
-        };
+        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);
@@ -631,8 +631,8 @@ export class AssemblyLineRuntime {
         }, 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) {
@@ -724,18 +724,36 @@ 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 suppliedConversationId = options.turn?.conversationId ?? options.conversationId;
+        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 = normalizeAgentPrincipal(options.turn?.principal ?? options.principal)
-            ?? (options.existingRun ? principalFromRun(options.existingRun) : undefined)
+        const principal = (options.existingRun ? principalFromRun(options.existingRun) : undefined)
+            ?? normalizeAgentPrincipal(options.turn?.principal ?? options.principal)
             ?? defaultUserPrincipal(legacyUserId, channel);
-        const initiator = normalizeAgentPrincipal(options.turn?.initiator ?? options.initiator)
-            ?? (options.existingRun ? initiatorFromRun(options.existingRun) : undefined)
+        const initiator = (options.existingRun ? initiatorFromRun(options.existingRun) : undefined)
+            ?? normalizeAgentPrincipal(options.turn?.initiator ?? options.initiator)
             ?? principal;
+        // Channel turns derive their audience from the authenticated turn, so it
+        // cannot disagree with the principal or conversation; other callers are
+        // trusted embedders and default to a private direct run.
+        const audience = (options.existingRun ? normalizeAgentAudience(options.existingRun.input.audience) : undefined)
+            ?? normalizeAgentAudience(options.turn?.audience ?? options.audience)
+            ?? { private: true };
+        const replyTarget = options.existingRun && isJsonObject(options.existingRun.input.replyTarget)
+            ? options.existingRun.input.replyTarget
+            : safeJson({
+                channel,
+                conversationId: suppliedConversationId ?? null,
+                delivery: options.turn?.delivery ?? options.delivery ?? null
+            });
         const runInput = {
             message: options.message,
+            agentSurface: "root",
             channel,
             eventId: options.turn?.eventId ?? options.eventId ?? null,
             conversationId: suppliedConversationId ?? options.existingRun?.input.conversationId ?? null,
@@ -747,11 +765,18 @@ export class AssemblyLineRuntime {
             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: {
@@ -771,6 +796,8 @@ export class AssemblyLineRuntime {
             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 });
+        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",
@@ -778,6 +805,10 @@ export class AssemblyLineRuntime {
                 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
@@ -795,18 +826,42 @@ 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 };
@@ -842,26 +897,7 @@ export class AssemblyLineRuntime {
                     attachmentMetadata: attachments
                 }
             });
-            const missingConnections = this.missingRequiredConnections(capabilities.connections);
-            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 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;
@@ -877,13 +913,14 @@ export class AssemblyLineRuntime {
                 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;
-            let 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 });
@@ -901,7 +938,7 @@ export class AssemblyLineRuntime {
             let structuredOutput;
             const tool = this.selectTool(hydratedOptions);
             if (tool) {
-                if (!capabilities.tools.includes(tool.name)) {
+                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";
@@ -961,7 +998,8 @@ export class AssemblyLineRuntime {
                     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);
                 }
                 const outcome = await this.runHarnessLoop(loopInput);
                 run = outcome.run;
@@ -1008,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 {
@@ -1025,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,
@@ -1037,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;
@@ -1051,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;
@@ -1063,8 +1104,9 @@ 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) {
@@ -1113,9 +1155,10 @@ export class AssemblyLineRuntime {
             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)
@@ -1127,15 +1170,16 @@ export class AssemblyLineRuntime {
             throw new Error("No compiled model is available for harness resolution.");
         return resolveAgentHarnessImpl(this.harnessLoopHost(), resolvedModel);
     }
-    piHarness() {
-        return piHarnessImpl(this.harnessLoopHost());
-    }
     async runHarnessLoop(input) {
         return runHarnessLoopImpl(this.harnessLoopHost(), input);
     }
     /** Load the conversation's stored transcript for resume, or undefined when disabled/absent. */
     async loadConversationTranscript(conversationId, runId) {
-        return loadResumableConversationTranscriptImpl(this.conversationContextHost(), { state: this.state, createCheckpoint: (input) => this.createCheckpoint(input) }, conversationId, runId);
+        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);
@@ -1184,9 +1228,10 @@ 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) => this.resolvedInstructionsForRun(run, bundle, capabilities),
+            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),
@@ -1203,12 +1248,17 @@ export class AssemblyLineRuntime {
             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));
@@ -1219,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;
     }
     /**
@@ -1237,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));
@@ -1289,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) {
@@ -1338,7 +1455,7 @@ export class AssemblyLineRuntime {
         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(skillName);
+        const loaded = await this.skillLoadDetails(run, skillName);
         const output = {
             name: loaded.name,
             skillName: loaded.name,
@@ -1423,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;
     }
@@ -1447,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)
         };
@@ -1471,6 +1590,7 @@ export class AssemblyLineRuntime {
             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);
@@ -1515,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),
@@ -1532,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,
@@ -1549,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),
@@ -1597,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);
@@ -1647,7 +1769,12 @@ 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(selected) {
@@ -1665,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,
@@ -1695,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);
@@ -1722,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,
@@ -1736,12 +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,
+            surfaceForRun: (run) => surfaceForRun(this.manifest, run),
             agentStateForRun: (runId) => this.agentStateForRun(runId),
-            ensureSkillsSeeded: () => this.ensureSkillsSeeded(),
-            skillScope: () => this.skillScope(),
+            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),
@@ -1754,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),
@@ -1800,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 = {}) {
@@ -1819,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);
     }
@@ -1847,7 +1984,10 @@ export class AssemblyLineRuntime {
         await this.runtimeLearning.handleRuntimeEvent(runId, event.type);
     }
     async createAgentHookController(run, options, channel, conversationId, attachments) {
-        const disabledTools = new Set(Object.entries(this.coreToolPolicy).filter(([, mode]) => mode === "disabled").map(([name]) => name));
+        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,
@@ -1865,11 +2005,15 @@ export class AssemblyLineRuntime {
                 ...(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)
@@ -1879,7 +2023,9 @@ export class AssemblyLineRuntime {
         return created.controller;
     }
     async createSubagentHookController(run, subagent, message, conversationId) {
-        const baseCatalog = hookCapabilityCatalog(this.manifest);
+        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,
             state: this.state,
@@ -1887,15 +2033,18 @@ export class AssemblyLineRuntime {
             sourceLoader: this.sourceLoader,
             eventHandlers: this.eventHandlers,
             logger: this.logger,
-            agentScope: `${this.durableAgentScope()}:subagent:${subagent.name}`,
+            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,
@@ -1904,9 +2053,11 @@ export class AssemblyLineRuntime {
                 ...(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)
         });
@@ -1914,6 +2065,10 @@ export class AssemblyLineRuntime {
         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)
@@ -1931,9 +2086,6 @@ export class AssemblyLineRuntime {
             createSubagent: (subagent, message, conversationId) => this.createSubagentHookController(run, subagent, message, conversationId)
         });
     }
-    resolvedInstructionsForRun(run, bundle, capabilities) {
-        return resolvedHookInstructionsForRun(this.manifest, this.sourceLoader, run, bundle.instructions, capabilities);
-    }
     async loadTool(tool, run) {
         const stub = resolveEvalToolStub(this.evalStubCursors, run, tool.name) ?? this.toolStubs[tool.name];
         if (stub) {
@@ -1943,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)
@@ -1953,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) {