@assemblyline-agents/runtime 3.0.0 → 3.2.0

package/dist/index.js

@@ -10,10 +10,9 @@ 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 { 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 +23,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 +54,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 +64,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, 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,8 +94,8 @@ 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;
     state;
     runEventBus = new RunEventBus();
@@ -103,6 +105,8 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
     blob;
     sandbox;
     scheduler;
+    scheduleStore;
+    schedulesConfig;
     mediaProcessors;
     deliveryMode;
     toolStubs;
@@ -130,10 +134,8 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
     skillStore;
     learningStore;
     memoryStore;
-    scheduleStore;
     connectionDefinitionStore;
     skillsConfig;
-    schedulesConfig;
     connectionsConfig;
     runtimeLearning;
     connectionScopeMigrated = false;
@@ -159,6 +161,7 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
     outputValidationMaxRetries;
     runSemaphore;
     conversationTurnDispatcher;
+    backgroundSubagents;
     memoryEmbeddingProvider;
     memoryEmbeddingsEnabled;
     resourceProjectionPolicy;
@@ -177,10 +180,8 @@ 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;
@@ -286,7 +287,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 +306,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({
@@ -318,6 +328,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 +394,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 +498,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 +598,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 +771,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 +902,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 +963,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 +1068,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 +1126,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() {
@@ -1411,7 +1401,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 +1410,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 +1431,29 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
     async runSubagent(parentRunId, subagentName, task) {
         return runSubagentImpl(this.subagentExecutionHost(), parentRunId, subagentName, task);
     }
+    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 +1594,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 +1603,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),
@@ -1870,6 +1885,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),
@@ -1879,6 +1897,10 @@ export class AssemblyLineRuntime extends WorkspaceRuntimeMethods {
             loadConnectionDefinition: (connection) => this.loadConnectionDefinition(connection),
             loadTool: (tool, run) => this.loadTool(tool, run),
             runSubagent: (parentRunId, subagentName, task) => this.runSubagent(parentRunId, subagentName, task),
+            queueSubagent: (parentRunId, subagentName, task) => this.queueSubagent(parentRunId, subagentName, task),
+            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 +1930,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 +2016,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);