@assemblyline-agents/runtime 3.1.0 → 3.3.0

package/dist/index.js

@@ -5,15 +5,15 @@ 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 { evalRunOptionsForRun, resolveEvalToolStub, validateEvalRunOptions } from "./eval-run-options.js";
 import { rememberDefaultOutboundRoute } from "./default-outbound-route.js";
 import { audienceFromRun, audienceUserKey, normalizeAgentAudience } from "./audience.js";
 import { AgentSourceModuleLoader } from "./source-loader.js";
+import { SandboxAuthoredToolExecutor, resolveAuthoredToolExecutionPolicy } from "./sandbox-authored-tool-executor.js";
 import { AgentEventHandlerRegistry } from "./agent-event-handlers.js";
-import { 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 { createMainAgentHookController as createMainAgentHookControllerImpl, createSubagentHookController as createSubagentHookControllerImpl } from "./agent-hook-controller-factory.js";
+import { durableAgentSurfaceScope, flattenSubagents, surfaceForPath, surfaceForRun } from "./agent-surface.js";
+import { recoverAgentHookController, removeTerminalAgentHookState, resolvedInstructionsForRun as resolvedHookInstructionsForRun } from "./agent-hook-run-lifecycle.js";
 import { compiledChannelProvider, providerIngressSecurityError, providerIngressSecurityWarnings, resolveCoreToolPolicy, trustedAttachmentProviderForTurn } from "./security.js";
 export { constantTimeSecretEqual } from "./security.js";
 export { RUN_STREAM_TERMINAL_EVENTS } from "./run-stream.js";
@@ -24,7 +24,7 @@ import { resolveBooleanEnv, resolveNonNegativeIntegerEnv, resolvePositiveInteger
 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 { cacheRunControlSignal, registerRunAbortController, startRunHeartbeatImpl, trackActiveRunHeartbeat } from "./run-heartbeat.js";
+import { eventRenewsRunProgress, RunProgressSupervisor } from "./run-heartbeat.js";
 import { redactTruncateJson } from "./content-capture.js";
 import { isJsonObject, safeJson } from "./json-util.js";
 import { sandboxSessionKeyForRun } from "./sandbox-session-key.js";
@@ -55,7 +55,8 @@ import { beginChannelTurnImpl, completeRunImpl, latestRunFailureMessageImpl, rec
 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 { RuntimeWorkspaceManager } from "./workspace-runtime.js";
+import { DynamicScheduleRuntimeMethods } from "./dynamic-schedule-runtime.js";
 import { beginConnectionAuthorizationImpl, createConnectionRegistryForRunImpl, createConnectionRegistryForSessionImpl, createConnectionRegistryImpl, executeConnectionToolWithRecordImpl, skillLoadDetailsImpl } from "./builtin-tool-executors.js";
 import { createMemoryToolApiImpl, createResourceToolApiImpl, durableStepImpl } from "./tool-apis.js";
 import { executeToolImpl, executeToolWithRecordImpl, harnessExecuteToolImpl, modelToolsImpl, selectToolImpl, visibleToolSetImpl, wrapSandboxImpl } from "./tool-execution.js";
@@ -64,13 +65,15 @@ import { completeConnectionAuthorizationCallbackImpl, replayImpl, resumeApproval
 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 { createSubagentRunImpl, executeSubagentRunImpl, finalizeSubagentHandoffImpl, readSubagentImpl, resumeSubagentImpl, runSubagentImpl, sendSubagentFollowupImpl } from "./subagent-execution.js";
+import { acceptBackgroundSubagentHandoff } from "./subagent-handoff.js";
 import { createHarnessContextImpl, DEFAULT_MAX_MODEL_ITERATIONS, DEFAULT_OUTPUT_VALIDATION_MAX_RETRIES, executeHarnessTurnImpl, persistHarnessContinuationImpl, resolveAgentHarnessImpl, runHarnessLoopImpl } from "./harness-loop.js";
 import { getAgentControlImpl, requestRunControlImpl, setAgentEnabledImpl, setAgentMaintenanceImpl } from "./operator-controls.js";
 import { acceptChannelTurnImpl, channelAttachmentResolverImpl, dispatchHttpChannelImpl, loadChannelModuleImpl, observeChannelMessageImpl, startChannelAgentTurnImpl, startChannelIngressImpl } from "./channel-ingress.js";
 import { augmentChannelContextImpl, buildContextBundleImpl, prepareConversationImpl, recentHistoryImpl } from "./conversation-context.js";
 import { loadResumableConversationTranscriptImpl } from "./conversation-transcript.js";
 import { ConversationTurnDispatcher } from "./conversation-turn-dispatch.js";
+import { BackgroundSubagentCoordinator } from "./background-subagents.js";
 import { instructionsForRunTargetImpl } from "./target-instructions.js";
 import { emitTelemetrySpanImpl, runSpanAttributesImpl } from "./telemetry.js";
 import { normalizeRuntimeState } from "./state-stores.js";
@@ -92,9 +95,10 @@ import { syncMemoryFromSandbox, syncSkillsFromSandbox } from "./sandbox-state-sy
 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 class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
+import { connectionPrincipalKeyForGrant, durableAgentScopeForManifest, isInstrumentationDefinition, normalizeCapturePolicy, randomHex, timestamp, } from "./runtime-util.js";
+export class AssemblyLineRuntime extends DynamicScheduleRuntimeMethods {
     manifest;
+    authoredToolExecution;
     state;
     runEventBus = new RunEventBus();
     eventHandlers;
@@ -103,6 +107,8 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
     blob;
     sandbox;
     scheduler;
+    scheduleStore;
+    schedulesConfig;
     mediaProcessors;
     deliveryMode;
     toolStubs;
@@ -130,10 +136,8 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
     skillStore;
     learningStore;
     memoryStore;
-    scheduleStore;
     connectionDefinitionStore;
     skillsConfig;
-    schedulesConfig;
     connectionsConfig;
     runtimeLearning;
     connectionScopeMigrated = false;
@@ -159,6 +163,7 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
     outputValidationMaxRetries;
     runSemaphore;
     conversationTurnDispatcher;
+    backgroundSubagents;
     memoryEmbeddingProvider;
     memoryEmbeddingsEnabled;
     resourceProjectionPolicy;
@@ -170,6 +175,7 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
     hostInstrumentationProvided;
     instrumentationConfig;
     sourceLoader;
+    sandboxAuthoredToolExecutor;
     skillBundleIndex;
     skillResourceReader;
     contextPolicyPromise;
@@ -177,13 +183,12 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
     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;
+    runProgress;
+    runStallTimeoutMs;
     constructor(options) {
         super();
         this.manifest = options.manifest;
+        this.authoredToolExecution = resolveAuthoredToolExecutionPolicy(options.authoredToolExecution);
         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).
@@ -286,7 +291,16 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
         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.runStallTimeoutMs = options.runStallTimeoutMs ?? resolveNonNegativeIntegerEnv(this.env.ASSEMBLY_LINE_RUN_STALL_TIMEOUT_MS, 3_600_000);
+        this.runProgress = new RunProgressSupervisor({
+            state: this.state,
+            logger: this.logger,
+            runHeartbeatMs: this.runHeartbeatMs,
+            runStallTimeoutMs: this.runStallTimeoutMs,
+            runControlIntents: this.runControlIntents,
+            activeRuns: this.activeRunExecutions,
+            debugSwallow: (message, fields) => this.debugSwallow(message, fields)
+        });
         this.runRecoveryIntervalMs = options.runRecoveryIntervalMs ?? resolvePositiveIntegerEnv(this.env.ASSEMBLY_LINE_RUN_RECOVERY_INTERVAL_MS, 60_000);
         this.maxModelIterations = resolvePositiveIntegerEnv(this.env.ASSEMBLY_LINE_MAX_MODEL_ITERATIONS, DEFAULT_MAX_MODEL_ITERATIONS);
         this.outputValidationMaxRetries = resolveNonNegativeIntegerEnv(this.env.ASSEMBLY_LINE_OUTPUT_VALIDATION_MAX_RETRIES, DEFAULT_OUTPUT_VALIDATION_MAX_RETRIES);
@@ -296,7 +310,7 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
         });
         this.conversationTurnDispatcher = new ConversationTurnDispatcher({
             state: this.state, logger: this.logger,
-            agentScope: this.durableAgentScope(), maxRunDurationMs: this.maxRunDurationMs,
+            agentScope: this.durableAgentScope(),
             now: () => this.now(), agentEnabled: () => this.agentEnabled(),
             admitRunOrReject: () => this.admitRunOrReject(),
             runTurn: (turn, admission, onRunCreated) => this.run({
@@ -309,8 +323,12 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
         this.sourceLoader = new AgentSourceModuleLoader({
             manifest: this.manifest,
             sourceBundle: this.sourceBundle,
-            ...(options.artifactRoot ? { cacheRoot: join(resolve(options.artifactRoot), ARTIFACT_DIR_NAME, "module-cache") } : {})
+            ...(options.artifactRoot ? {
+                cacheRoot: join(resolve(options.artifactRoot), ARTIFACT_DIR_NAME, "module-cache"),
+                packageRoot: resolve(options.artifactRoot)
+            } : {})
         });
+        this.sandboxAuthoredToolExecutor = new SandboxAuthoredToolExecutor(this.sourceLoader);
         this.skillBundleIndex = createSkillBundleIndex(this.manifest);
         this.skillResourceReader = createSkillResourceReader({
             manifest: this.manifest,
@@ -318,6 +336,16 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
             manifestRoot: this.manifest.root,
             sourceBundle: this.sourceBundle
         });
+        this.backgroundSubagents = new BackgroundSubagentCoordinator({
+            state: this.state,
+            logger: this.logger,
+            withRunAdmission: (work) => this.withRunAdmission(work),
+            execute: (childRunId) => executeSubagentRunImpl(this.subagentExecutionHost(), childRunId),
+            finalize: (timeline) => finalizeSubagentHandoffImpl(this.subagentExecutionHost(), timeline),
+            replay: (runId) => this.replay(runId),
+            cancel: (runId) => this.cancelRun(runId),
+            enqueueConversationTurn: (input) => this.conversationTurnDispatcher.enqueue(input)
+        });
     }
     boot() {
         if (this.manifest.schemaVersion !== ASSEMBLY_LINE_MANIFEST_SCHEMA_VERSION) {
@@ -374,6 +402,7 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
     async createCheckpoint(input) {
         const storedData = await this.checkpointDataForStorage(input.runId, input.name, input.data);
         const checkpoint = await this.state.createCheckpoint({ ...input, data: storedData });
+        await this.runProgress.renew(input.runId);
         if (COMPACTABLE_ACTIVE_CHECKPOINT_NAMES.includes(input.name)) {
             await this.compactCheckpoints({
                 runId: input.runId,
@@ -477,53 +506,6 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
     startBackgroundReviewWorker(options = {}) {
         return this.runtimeLearning.startBackgroundReviewWorker(options);
     }
-    async createDynamicSchedule(input) {
-        if (!this.schedulesConfig.dynamic) {
-            throw new Error("Dynamic automations are disabled (dynamicAutomations.dynamic is false).");
-        }
-        const trigger = input.trigger ? this.normalizeScheduleTriggerDefinition(input.trigger) : undefined;
-        const prompt = stringValue(input.prompt) || stringValue(input.message) || (trigger ? `Run scheduled trigger ${trigger.handler}.` : "");
-        if (!prompt)
-            throw new Error("Dynamic schedules require prompt or message.");
-        const createInput = {
-            ...input,
-            prompt
-        };
-        if (input.message)
-            createInput.message = input.message;
-        if (trigger)
-            createInput.trigger = trigger;
-        return this.scheduleStore.create(createInput);
-    }
-    async createDynamicAutomation(input) {
-        return this.createDynamicSchedule(input);
-    }
-    async listDynamicSchedules(scope) {
-        return this.scheduleStore.list(scope);
-    }
-    async listDynamicAutomations(scope) {
-        return this.listDynamicSchedules(scope);
-    }
-    async updateDynamicSchedule(scope, id, patch) {
-        if (!this.schedulesConfig.dynamic) {
-            throw new Error("Dynamic automations are disabled (dynamicAutomations.dynamic is false).");
-        }
-        const normalized = { ...patch };
-        if (Object.prototype.hasOwnProperty.call(patch, "trigger")) {
-            const rawTrigger = patch.trigger;
-            normalized.trigger = rawTrigger === null ? null : this.normalizeScheduleTriggerDefinition(rawTrigger);
-        }
-        return this.scheduleStore.update(scope, id, normalized);
-    }
-    async updateDynamicAutomation(scope, id, patch) {
-        return this.updateDynamicSchedule(scope, id, patch);
-    }
-    async deleteDynamicSchedule(scope, id) {
-        return this.scheduleStore.delete(scope, id);
-    }
-    async deleteDynamicAutomation(scope, id) {
-        return this.deleteDynamicSchedule(scope, id);
-    }
     /** Persist a runtime-provided connection definition (gated). Credentials route to the grant store. */
     async saveConnectionDefinition(input) {
         if (!this.connectionsConfig.dynamic) {
@@ -624,6 +606,7 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
     async acquireSandboxForRun(run) {
         return acquireSandboxSessionForRun({
             manifest: this.manifest,
+            env: this.env,
             state: this.state,
             sandbox: this.sandbox,
             sessionKey: (candidate) => this.sandboxSessionKey(candidate),
@@ -796,6 +779,17 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
             this.logger.warn("onRunCreated hook failed", { runId: run.id, error: error instanceof Error ? error.message : String(error) });
         }
         await this.state.appendEvent(run.id, "run.accepted", { agentRevision: this.manifest.agentRevision });
+        try {
+            await acceptBackgroundSubagentHandoff(this.state, run);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            run = await failRunImpl({ state: this.state }, run.id, {
+                reason: "subagent.handoff_failed",
+                error: message
+            });
+            return this.result(run, `Artifact handoff failed: ${message}`, false, false, false);
+        }
         if (options.replay)
             await recordRunReplayStarted(this.state, run.id, options.replay);
         if (this.usesRevisionScopedDurableState() && (this.skillsConfig.enabled || this.connectionsConfig.dynamic)) {
@@ -916,8 +910,20 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
             const channelContext = mergeJsonObjects(media.channelContext, augmentation?.channelContext);
             if (channelContext)
                 contextInput.channelContext = channelContext;
-            if (hydratedOptions.promptContext)
-                contextInput.promptContext = hydratedOptions.promptContext;
+            const activeWork = await this.backgroundSubagents.listForRoot(run);
+            if (hydratedOptions.promptContext || activeWork.length > 0) {
+                contextInput.promptContext = {
+                    ...(hydratedOptions.promptContext ?? {}),
+                    ...(activeWork.length > 0
+                        ? {
+                            activeWork: {
+                                items: activeWork,
+                                guidance: "These background tasks are still active. You may answer new messages while they run. Do not claim they are complete. Use manage_work to inspect or cancel them."
+                            }
+                        }
+                        : {})
+                };
+            }
             if (hydratedOptions.target)
                 contextInput.target = hydratedOptions.target;
             let bundle = options.contextSnapshot ? structuredClone(options.contextSnapshot) : await this.buildContextBundle(contextInput);
@@ -965,6 +971,13 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
                 const input = hydratedOptions.input ?? inferToolInput(tool, hydratedOptions.message);
                 const outcome = await this.executeTool(run, tool, input, sandboxHandle, hydratedOptions.approve ?? false);
                 run = outcome.run;
+                const stalled = await this.runProgress.failIfStalled(run);
+                if (stalled) {
+                    run = stalled;
+                    await stopChannelLifecycle();
+                    await sandboxHandle.dispose();
+                    return this.result(run, "Run stalled without durable progress.", false, false, false);
+                }
                 if (outcome.waitingForApproval || outcome.waitingForInput || outcome.waitingForConnection) {
                     await stopChannelLifecycle();
                     await this.emitSpan("ai.assembly-line.turn", spanStartedAt, this.runSpanAttributes(run, {
@@ -1063,24 +1076,9 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
     async settleCompletionBoundaryControl(run) {
         return settleCompletionBoundaryControlImpl({ state: this.state, runControlIntents: this.runControlIntents }, run);
     }
-    /** Bump `updatedAt` while a run executes; enforces the wall-clock deadline (run-heartbeat.ts). */
+    /** Bump `updatedAt` while a run executes and supervise its progress lease. */
     startRunHeartbeat(runId) {
-        return trackActiveRunHeartbeat(this.activeRunExecutions, runId, startRunHeartbeatImpl({
-            state: this.state,
-            logger: this.logger,
-            runHeartbeatMs: this.runHeartbeatMs,
-            maxRunDurationMs: this.maxRunDurationMs,
-            runControlIntents: this.runControlIntents,
-            runDeadlines: this.runDeadlines,
-            abortRunControllers: (id) => {
-                for (const controller of this.runAbortControllers.get(id) ?? [])
-                    controller.abort();
-            },
-            debugSwallow: (message, fields) => this.debugSwallow(message, fields)
-        }, runId));
-    }
-    registerRunAbort(runId, controller) {
-        return registerRunAbortController(this.runAbortControllers, this.runDeadlines, runId, controller, this.runControlIntents);
+        return this.runProgress.start(runId);
     }
     conversationContextHost() {
         const runtime = this;
@@ -1136,10 +1134,10 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
             maxModelIterations: this.maxModelIterations,
             outputValidationMaxRetries: this.outputValidationMaxRetries,
             now: () => this.now(),
-            shouldStopRun: (runId) => this.runControlIntents.has(runId) || this.runDeadlines.has(runId),
-            runDeadlineExceeded: (runId) => this.runDeadlines.has(runId),
-            registerRunAbort: (runId, controller) => this.registerRunAbort(runId, controller),
-            maxRunDurationMs: this.maxRunDurationMs,
+            shouldStopRun: (runId) => this.runProgress.shouldStop(runId),
+            runStalled: (runId) => this.runProgress.isStalled(runId),
+            registerRunAbort: (runId, controller) => this.runProgress.registerAbort(runId, controller),
+            runStallTimeoutMs: this.runStallTimeoutMs,
             runEventBus: this.runEventBus,
             connectionAuthorizationSessionStore: this.connectionAuthorizationSessionStore,
             get defaultAgentHarness() {
@@ -1155,7 +1153,7 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
             createConnectionRegistryForRun: (run, fallbackChannel, sandboxHandle, selectedConnections) => this.createConnectionRegistryForRun(run, fallbackChannel, sandboxHandle, selectedConnections),
             missingRequiredConnections: (selected) => this.missingRequiredConnections(selected),
             visibleToolSet: (defaultToolNames, activeSkills) => this.visibleToolSet(defaultToolNames, activeSkills),
-            modelTools: (run, activeToolNames, connectionRegistry, discoveredConnectionTools, options) => this.modelTools(run, activeToolNames, connectionRegistry, discoveredConnectionTools, options),
+            modelTools: (run, activeToolNames, sandboxHandle, connectionRegistry, discoveredConnectionTools, options) => this.modelTools(run, activeToolNames, sandboxHandle, connectionRegistry, discoveredConnectionTools, options),
             harnessExecuteTool: (call, state) => this.harnessExecuteTool(call, state),
             createCheckpoint: (input) => this.createCheckpoint(input),
             hydrateCheckpointData: (data) => this.hydrateCheckpointData(data),
@@ -1411,7 +1409,7 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
             state: this.state,
             boot: () => this.boot(),
             durableAgentScope: () => this.durableAgentScope(),
-            cacheRunControl: (runId, intent) => cacheRunControlSignal(this.runControlIntents, this.activeRunExecutions, this.runAbortControllers, runId, intent)
+            cacheRunControl: (runId, intent) => this.runProgress.cacheControl(runId, intent)
         };
     }
     async resumeHarnessLoop(run, harness, restored, resume) {
@@ -1420,6 +1418,7 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
     subagentExecutionHost() {
         return {
             state: this.state,
+            blob: this.blob,
             manifest: this.manifest,
             sourceLoader: this.sourceLoader,
             resolveAgentHarness: (modelSpec) => this.resolveAgentHarness(modelSpec),
@@ -1440,6 +1439,32 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
     async runSubagent(parentRunId, subagentName, task) {
         return runSubagentImpl(this.subagentExecutionHost(), parentRunId, subagentName, task);
     }
+    async resumeSubagent(parentRunId, childRunId, subagentName, message) {
+        return resumeSubagentImpl(this.subagentExecutionHost(), parentRunId, childRunId, subagentName, message);
+    }
+    async queueSubagent(parentRunId, subagentName, task) {
+        const child = await createSubagentRunImpl(this.subagentExecutionHost(), parentRunId, subagentName, task, { background: true });
+        this.backgroundSubagents.requestDrain();
+        return child;
+    }
+    async listBackgroundWork(rootRunId, includeTerminal = false) {
+        const root = await this.state.getRun(rootRunId);
+        if (!root)
+            throw new Error(`Run not found: ${rootRunId}`);
+        return this.backgroundSubagents.listForRoot(root, includeTerminal);
+    }
+    async getBackgroundWork(rootRunId, childRunId) {
+        const root = await this.state.getRun(rootRunId);
+        if (!root)
+            throw new Error(`Run not found: ${rootRunId}`);
+        return this.backgroundSubagents.getForRoot(root, childRunId);
+    }
+    async cancelBackgroundWork(rootRunId, childRunId) {
+        const root = await this.state.getRun(rootRunId);
+        if (!root)
+            throw new Error(`Run not found: ${rootRunId}`);
+        return this.backgroundSubagents.cancelForRoot(root, childRunId);
+    }
     async readSubagent(childRunId, cursor) {
         return readSubagentImpl(this.subagentExecutionHost(), childRunId, cursor);
     }
@@ -1580,7 +1605,7 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
     async resumeRunFromContinuation(run, context) {
         return resumeRunFromContinuationImpl(this.replayResumeHost(), run, context);
     }
-    /** Start delivery, sandbox-sync, conversation-turn, background-review, and orphan-recovery workers. */
+    /** Start delivery, sandbox-sync, conversation-turn, subagent, background-review, and orphan-recovery workers. */
     startBackgroundWorkers(options = {}) {
         return startBackgroundWorkersImpl({
             env: this.env,
@@ -1589,6 +1614,7 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
             startDeliveryWorker: (workerOptions) => this.startDeliveryWorker(workerOptions),
             startSandboxSyncWorker: (workerOptions) => this.startSandboxSyncWorker(workerOptions),
             startConversationTurnWorker: (workerOptions) => this.conversationTurnDispatcher.startWorker(workerOptions?.intervalMs),
+            startBackgroundSubagentWorker: (workerOptions) => this.backgroundSubagents.startWorker(workerOptions?.intervalMs),
             startBackgroundReviewWorker: (workerOptions) => this.startBackgroundReviewWorker(workerOptions),
             startConnectionEventWorker: (workerOptions) => this.startConnectionEventWorker(workerOptions),
             recoverIncompleteRuns: (recoveryOptions) => this.recoverIncompleteRuns(recoveryOptions),
@@ -1725,8 +1751,8 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
     async instructionsForRunTarget(run, target, baseInstructions) {
         return instructionsForRunTargetImpl({ appendEvent: (runId, type, data) => this.state.appendEvent(runId, type, data), skillLoadDetails: (skillName) => this.skillLoadDetails(run, skillName) }, run, target, baseInstructions);
     }
-    async modelTools(run, activeToolNames, connectionRegistry, discoveredConnectionTools = new Map(), options) {
-        return modelToolsImpl(this.toolExecutionHost(), run, activeToolNames, connectionRegistry, discoveredConnectionTools, options);
+    async modelTools(run, activeToolNames, sandboxHandle, connectionRegistry, discoveredConnectionTools = new Map(), options) {
+        return modelToolsImpl(this.toolExecutionHost(), run, activeToolNames, sandboxHandle, connectionRegistry, discoveredConnectionTools, options);
     }
     async harnessExecuteTool(call, state) {
         return harnessExecuteToolImpl(this.toolExecutionHost(), call, state);
@@ -1863,6 +1889,7 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
             connectionAuthorizationSessionStore: this.connectionAuthorizationSessionStore,
             connectionCallbackBaseUrl: this.connectionCallbackBaseUrl,
             toolOutputMaxChars: this.toolOutputMaxChars,
+            authoredToolExecution: this.authoredToolExecution,
             toolTimeoutMs: this.toolTimeoutMs,
             sandboxSyncMaxAttempts: this.sandboxSyncMaxAttempts,
             skillsConfigForRun: (run) => this.skillsConfigForRun(run),
@@ -1870,6 +1897,9 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
             connectionsConfig: this.connectionsConfig,
             surfaceForRun: (run) => surfaceForRun(this.manifest, run),
             agentStateForRun: (runId) => this.agentStateForRun(runId),
+            reportRunProgress: async (runId, data = {}) => {
+                await this.state.appendEvent(runId, "run.progress_reported", data);
+            },
             ensureSkillsSeeded: (run) => this.ensureSkillsSeeded(surfaceForRun(this.manifest, run).path),
             skillScopeForRun: (run) => this.skillScopeForRun(run),
             scheduleScopeForRun: (run) => this.scheduleScopeForRun(run),
@@ -1878,7 +1908,15 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
             mergedConnections: () => this.mergedConnections(),
             loadConnectionDefinition: (connection) => this.loadConnectionDefinition(connection),
             loadTool: (tool, run) => this.loadTool(tool, run),
+            shouldSandboxAuthoredTool: (tool, run) => this.shouldSandboxAuthoredTool(tool, run),
+            describeSandboxedTool: (tool, sandboxHandle) => this.sandboxAuthoredToolExecutor.describe(tool, sandboxHandle),
+            executeSandboxedTool: (tool, input, context, sandboxHandle, signal) => this.sandboxAuthoredToolExecutor.execute(tool, input, context, sandboxHandle, signal),
             runSubagent: (parentRunId, subagentName, task) => this.runSubagent(parentRunId, subagentName, task),
+            queueSubagent: (parentRunId, subagentName, task) => this.queueSubagent(parentRunId, subagentName, task),
+            resumeSubagent: (parentRunId, childRunId, subagentName, message) => this.resumeSubagent(parentRunId, childRunId, subagentName, message),
+            listBackgroundWork: (rootRunId, includeTerminal) => this.listBackgroundWork(rootRunId, includeTerminal),
+            getBackgroundWork: (rootRunId, childRunId) => this.getBackgroundWork(rootRunId, childRunId),
+            cancelBackgroundWork: (rootRunId, childRunId) => this.cancelBackgroundWork(rootRunId, childRunId),
             projectSkillIntoSandbox: (run, sandbox, skillName) => this.projectSkillIntoSandbox(run, sandbox, skillName),
             hydrateLogicalPathForTool: (run, sandbox, path, options) => this.hydrateLogicalPathForTool(run, sandbox, path, options),
             recordSandboxTombstone: (run, sandbox, path) => this.recordSandboxTombstone(run, sandbox, path),
@@ -1908,10 +1946,24 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
         return selectToolImpl(this.toolExecutionHost(), options);
     }
     async executeTool(run, tool, input, sandboxHandle, approved, idempotencyKey) {
-        return executeToolImpl(this.toolExecutionHost(), run, tool, input, sandboxHandle, approved, idempotencyKey);
+        const abortController = new AbortController();
+        const unregisterAbort = this.runProgress.registerAbort(run.id, abortController);
+        try {
+            return await executeToolImpl(this.toolExecutionHost(), run, tool, input, sandboxHandle, approved, idempotencyKey, abortController.signal);
+        }
+        finally {
+            unregisterAbort();
+        }
     }
     async executeToolWithRecord(run, tool, toolCall, input, sandboxHandle, approvedToolCall = false) {
-        return executeToolWithRecordImpl(this.toolExecutionHost(), run, tool, toolCall, input, sandboxHandle, approvedToolCall);
+        const abortController = new AbortController();
+        const unregisterAbort = this.runProgress.registerAbort(run.id, abortController);
+        try {
+            return await executeToolWithRecordImpl(this.toolExecutionHost(), run, tool, toolCall, input, sandboxHandle, approvedToolCall, abortController.signal);
+        }
+        finally {
+            unregisterAbort();
+        }
     }
     async durableStep(runId, key, fn, options) {
         return durableStepImpl(this.toolExecutionHost(), runId, key, fn, options);
@@ -1980,94 +2032,38 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
             removeTerminalAgentHookState(runId, event, this.eventHandlers, this.agentHookControllers, this.agentStateHandles);
     }
     async handleRuntimeEvent(runId, event) {
+        if (eventRenewsRunProgress(event.type))
+            await this.runProgress.renew(runId);
         await this.dispatchHookEvent(runId, event);
         await this.runtimeLearning.handleRuntimeEvent(runId, event.type);
     }
     async createAgentHookController(run, options, channel, conversationId, attachments) {
-        const 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)
-        });
-        this.agentStateHandles.set(run.id, created.agentState);
-        this.agentHookControllers.set(run.id, created.controller);
-        return created.controller;
+        const created = await createMainAgentHookControllerImpl(this.agentHookControllerFactoryHost(), run, options, channel, conversationId, attachments);
+        return this.rememberAgentHookController(run.id, created);
     }
     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({
+        const created = await createSubagentHookControllerImpl(this.agentHookControllerFactoryHost(), run, subagent, message, conversationId);
+        return this.rememberAgentHookController(run.id, created);
+    }
+    agentHookControllerFactoryHost() {
+        return {
             manifest: this.manifest,
             state: this.state,
             blob: this.blob,
             sourceLoader: this.sourceLoader,
             eventHandlers: this.eventHandlers,
             logger: this.logger,
-            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),
+            durableAgentScope: () => this.durableAgentScope(),
+            listSkillNames: async (surfacePath) => (await this.listSkills(surfacePath)).map((skill) => skill.name).sort(),
+            disabledToolsForRun: () => new Set(Object.entries(this.coreToolPolicy).filter(([, mode]) => mode === "disabled").map(([name]) => name)),
             createCheckpoint: (input) => this.createCheckpoint(input),
             listCheckpoints: (runId) => this.listHydratedCheckpoints(runId)
-        });
-        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;
+    rememberAgentHookController(runId, created) {
+        this.agentStateHandles.set(runId, created.agentState);
+        this.agentHookControllers.set(runId, created.controller);
+        return created.controller;
     }
     agentStateForRun(runId) {
         const handle = this.agentStateHandles.get(runId);
@@ -2103,6 +2099,13 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
         const module = await this.sourceLoader.load(tool.source);
         return module.default;
     }
+    shouldSandboxAuthoredTool(tool, run) {
+        if (tool.source.path.startsWith("__builtin__"))
+            return false;
+        if (this.toolStubs[tool.name] || evalRunOptionsForRun(run)?.toolStubs?.[tool.name])
+            return false;
+        return this.authoredToolExecution === "sandbox" || tool.execution === "sandbox";
+    }
     async result(run, response, waitingForApproval, waitingForInput, waitingForConnection) {
         return buildRunAgentResult(this.state, run, response, waitingForApproval, waitingForInput, waitingForConnection);
     }