@fevex/core 0.1.0-alpha.4 → 0.1.0-alpha.6

package/dist/index.mjs

@@ -1,11 +1,13 @@
 import { defineAgent } from "./agents/index.mjs";
+import { a as CatalogedArtifactStore, c as assertArtifactId, i as FileSystemArtifactStore, n as InMemoryArtifactStore, o as ArtifactError, r as InMemoryArtifactCatalog, s as artifactTenantId, t as S3ArtifactStore } from "./artifacts-gUzemET7.mjs";
 import { n as RunPausedError, t as FevexRunError } from "./run-error-Cr17wPGH.mjs";
 import { ChannelError, deliverChannelRun, handleChannelInput } from "./channels/index.mjs";
 import { InMemoryMemoryStore, createMemoryContextProvider, defineContextProvider, defineSkill } from "./knowledge/index.mjs";
 import { n as teamAsWorkflow, t as defineTeam } from "./teams-Ctz676G4.mjs";
-import { InMemoryRunStore, isDurableRunStore, validateListEventsOptions } from "./runtime/index.mjs";
+import { InMemoryRunStore, isDurableRunStore, isRetainableRunStore, validateListEventsOptions, validatePurgeRunsOptions } from "./runtime/index.mjs";
 import { FEVEX_JSON_SCHEMA_PROFILE_VERSION, IntegrationError, compileFevexJsonSchema, defineConnection, defineTool, toToolSpec, validateFevexJsonSchemaProfile } from "./tools/index.mjs";
-import { a as assertTokenBudget, c as remainingOutputTokens, d as serializeValue, f as toJsonValue, i as assertContinuationBudget, l as toErrorMessage, n as abortable, o as cancellationReason, r as addUsage, s as eventUsage, t as readModelStream, u as serializeJsonValue } from "./model-stream-u2xMsEaf.mjs";
+import { _ as serializeValue, a as assertTokenBudget, c as eventUsage, d as remainingDeadlineMs, f as remainingOutputTokens, g as serializeJsonValue, h as toErrorMessage, i as assertContinuationBudget, l as isTimeoutError, m as runSignal, n as abortable, o as cancellationReason, p as resumeDeadlineSignal, r as addUsage, s as deadlineAtFromMs, u as minDeadline, v as toJsonValue } from "./run-support-CmZ6Xo6H.mjs";
+import { t as readModelStream } from "./model-stream-JQdHDDcj.mjs";
 import "./models/index.mjs";
 import { definePolicy } from "./policies/index.mjs";
 import { SandboxError, createLocalSandbox, sandboxResultToJson } from "./sandbox/index.mjs";
@@ -103,6 +105,9 @@ function isRunStore(value) {
 function isSandbox(value) {
 	return isRecord(value) && typeof value.run === "function";
 }
+function isArtifactStore(value) {
+	return (typeof value === "object" && value !== null || typeof value === "function") && typeof value.put === "function" && typeof value.get === "function";
+}
 function isJsonObject(value) {
 	return isRecord(value);
 }
@@ -300,7 +305,21 @@ function createComposition(config) {
 	assertConfiguration(config.runStore === void 0 || isRunStore(config.runStore), "INVALID_CONFIG", "Fevex config \"runStore\" must implement RunStore");
 	assertConfiguration(config.credentialStore === void 0 || typeof config.credentialStore?.resolve === "function", "INVALID_CONFIG", "Fevex config \"credentialStore\" must implement resolve");
 	assertConfiguration(config.sandbox === void 0 || isSandbox(config.sandbox), "INVALID_CONFIG", "Fevex config \"sandbox\" must implement Sandbox");
+	assertConfiguration(config.artifacts === void 0 || isArtifactStore(config.artifacts), "INVALID_CONFIG", "Fevex config \"artifacts\" must implement ArtifactStore");
 	assertConfiguration(config.policies === void 0 || Array.isArray(config.policies), "INVALID_CONFIG", "Fevex config \"policies\" must be an array");
+	if (config.admission !== void 0) {
+		assertConfiguration(isRecord(config.admission), "INVALID_CONFIG", "Fevex config \"admission\" must be an object");
+		for (const name of ["maxActiveRuns", "maxActiveRunsPerTenant"]) {
+			const value = config.admission[name];
+			assertConfiguration(value === void 0 || typeof value === "number" && Number.isSafeInteger(value) && value > 0, "INVALID_CONFIG", `Fevex config "admission.${name}" must be a positive safe integer`);
+		}
+		assertConfiguration(config.admission.tenantKey === void 0 || typeof config.admission.tenantKey === "function", "INVALID_CONFIG", "Fevex config \"admission.tenantKey\" must be a function");
+		assertConfiguration(config.admission.authorize === void 0 || typeof config.admission.authorize === "function", "INVALID_CONFIG", "Fevex config \"admission.authorize\" must be a function");
+	}
+	if (config.limits !== void 0) {
+		assertConfiguration(isRecord(config.limits), "INVALID_CONFIG", "Fevex config \"limits\" must be an object");
+		assertConfiguration(config.limits.maxEventsPerRun === void 0 || typeof config.limits.maxEventsPerRun === "number" && Number.isSafeInteger(config.limits.maxEventsPerRun) && config.limits.maxEventsPerRun > 0, "INVALID_CONFIG", "Fevex config \"limits.maxEventsPerRun\" must be a positive safe integer");
+	}
 	if (config.observability !== void 0) {
 		assertConfiguration(isRecord(config.observability), "INVALID_CONFIG", "Fevex config \"observability\" must be an object");
 		assertConfiguration(Array.isArray(config.observability.exporters) && config.observability.exporters.every((exporter) => isRecord(exporter) && typeof exporter.export === "function"), "INVALID_CONFIG", "Fevex config \"observability.exporters\" must contain TraceExporters");
@@ -313,6 +332,18 @@ function createComposition(config) {
 				"error.message"
 			].includes(kind)) && (content.redact === void 0 || typeof content.redact === "function"), "INVALID_CONFIG", "Fevex config \"observability.content\" is invalid");
 		}
+		if (config.observability.exportQueue !== void 0) {
+			const queue = config.observability.exportQueue;
+			assertConfiguration(isRecord(queue) && [
+				"concurrency",
+				"maxQueued",
+				"timeoutMs",
+				"maxFailures"
+			].every((key) => {
+				const value = queue[key];
+				return value === void 0 || typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+			}), "INVALID_CONFIG", "Fevex config \"observability.exportQueue\" must contain positive safe integers");
+		}
 	}
 	const models = /* @__PURE__ */ new Map();
 	const agents = /* @__PURE__ */ new Map();
@@ -594,15 +625,19 @@ function createComposition(config) {
 		runStore: config.runStore ?? new InMemoryRunStore(),
 		credentialStore: config.credentialStore,
 		sandbox: config.sandbox,
+		artifacts: config.artifacts,
 		policies,
 		onEvent: config.onEvent,
+		admission: config.admission === void 0 ? void 0 : { ...config.admission },
+		limits: config.limits === void 0 ? void 0 : { ...config.limits },
 		observability: config.observability === void 0 ? void 0 : {
 			exporters: [...config.observability.exporters],
 			...config.observability.calculateCost ? { calculateCost: config.observability.calculateCost } : {},
 			...config.observability.content ? { content: {
 				include: [...config.observability.content.include],
 				...config.observability.content.redact ? { redact: config.observability.content.redact } : {}
-			} } : {}
+			} } : {},
+			...config.observability.exportQueue ? { exportQueue: { ...config.observability.exportQueue } } : {}
 		}
 	};
 }
@@ -732,6 +767,7 @@ const toolErrorPayload = (tool, error) => ({
 	} : {}
 });
 const runErrorPayload = (error) => {
+	if (error instanceof FevexRunError) return { errorCode: error.code };
 	if (!(error instanceof IntegrationError)) return {};
 	return {
 		errorCode: error.code,
@@ -866,9 +902,10 @@ function addWorkflowBudget(first, second) {
 * engine — that direction is what keeps the two separable.
 */
 function createAgentEngine(composition, core) {
-	const { models, agents, tools, contextProviders, memoryStore, runStore, credentialStore, sandbox, policies } = composition;
-	const { activeRuns, activeSessions, runtimeOwner, resolveModel, resolveCheckpointModel, notifyObserver, createEvent, emitEvent, releaseExecution, commit, startLease, cancelExecution, authorize } = core;
-	const prepareExecution = async (name, request) => {
+	const { models, agents, tools, contextProviders, memoryStore, runStore, credentialStore, sandbox, artifacts, policies } = composition;
+	const { activeRuns, activeSessions, runtimeOwner, isClosed, admitStart, markInternalRun, resolveModel, resolveCheckpointModel, notifyObserver, createEvent, emitEvent, releaseExecution, commit, startLease, cancelExecution, authorize } = core;
+	const prepareExecutionBody = async (name, request, internal = false, correlation = {}) => {
+		if (!internal && isClosed()) throw new FevexRunError("RUNTIME_CLOSED", "Runtime is not accepting new runs");
 		const agent = agents.get(name);
 		if (!agent) throw new FevexRunError("AGENT_NOT_FOUND", `Agent "${name}" is not registered`);
 		const { modelName, model } = resolveModel(agent, request.model);
@@ -887,20 +924,25 @@ function createAgentEngine(composition, core) {
 			session = stored;
 		}
 		if (activeSessions.has(session.id)) throw new FevexRunError("RUN_CONFLICT", `Session "${session.id}" already has an active run`);
-		activeSessions.add(session.id);
 		const controller = new AbortController();
-		const signal = request.signal ? AbortSignal.any([controller.signal, request.signal]) : controller.signal;
+		const signal = runSignal(controller, request);
+		const deadlineAt = deadlineAtFromMs(request.deadlineMs);
+		activeSessions.add(session.id);
 		const run = {
 			id: crypto.randomUUID(),
 			sessionId: session.id,
 			agentName: name,
 			modelName,
 			...model.metadata === void 0 ? {} : { modelMetadata: structuredClone(model.metadata) },
+			...correlation.parentRunId === void 0 ? {} : { parentRunId: correlation.parentRunId },
+			...correlation.rootRunId === void 0 ? {} : { rootRunId: correlation.rootRunId },
 			status: "running",
 			revision: 0,
 			createdAt: now,
-			updatedAt: now
+			updatedAt: now,
+			...deadlineAt === void 0 ? {} : { deadlineAt }
 		};
+		if (internal) markInternalRun(run.id);
 		const state = {
 			run,
 			session,
@@ -981,6 +1023,17 @@ function createAgentEngine(composition, core) {
 		activeRuns.set(run.id, state);
 		return state;
 	};
+	const prepareExecution = async (name, request, options = {}) => {
+		const release = options.admit === false ? void 0 : await admitStart("agent", name, request);
+		try {
+			return await prepareExecutionBody(name, request, options.admit === false, {
+				...options.parentRunId === void 0 ? {} : { parentRunId: options.parentRunId },
+				...options.rootRunId === void 0 ? {} : { rootRunId: options.rootRunId }
+			});
+		} finally {
+			release?.();
+		}
+	};
 	const durableCheckpoint = async (state, model, modelName, messages, inputContent, usage, providerState, step, toolCallCount, seenToolCallIds, pendingTools, pendingIndex) => {
 		const agent = agents.get(state.run.agentName);
 		if (agent.model !== void 0 && typeof agent.model !== "string") throw new FevexRunError("RUN_NOT_RESUMABLE", "Durable continuation requires a named model", state.run.id);
@@ -1519,6 +1572,20 @@ function createAgentEngine(composition, core) {
 						}
 						events.push(started);
 						yield started;
+						const createdArtifacts = [];
+						const toolArtifacts = artifacts === void 0 ? void 0 : scopedArtifacts(artifacts, {
+							runId: state.run.id,
+							sessionId: state.session.id,
+							request,
+							emit: async (descriptor) => {
+								createdArtifacts.push(await emit("artifact.created", {
+									descriptor,
+									toolCallId: pending.call.id,
+									toolName: pending.call.name,
+									...toolSourcePayload(tool)
+								}));
+							}
+						});
 						try {
 							const raw = await abortable(() => tool.execute(pending.input, {
 								runId: state.run.id,
@@ -1527,9 +1594,11 @@ function createAgentEngine(composition, core) {
 								idempotencyKey: pending.idempotencyKey,
 								getCredential,
 								...scopedSandbox === void 0 ? {} : { sandbox: scopedSandbox },
+								...toolArtifacts === void 0 ? {} : { artifacts: toolArtifacts },
 								context: request.context,
 								signal: request.signal
 							}), request.signal);
+							for (const event of createdArtifacts.splice(0)) yield event;
 							output = toJsonValue(tool.outputSchema === void 0 ? raw : await validateSchema(tool.outputSchema, raw, `Output from tool "${tool.name}" does not match outputSchema`), `Output from tool "${tool.name}" must be JSON-serializable`);
 							if (containsSecret(output, secrets)) throw new Error(`Output from tool "${tool.name}" contains a credential`);
 							record = {
@@ -1557,6 +1626,7 @@ function createAgentEngine(composition, core) {
 							yield completed;
 							break;
 						} catch (error) {
+							for (const event of createdArtifacts.splice(0)) yield event;
 							if (request.signal.aborted) throw error;
 							const safeError = redact(toErrorMessage(error), secrets);
 							record = {
@@ -1664,7 +1734,7 @@ function createAgentEngine(composition, core) {
 			}
 		}
 	};
-	const resumeAgent = async (runId, resolution, waitForCompletion = false, recoveryActor) => {
+	const resumeAgentBody = async (runId, resolution, waitForCompletion = false, recoveryActor) => {
 		if (resolution?.type === "timer" || resolution?.type === "event") throw new FevexRunError("RUN_NOT_RESUMABLE", `Run "${runId}" cannot be resumed`, runId);
 		if (!isDurableRunStore(runStore)) throw new FevexRunError("DURABLE_STORE_REQUIRED", "resumeRun requires DurableRunStore", runId);
 		const run = await runStore.getRun(runId);
@@ -1672,6 +1742,11 @@ function createAgentEngine(composition, core) {
 		if (!run || !checkpoint) throw new FevexRunError(resolution ? "RUN_NOT_RESUMABLE" : "RUN_NOT_RECOVERABLE", `Run "${runId}" cannot be ${resolution ? "resumed" : "recovered"}`, runId);
 		if (checkpoint.version !== 2) throw new FevexRunError("CHECKPOINT_UNSUPPORTED", `Checkpoint for run "${runId}" is unsupported`, runId);
 		if (resolution && run.status !== "paused" && run.status !== "running" || !resolution && run.status !== "running") throw new FevexRunError(resolution ? "RUN_NOT_RESUMABLE" : "RUN_NOT_RECOVERABLE", `Run "${runId}" is not ${resolution ? "resumable" : "recoverable"}`, runId);
+		if (run.deadlineAt !== void 0 && Date.parse(run.deadlineAt) <= Date.now()) {
+			if (!await cancelStoredAgent(runId, "timeout")) throw new FevexRunError(resolution ? "RUN_NOT_RESUMABLE" : "RUN_NOT_RECOVERABLE", `Run "${runId}" deadline has passed`, runId);
+			return await runStore.getRun(runId);
+		}
+		const deadlineSignal = resumeDeadlineSignal(run.deadlineAt, runId, resolution ? "RUN_NOT_RESUMABLE" : "RUN_NOT_RECOVERABLE");
 		const agent = agents.get(run.agentName);
 		if (!agent) throw new FevexRunError("RUN_DEFINITION_CHANGED", `Agent "${run.agentName}" is unavailable`, runId);
 		const checkpointModel = await resolveCheckpointModel(run.agentName, agent, checkpoint);
@@ -1695,6 +1770,7 @@ function createAgentEngine(composition, core) {
 		if (!await runStore.acquireLease(lease)) throw new FevexRunError("RUN_CONFLICT", `Run "${runId}" is leased`, runId);
 		try {
 			const controller = new AbortController();
+			const signal = deadlineSignal ? AbortSignal.any([controller.signal, deadlineSignal]) : controller.signal;
 			const state = {
 				run,
 				session,
@@ -1705,7 +1781,7 @@ function createAgentEngine(composition, core) {
 					sessionId: session.id,
 					context: checkpoint.context,
 					limits: checkpoint.limits,
-					signal: controller.signal
+					signal
 				},
 				controller,
 				eventSequence: (await runStore.listEvents(runId)).at(-1)?.sequence ?? 0,
@@ -1874,10 +1950,27 @@ function createAgentEngine(composition, core) {
 			throw error;
 		}
 	};
-	const cancelStoredAgent = async (runId) => {
+	const resumeAgent = async (runId, resolution, waitForCompletion = false, recoveryActor, options = {}) => {
+		let release;
+		if (options.admit !== false) {
+			const run = await runStore.getRun(runId);
+			const checkpoint = isDurableRunStore(runStore) ? await runStore.getCheckpoint(runId) : void 0;
+			if (run && checkpoint && (run.status === "paused" || run.status === "running")) release = await admitStart("agent", run.agentName, {
+				input: "",
+				...checkpoint.context === void 0 ? {} : { context: checkpoint.context }
+			});
+		}
+		try {
+			if (options.internal) markInternalRun(runId);
+			return await resumeAgentBody(runId, resolution, waitForCompletion, recoveryActor);
+		} finally {
+			release?.();
+		}
+	};
+	const cancelStoredAgent = async (runId, reason = "aborted") => {
 		const active = activeRuns.get(runId);
 		if (active && !active.request.signal.aborted) {
-			active.controller.abort(new DOMException("Run cancelled", "AbortError"));
+			active.controller.abort(new DOMException(reason === "timeout" ? "Run deadline exceeded" : "Run cancelled", reason === "timeout" ? "TimeoutError" : "AbortError"));
 			if (!active.advancing) {
 				await cancelExecution(active);
 				return true;
@@ -1920,8 +2013,8 @@ function createAgentEngine(composition, core) {
 			};
 			run.status = "cancelled";
 			run.pause = void 0;
-			run.error = "aborted";
-			const cancelled = createEvent(state, "run.cancelled", { reason: "aborted" });
+			run.error = reason;
+			const cancelled = createEvent(state, "run.cancelled", { reason });
 			await commit(state, {
 				checkpoint: null,
 				events: [cancelled]
@@ -1943,21 +2036,67 @@ function createAgentEngine(composition, core) {
 		cancelStoredAgent
 	};
 }
+function scopedArtifacts(store, options) {
+	const scopedContext = (value) => {
+		const contextTenant = options.request.context?.attributes?.tenantId;
+		const tenantId = typeof contextTenant === "string" ? contextTenant : value?.tenantId;
+		const actor = options.request.context?.actor;
+		return {
+			...value,
+			runId: options.runId,
+			sessionId: options.sessionId,
+			...tenantId === void 0 ? {} : { tenantId },
+			...actor === void 0 ? {} : { actor },
+			signal: options.request.signal
+		};
+	};
+	return {
+		async put(input, context) {
+			const descriptor = await store.put(input, scopedContext(context));
+			await options.emit(descriptor);
+			return descriptor;
+		},
+		get(artifactId, context) {
+			return store.get(artifactId, scopedContext(context));
+		},
+		...store.head === void 0 ? {} : { head(artifactId, context) {
+			return store.head(artifactId, scopedContext(context));
+		} },
+		...store.delete === void 0 ? {} : { delete(artifactId, context) {
+			return store.delete(artifactId, scopedContext(context));
+		} }
+	};
+}
 //#endregion
 //#region src/internal/observability.ts
 const TERMINAL_TYPES = /* @__PURE__ */ new Set([
 	"run.completed",
 	"run.failed",
-	"run.cancelled"
+	"run.cancelled",
+	"workflow.run.completed",
+	"workflow.run.failed",
+	"workflow.run.cancelled",
+	"team.run.completed",
+	"team.run.failed",
+	"team.run.cancelled"
 ]);
 const SENSITIVE_KEY = /api[-_]?key|authorization|cookie|credential|password|secret|token/i;
+function isTraceTerminalEvent(event) {
+	return TERMINAL_TYPES.has(event.type);
+}
 function durationMs(startedAt, endedAt) {
 	return Math.max(0, Date.parse(endedAt) - Date.parse(startedAt));
 }
 function traceStatus(event) {
-	if (event.type === "run.completed") return "completed";
-	if (event.type === "run.cancelled") return "cancelled";
-	return "failed";
+	switch (event.type) {
+		case "run.completed":
+		case "workflow.run.completed":
+		case "team.run.completed": return "completed";
+		case "run.cancelled":
+		case "workflow.run.cancelled":
+		case "team.run.cancelled": return "cancelled";
+		default: return "failed";
+	}
 }
 function redactKeys(value) {
 	if (Array.isArray(value)) return value.map(redactKeys);
@@ -2064,20 +2203,74 @@ function annotation(event) {
 				toolName: event.payload.toolName
 			}
 		};
+		case "workflow.run.paused":
+		case "team.run.paused": {
+			const stepId = event.type === "workflow.run.paused" ? event.payload.stepId : event.payload.delegationId;
+			return {
+				name: event.type,
+				timestamp: event.timestamp,
+				attributes: {
+					stepId,
+					reason: event.payload.reason,
+					...event.payload.childRunId === void 0 ? {} : { childRunId: event.payload.childRunId }
+				}
+			};
+		}
+		case "workflow.run.resumed":
+		case "team.run.resumed": return {
+			name: event.type,
+			timestamp: event.timestamp
+		};
+		case "team.handoff.created": return {
+			name: event.type,
+			timestamp: event.timestamp,
+			attributes: {
+				delegationId: event.payload.delegationId,
+				from: event.payload.from,
+				to: event.payload.to,
+				reason: event.payload.reason
+			}
+		};
 		default: return;
 	}
 }
-function buildRunTrace(run, rawEvents, modelRegistryName, model, options) {
-	const events = [...rawEvents].sort((left, right) => left.sequence - right.sequence);
-	const terminal = [...events].reverse().find((event) => TERMINAL_TYPES.has(event.type));
-	if (!terminal) throw new TypeError(`Run "${run.id}" has no terminal event`);
-	const started = events.find((event) => event.type === "run.started") ?? events[0];
-	if (!started) throw new TypeError(`Run "${run.id}" has no events`);
+function terminalContent(options, terminal) {
+	if (terminal.type === "run.completed" || terminal.type === "workflow.run.completed" || terminal.type === "team.run.completed") {
+		const output = content(options, "run.output", terminal.payload.output);
+		return output ? [output] : [];
+	}
+	if (terminal.type === "run.failed" || terminal.type === "workflow.run.failed" || terminal.type === "team.run.failed") {
+		const error = content(options, "error.message", terminal.payload.error);
+		return error ? [error] : [];
+	}
+	return [];
+}
+function sortedEvents(rawEvents) {
+	return [...rawEvents].sort((left, right) => left.sequence - right.sequence);
+}
+function terminalEvent(runId, events) {
+	const terminal = [...events].reverse().find((event) => isTraceTerminalEvent(event));
+	if (!terminal) throw new TypeError(`Run "${runId}" has no terminal event`);
+	return terminal;
+}
+function startEvent(events) {
+	const started = events.find((event) => event.type === "run.started" || event.type === "workflow.run.started" || event.type === "team.run.started") ?? events[0];
+	if (!started) throw new TypeError("Run has no events");
+	return started;
+}
+function traceKind(run) {
+	if (isTeamRun(run)) return "team";
+	return run.kind === "workflow" ? "workflow" : "agent";
+}
+function buildAgentTrace(run, events, modelRegistryName, model, options) {
+	const terminal = terminalEvent(run.id, events);
+	const started = startEvent(events);
 	const status = traceStatus(terminal);
 	const annotations = [];
 	const spans = [];
 	const openModels = /* @__PURE__ */ new Map();
 	const openTools = /* @__PURE__ */ new Map();
+	const modelSpanByStep = /* @__PURE__ */ new Map();
 	const previousUsage = {};
 	const closeModel = (step, endedAt, spanStatus) => {
 		const open = openModels.get(step);
@@ -2108,6 +2301,7 @@ function buildRunTrace(run, rawEvents, modelRegistryName, model, options) {
 		const spanCost = costFor(options, modelRegistryName, model, usage);
 		if (spanCost) span.cost = spanCost;
 		spans.push(span);
+		modelSpanByStep.set(step, span.id);
 	};
 	const findOpenTool = (toolCallId) => {
 		const entries = [...openTools.entries()];
@@ -2127,7 +2321,7 @@ function buildRunTrace(run, rawEvents, modelRegistryName, model, options) {
 		const errorContent = error ? content(options, "error.message", error) : void 0;
 		spans.push({
 			id: event.id,
-			parentId: run.id,
+			parentId: modelSpanByStep.get(event.payload.step) ?? run.id,
 			kind: "tool",
 			name: event.payload.toolName,
 			startedAt: event.timestamp,
@@ -2192,19 +2386,15 @@ function buildRunTrace(run, rawEvents, modelRegistryName, model, options) {
 	for (const open of [...openTools.values()]) if (open.event.type === "tool.started") closeTool(open.event.payload.toolCallId, terminal.timestamp, status);
 	const finalUsage = run.usage ?? previousUsage;
 	const totalCost = costFor(options, modelRegistryName, model, finalUsage);
-	const traceContent = [];
-	if (terminal.type === "run.completed") {
-		const output = content(options, "run.output", terminal.payload.output);
-		if (output) traceContent.push(output);
-	} else if (terminal.type === "run.failed") {
-		const error = content(options, "error.message", terminal.payload.error);
-		if (error) traceContent.push(error);
-	}
+	const traceContent = terminalContent(options, terminal);
 	return {
 		schemaVersion: "1",
+		kind: "agent",
 		traceId: run.id,
 		runId: run.id,
 		sessionId: run.sessionId,
+		...run.parentRunId === void 0 ? {} : { parentRunId: run.parentRunId },
+		rootRunId: run.rootRunId ?? run.parentRunId ?? run.id,
 		agentName: run.agentName,
 		modelRegistryName,
 		...model ? { model: { ...model } } : {},
@@ -2224,6 +2414,249 @@ function buildRunTrace(run, rawEvents, modelRegistryName, model, options) {
 		...traceContent.length ? { content: traceContent } : {}
 	};
 }
+function buildCoordinatorTrace(run, events, options) {
+	const terminal = terminalEvent(run.id, events);
+	const started = startEvent(events);
+	const status = traceStatus(terminal);
+	const annotations = [];
+	const spans = [];
+	const openSteps = /* @__PURE__ */ new Map();
+	const stepKey = (scope, stepId) => `${scope}:${stepId}`;
+	const modelCallCount = events.filter(({ type }) => type === "model.completed").length;
+	const toolCallCount = events.filter(({ type }) => type === "tool.completed" || type === "tool.failed").length;
+	const openStep = (key, event, name, attributes) => {
+		openSteps.set(key, {
+			event,
+			name,
+			attributes
+		});
+	};
+	const closeStep = (key, endedAt, spanStatus, error) => {
+		const open = openSteps.get(key);
+		if (!open) return;
+		openSteps.delete(key);
+		const errorContent = error ? content(options, "error.message", error) : void 0;
+		spans.push({
+			id: open.event.id,
+			parentId: run.id,
+			kind: "step",
+			name: open.name,
+			startedAt: open.event.timestamp,
+			endedAt,
+			durationMs: durationMs(open.event.timestamp, endedAt),
+			status: spanStatus,
+			attributes: open.attributes,
+			annotations: [],
+			...errorContent ? { content: [errorContent] } : {}
+		});
+	};
+	for (const event of events) {
+		const item = annotation(event);
+		if (item) annotations.push(item);
+		switch (event.type) {
+			case "workflow.step.started":
+				openStep(stepKey("workflow", event.payload.stepId), event, event.payload.stepId, {
+					stepId: event.payload.stepId,
+					stepKind: event.payload.kind,
+					...event.payload.agentName === void 0 ? {} : { agentName: event.payload.agentName },
+					...event.payload.childRunId === void 0 ? {} : { childRunId: event.payload.childRunId }
+				});
+				break;
+			case "workflow.step.completed":
+				closeStep(stepKey("workflow", event.payload.stepId), event.timestamp, "completed");
+				break;
+			case "workflow.step.failed":
+				closeStep(stepKey("workflow", event.payload.stepId), event.timestamp, "failed", event.payload.error);
+				break;
+			case "workflow.wait.started":
+				openStep(stepKey("workflow", event.payload.stepId), event, event.payload.stepId, {
+					stepId: event.payload.stepId,
+					stepKind: "wait",
+					waitKind: event.payload.kind,
+					...event.payload.resumeAt === void 0 ? {} : { resumeAt: event.payload.resumeAt },
+					...event.payload.eventName === void 0 ? {} : { eventName: event.payload.eventName }
+				});
+				break;
+			case "workflow.wait.completed":
+				closeStep(stepKey("workflow", event.payload.stepId), event.timestamp, "completed");
+				break;
+			case "team.agent.assigned":
+				openStep(stepKey("team", event.payload.delegationId), event, event.payload.delegationId, {
+					stepId: event.payload.delegationId,
+					stepKind: "agent",
+					agentName: event.payload.agentName,
+					action: event.payload.action,
+					...event.payload.expectedOutput === void 0 ? {} : { expectedOutput: event.payload.expectedOutput },
+					...event.payload.constraints === void 0 ? {} : { constraints: event.payload.constraints },
+					...event.payload.childRunId === void 0 ? {} : { childRunId: event.payload.childRunId }
+				});
+				break;
+			case "team.task.completed":
+				closeStep(stepKey("team", event.payload.delegationId), event.timestamp, "completed");
+				break;
+			case "team.task.failed":
+				closeStep(stepKey("team", event.payload.delegationId), event.timestamp, "failed", event.payload.error);
+				break;
+			case "team.merge.started":
+				openStep(stepKey("team", event.payload.stepId), event, event.payload.stepId, {
+					stepId: event.payload.stepId,
+					stepKind: "merge",
+					width: event.payload.width
+				});
+				break;
+			case "team.merge.completed":
+				closeStep(stepKey("team", event.payload.stepId), event.timestamp, "completed");
+				break;
+			case "team.merge.failed":
+				closeStep(stepKey("team", event.payload.stepId), event.timestamp, "failed", event.payload.error);
+				break;
+		}
+	}
+	for (const key of [...openSteps.keys()]) closeStep(key, terminal.timestamp, status);
+	const traceContent = terminalContent(options, terminal);
+	return {
+		schemaVersion: "1",
+		kind: traceKind(run),
+		traceId: run.id,
+		runId: run.id,
+		sessionId: run.sessionId,
+		...run.parentRunId === void 0 ? {} : { parentRunId: run.parentRunId },
+		rootRunId: run.rootRunId ?? run.parentRunId ?? run.id,
+		agentName: coordinatorName(run),
+		startedAt: started.timestamp,
+		endedAt: terminal.timestamp,
+		durationMs: durationMs(started.timestamp, terminal.timestamp),
+		status,
+		attributes: {
+			eventCount: events.length,
+			stepCount: spans.filter(({ kind }) => kind === "step").length,
+			modelCallCount,
+			toolCallCount
+		},
+		annotations,
+		spans,
+		...run.usage && Object.keys(run.usage).length ? { usage: { ...run.usage } } : {},
+		...traceContent.length ? { content: traceContent } : {}
+	};
+}
+function buildRunTrace(run, rawEvents, modelRegistryName, model, options) {
+	const events = sortedEvents(rawEvents);
+	if (isCoordinatorRun(run)) return buildCoordinatorTrace(run, events, options);
+	if (!modelRegistryName) throw new TypeError(`Run "${run.id}" has no model registry name`);
+	return buildAgentTrace(run, events, modelRegistryName, model, options);
+}
+//#endregion
+//#region src/internal/trace-export.ts
+const DEFAULT_CONCURRENCY = 4;
+const DEFAULT_MAX_QUEUED = 100;
+const DEFAULT_TIMEOUT_MS = 3e4;
+const DEFAULT_MAX_FAILURES = 100;
+const DEDUPE_WINDOW = 1e4;
+function withTimeout(promise, timeoutMs, message) {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+		promise.then((value) => {
+			clearTimeout(timer);
+			resolve(value);
+		}, (error) => {
+			clearTimeout(timer);
+			reject(error);
+		});
+	});
+}
+function withDefault(value, fallback) {
+	return value ?? fallback;
+}
+/**
+* Bounded, deduplicated trace export queue. Jobs include building the trace
+* from the store, so a slow store or exporter cannot grow memory without limit.
+*/
+function createTraceExportQueue(options = {}) {
+	const concurrency = withDefault(options.concurrency, DEFAULT_CONCURRENCY);
+	const maxQueued = withDefault(options.maxQueued, DEFAULT_MAX_QUEUED);
+	const timeoutMs = withDefault(options.timeoutMs, DEFAULT_TIMEOUT_MS);
+	const maxFailures = withDefault(options.maxFailures, DEFAULT_MAX_FAILURES);
+	const queue = [];
+	const pending = /* @__PURE__ */ new Set();
+	const exportedRuns = /* @__PURE__ */ new Set();
+	const failures = [];
+	let active = 0;
+	let exported = 0;
+	let failed = 0;
+	let dropped = 0;
+	let unreported = 0;
+	const rememberRun = (runId) => {
+		if (exportedRuns.has(runId)) return false;
+		if (exportedRuns.size >= DEDUPE_WINDOW) {
+			const oldest = exportedRuns.values().next().value;
+			if (oldest !== void 0) exportedRuns.delete(oldest);
+		}
+		exportedRuns.add(runId);
+		return true;
+	};
+	const recordFailure = (error) => {
+		failed += 1;
+		unreported += 1;
+		failures.push(error);
+		if (failures.length > maxFailures) failures.shift();
+	};
+	const startNext = () => {
+		while (active < concurrency && queue.length) {
+			const task = queue.shift();
+			active += 1;
+			let job;
+			job = Promise.resolve().then(task).then(() => {
+				exported += 1;
+			}, (error) => {
+				recordFailure(error);
+			}).finally(() => {
+				active -= 1;
+				pending.delete(job);
+				startNext();
+			});
+			pending.add(job);
+		}
+	};
+	return {
+		timeoutMs,
+		enqueue(runId, task) {
+			if (!rememberRun(runId)) return;
+			if (queue.length >= maxQueued) {
+				dropped += 1;
+				recordFailure(/* @__PURE__ */ new Error(`Observability export queue is full; trace for run "${runId}" was dropped`));
+				return;
+			}
+			queue.push(task);
+			startNext();
+		},
+		async flush(flushOptions) {
+			const timeout = flushOptions?.timeoutMs;
+			if (timeout !== void 0 && (typeof timeout !== "number" || !Number.isSafeInteger(timeout) || timeout <= 0)) throw new Error("Observability flush timeoutMs must be a positive safe integer");
+			const drain = async () => {
+				while (pending.size) await Promise.all([...pending]);
+			};
+			if (timeout === void 0) await drain();
+			else await withTimeout(drain(), timeout, `Observability flush timed out after ${timeout}ms`);
+			if (unreported === 0) return;
+			const errors = [...failures];
+			const omitted = unreported - failures.length;
+			if (omitted > 0) errors.push(/* @__PURE__ */ new Error(`${omitted} additional export failures were not retained`));
+			failures.length = 0;
+			unreported = 0;
+			throw new AggregateError(errors, `Observability export failed (${failed} failure(s), ${dropped} dropped trace(s))`);
+		},
+		stats() {
+			return {
+				exported,
+				failed,
+				dropped,
+				queued: queue.length,
+				active,
+				retainedFailures: failures.length
+			};
+		}
+	};
+}
 //#endregion
 //#region src/internal/run-core.ts
 /**
@@ -2236,14 +2669,118 @@ function buildRunTrace(run, rawEvents, modelRegistryName, model, options) {
 * the lease table, so a second instance would corrupt event ordering and lease
 * ownership without raising an error.
 */
-function createRunCore({ models, agents, tools, runStore, policies, onEvent, observability }) {
+function createRunCore({ models, agents, tools, runStore, policies, onEvent, observability, admission, limits }) {
 	const activeRuns = /* @__PURE__ */ new Map();
 	const activeWorkflowRuns = /* @__PURE__ */ new Map();
 	const activeSessions = /* @__PURE__ */ new Set();
-	const pendingExports = /* @__PURE__ */ new Set();
-	const exportFailures = [];
-	const exportedRuns = /* @__PURE__ */ new Set();
+	const internalRuns = /* @__PURE__ */ new Set();
+	const pendingTenantStarts = /* @__PURE__ */ new Map();
+	const idleWaiters = /* @__PURE__ */ new Set();
+	let pendingStarts = 0;
+	let closed = false;
+	const traceExports = createTraceExportQueue(observability?.exportQueue);
 	const runtimeOwner = crypto.randomUUID();
+	const isIdle = () => activeRuns.size === 0 && activeWorkflowRuns.size === 0;
+	const notifyIdle = () => {
+		if (!isIdle()) return;
+		for (const resolve of idleWaiters) resolve();
+		idleWaiters.clear();
+	};
+	const waitForIdle = () => {
+		if (isIdle()) return Promise.resolve();
+		return new Promise((resolve) => idleWaiters.add(resolve));
+	};
+	const closeAdmission = () => {
+		closed = true;
+	};
+	const isClosed = () => closed;
+	const unboundedEvents = /* @__PURE__ */ new Set([
+		"run.started",
+		"run.recovered",
+		"run.paused",
+		"run.resumed",
+		"elicitation.requested",
+		"elicitation.resolved",
+		"approval.requested",
+		"approval.resolved",
+		"tool.execution_unknown",
+		"run.completed",
+		"run.failed",
+		"run.cancelled",
+		"workflow.run.started",
+		"workflow.run.recovered",
+		"workflow.run.paused",
+		"workflow.run.resumed",
+		"workflow.wait.started",
+		"workflow.wait.completed",
+		"workflow.run.completed",
+		"workflow.run.failed",
+		"workflow.run.cancelled",
+		"team.run.started",
+		"team.run.recovered",
+		"team.run.paused",
+		"team.run.resumed",
+		"team.run.completed",
+		"team.run.failed",
+		"team.run.cancelled"
+	]);
+	const tenantOf = (context) => {
+		const configured = admission?.tenantKey?.(context);
+		if (configured !== void 0) return configured;
+		const tenantId = context?.attributes?.tenantId;
+		if (typeof tenantId !== "string") return void 0;
+		return tenantId.trim() || void 0;
+	};
+	const countsForAdmission = (runId, state) => !internalRuns.has(runId) && !state.request.signal?.aborted;
+	const activeTopLevelRuns = () => {
+		let count = 0;
+		for (const [runId, state] of activeRuns) if (countsForAdmission(runId, state)) count += 1;
+		for (const [runId, state] of activeWorkflowRuns) if (countsForAdmission(runId, state)) count += 1;
+		return count;
+	};
+	const activeTenantRuns = (tenant) => {
+		let count = 0;
+		for (const [runId, state] of activeRuns) if (countsForAdmission(runId, state) && tenantOf(state.request.context) === tenant) count += 1;
+		for (const [runId, state] of activeWorkflowRuns) if (countsForAdmission(runId, state) && tenantOf(state.request.context) === tenant) count += 1;
+		return count;
+	};
+	const admitStart = async (kind, name, request) => {
+		if (closed) throw new FevexRunError("RUNTIME_CLOSED", "Runtime is not accepting new runs");
+		if (!admission) return () => {};
+		const running = activeTopLevelRuns() + pendingStarts;
+		const tenant = tenantOf(request.context);
+		const tenantRuns = tenant === void 0 ? 0 : activeTenantRuns(tenant) + (pendingTenantStarts.get(tenant) ?? 0);
+		if (admission.maxActiveRuns !== void 0 && running >= admission.maxActiveRuns) throw new FevexRunError("ADMISSION_DENIED", `Runtime reached maxActiveRuns limit of ${admission.maxActiveRuns}`);
+		if (admission.maxActiveRunsPerTenant !== void 0 && tenant !== void 0 && tenantRuns >= admission.maxActiveRunsPerTenant) throw new FevexRunError("ADMISSION_DENIED", `Tenant "${tenant}" reached maxActiveRunsPerTenant limit of ${admission.maxActiveRunsPerTenant}`);
+		pendingStarts += 1;
+		if (tenant !== void 0) pendingTenantStarts.set(tenant, (pendingTenantStarts.get(tenant) ?? 0) + 1);
+		let released = false;
+		const release = () => {
+			if (released) return;
+			released = true;
+			pendingStarts = Math.max(0, pendingStarts - 1);
+			if (tenant === void 0) return;
+			const next = (pendingTenantStarts.get(tenant) ?? 1) - 1;
+			if (next <= 0) pendingTenantStarts.delete(tenant);
+			else pendingTenantStarts.set(tenant, next);
+		};
+		try {
+			if (admission.authorize && !await admission.authorize({
+				kind,
+				name,
+				request,
+				activeRuns: running,
+				activeTenantRuns: tenantRuns
+			})) throw new FevexRunError("ADMISSION_DENIED", "Run admission was denied by the host");
+		} catch (error) {
+			release();
+			throw error;
+		}
+		return release;
+	};
+	const markInternalRun = (runId) => {
+		internalRuns.add(runId);
+	};
 	const resolveModel = (agent, requestedModel) => {
 		const modelName = requestedModel ?? (typeof agent.model === "string" ? agent.model : "default");
 		if (!modelName.trim()) throw new FevexRunError("MODEL_NOT_FOUND", "Model name cannot be empty");
@@ -2265,35 +2802,30 @@ function createRunCore({ models, agents, tools, runStore, policies, onEvent, obs
 		}
 	};
 	const scheduleTraceExport = (event) => {
-		if (!observability || ![
-			"run.completed",
-			"run.failed",
-			"run.cancelled"
-		].includes(event.type) || exportedRuns.has(event.runId)) return;
-		exportedRuns.add(event.runId);
-		let task;
-		task = (async () => {
+		if (!observability || !isTraceTerminalEvent(event)) return;
+		traceExports.enqueue(event.runId, async () => {
 			const run = await runStore.getRun(event.runId);
 			if (!run) throw new Error(`Run "${event.runId}" does not exist`);
-			if (isCoordinatorRun(run)) return;
-			const agentRun = run;
-			let modelRegistryName = agentRun.modelName;
-			let modelMetadata = agentRun.modelMetadata;
-			if (modelRegistryName === void 0) {
-				const agent = agents.get(agentRun.agentName);
-				if (!agent) throw new Error(`Agent "${agentRun.agentName}" is not registered`);
-				const checkpoint = isDurableRunStore(runStore) ? await runStore.getCheckpoint(agentRun.id) : void 0;
-				const resolved = resolveModel(agent, checkpoint?.modelName);
-				modelRegistryName = resolved.modelName;
-				modelMetadata = resolved.model.metadata;
+			const coordinator = isCoordinatorRun(run);
+			let modelRegistryName;
+			let modelMetadata;
+			if (!coordinator) {
+				const agentRun = run;
+				modelRegistryName = agentRun.modelName;
+				modelMetadata = agentRun.modelMetadata;
+				if (modelRegistryName === void 0) {
+					const agent = agents.get(agentRun.agentName);
+					if (!agent) throw new Error(`Agent "${agentRun.agentName}" is not registered`);
+					const checkpoint = isDurableRunStore(runStore) ? await runStore.getCheckpoint(agentRun.id) : void 0;
+					const resolved = resolveModel(agent, checkpoint?.modelName);
+					modelRegistryName = resolved.modelName;
+					modelMetadata = resolved.model.metadata;
+				}
 			}
-			const trace = buildRunTrace(agentRun, await runStore.listEvents(agentRun.id), modelRegistryName, modelMetadata, observability);
-			const failures = (await Promise.allSettled(observability.exporters.map((exporter) => Promise.resolve().then(() => exporter.export(trace))))).filter((result) => result.status === "rejected").map(({ reason }) => reason);
+			const trace = buildRunTrace(run, await runStore.listEvents(run.id), modelRegistryName, modelMetadata, observability);
+			const failures = (await Promise.allSettled(observability.exporters.map((exporter) => withTimeout(Promise.resolve().then(() => exporter.export(trace)), traceExports.timeoutMs, `Trace exporter timed out after ${traceExports.timeoutMs}ms for run "${run.id}"`)))).filter((result) => result.status === "rejected").map(({ reason }) => reason);
 			if (failures.length) throw new AggregateError(failures, "Trace export failed");
-		})().catch((error) => {
-			exportFailures.push(error);
-		}).finally(() => pendingExports.delete(task));
-		pendingExports.add(task);
+		});
 	};
 	const notifyObserver = (event) => {
 		scheduleTraceExport(event);
@@ -2302,14 +2834,17 @@ function createRunCore({ models, agents, tools, runStore, policies, onEvent, obs
 			Promise.resolve(onEvent(event)).catch(() => {});
 		} catch {}
 	};
-	const createEvent = (state, type, payload) => ({
-		id: crypto.randomUUID(),
-		sequence: state.eventSequence += 1,
-		type,
-		runId: state.run.id,
-		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-		...payload === void 0 ? {} : { payload }
-	});
+	const createEvent = (state, type, payload) => {
+		if (limits?.maxEventsPerRun !== void 0 && !unboundedEvents.has(type) && state.eventSequence >= limits.maxEventsPerRun) throw new FevexRunError("EVENT_LIMIT_EXCEEDED", `Run exceeded maxEventsPerRun limit of ${limits.maxEventsPerRun}`, state.run.id);
+		return {
+			id: crypto.randomUUID(),
+			sequence: state.eventSequence += 1,
+			type,
+			runId: state.run.id,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			...payload === void 0 ? {} : { payload }
+		};
+	};
 	const createCoordinatorEvent = (state, workflowType, workflowPayload, teamType, teamPayload = workflowPayload) => createEvent(state, isTeamRun(state.run) ? teamType : workflowType, isTeamRun(state.run) ? teamPayload : workflowPayload);
 	const emitEvent = async (state, type, payload) => {
 		const event = createEvent(state, type, payload);
@@ -2323,11 +2858,13 @@ function createRunCore({ models, agents, tools, runStore, policies, onEvent, obs
 	const releaseExecution = async (state) => {
 		activeRuns.delete(state.run.id);
 		activeSessions.delete(state.session.id);
+		internalRuns.delete(state.run.id);
 		if (state.leaseTimer) clearInterval(state.leaseTimer);
 		if (state.leaseExpiryTimer) clearTimeout(state.leaseExpiryTimer);
 		state.leaseTimer = void 0;
 		state.leaseExpiryTimer = void 0;
 		if (state.lease && isDurableRunStore(runStore)) await runStore.releaseLease(state.run.id, state.lease.ownerId, state.lease.generation).catch(() => {});
+		notifyIdle();
 	};
 	const commit = async (state, options = {}) => {
 		if (!isDurableRunStore(runStore)) throw new FevexRunError("DURABLE_STORE_REQUIRED", "This run requires a DurableRunStore", state.run.id);
@@ -2411,11 +2948,13 @@ function createRunCore({ models, agents, tools, runStore, policies, onEvent, obs
 	const releaseWorkflowExecution = async (state) => {
 		activeWorkflowRuns.delete(state.run.id);
 		activeSessions.delete(state.session.id);
+		internalRuns.delete(state.run.id);
 		if (state.leaseTimer) clearInterval(state.leaseTimer);
 		if (state.leaseExpiryTimer) clearTimeout(state.leaseExpiryTimer);
 		state.leaseTimer = void 0;
 		state.leaseExpiryTimer = void 0;
 		if (state.lease && isDurableRunStore(runStore)) await runStore.releaseLease(state.run.id, state.lease.ownerId, state.lease.generation).catch(() => {});
+		notifyIdle();
 	};
 	const commitWorkflow = async (state, update, events = []) => {
 		state.commitQueue = state.commitQueue.then(async () => {
@@ -2449,9 +2988,14 @@ function createRunCore({ models, agents, tools, runStore, policies, onEvent, obs
 		activeRuns,
 		activeWorkflowRuns,
 		activeSessions,
-		pendingExports,
-		exportFailures,
+		isIdle,
+		waitForIdle,
+		closeAdmission,
+		isClosed,
+		traceExports,
 		runtimeOwner,
+		admitStart,
+		markInternalRun,
 		resolveModel,
 		resolveCheckpointModel,
 		notifyObserver,
@@ -2479,7 +3023,7 @@ function createRunCore({ models, agents, tools, runStore, policies, onEvent, obs
 */
 function createWorkflowEngine(composition, core, agentEngine) {
 	const { models, agents, workflows, teams, runStore } = composition;
-	const { activeRuns, activeWorkflowRuns, activeSessions, runtimeOwner, createEvent, createCoordinatorEvent, notifyObserver, commit, startLease, releaseWorkflowExecution, commitWorkflow } = core;
+	const { activeRuns, activeWorkflowRuns, activeSessions, runtimeOwner, isClosed, admitStart, createEvent, createCoordinatorEvent, notifyObserver, commit, startLease, releaseWorkflowExecution, commitWorkflow } = core;
 	const { prepareExecution, executeAgent, nextEvent, resumeAgent, cancelStoredAgent } = agentEngine;
 	const cancelWorkflowExecution = async (state, reason = cancellationReason(state.request.signal)) => {
 		if (state.leaseLost) {
@@ -2488,7 +3032,7 @@ function createWorkflowEngine(composition, core, agentEngine) {
 		}
 		if (state.run.status === "completed" || state.run.status === "failed" || state.run.status === "cancelled") return;
 		const childRunIds = Object.values(state.checkpoint.steps).filter((record) => record.type === "agent" && record.status === "running").map(({ childRunId }) => childRunId);
-		for (const childRunId of childRunIds) if (!await cancelStoredAgent(childRunId)) throw new FevexRunError("RUN_CONFLICT", `Workflow child "${childRunId}" could not be cancelled`, state.run.id);
+		for (const childRunId of childRunIds) if (!await cancelStoredAgent(childRunId, reason === "timeout" ? "timeout" : "aborted")) throw new FevexRunError("RUN_CONFLICT", `Workflow child "${childRunId}" could not be cancelled`, state.run.id);
 		state.run.status = "cancelled";
 		state.run.pause = void 0;
 		state.run.error = reason;
@@ -2501,7 +3045,77 @@ function createWorkflowEngine(composition, core, agentEngine) {
 		await releaseWorkflowExecution(state);
 		return event;
 	};
-	const prepareWorkflowExecution = async (name, request, kind = "workflow") => {
+	const cancelStoredWorkflow = async (runId, reason = "aborted") => {
+		const active = activeWorkflowRuns.get(runId);
+		if (active && !active.request.signal.aborted) {
+			active.controller.abort(new DOMException(reason === "timeout" ? "Run deadline exceeded" : "Run cancelled", reason === "timeout" ? "TimeoutError" : "AbortError"));
+			if (!active.advancing) {
+				await cancelWorkflowExecution(active);
+				return true;
+			}
+			for (let attempt = 0; attempt < 100; attempt += 1) {
+				const current = await runStore.getRun(runId);
+				if (current?.status === "cancelled" || current?.status === "completed" || current?.status === "failed") return true;
+				await new Promise((resolve) => setTimeout(resolve, 10));
+			}
+			return false;
+		}
+		if (!isDurableRunStore(runStore)) return false;
+		const run = await runStore.getRun(runId);
+		if (!run) return false;
+		if (run.status === "completed" || run.status === "failed" || run.status === "cancelled") return true;
+		const session = await runStore.getSession(run.sessionId);
+		const checkpoint = await runStore.getCheckpoint(runId);
+		if (!session || !checkpoint) return false;
+		const ownerId = `${runtimeOwner}:${crypto.randomUUID()}`;
+		const lease = {
+			generation: 0,
+			runId,
+			ownerId,
+			expiresAt: new Date(Date.now() + LEASE_MS).toISOString()
+		};
+		if (!await runStore.acquireLease(lease)) return false;
+		try {
+			const childRunIds = Object.values(checkpoint.steps).filter((record) => record.type === "agent" && record.status === "running").map(({ childRunId }) => childRunId);
+			for (const childRunId of childRunIds) if (!await cancelStoredAgent(childRunId, reason)) return false;
+			const state = {
+				run,
+				session,
+				request: {
+					input: checkpoint.input,
+					...checkpoint.model === void 0 ? {} : { model: checkpoint.model },
+					...checkpoint.reasoning === void 0 ? {} : { reasoning: checkpoint.reasoning },
+					sessionId: session.id,
+					context: checkpoint.context,
+					limits: checkpoint.limits,
+					signal: new AbortController().signal
+				},
+				controller: new AbortController(),
+				eventSequence: (await runStore.listEvents(runId)).at(-1)?.sequence ?? 0,
+				checkpoint,
+				advancing: false,
+				lease,
+				commitQueue: Promise.resolve()
+			};
+			run.status = "cancelled";
+			run.pause = void 0;
+			run.error = reason;
+			run.usage = checkpoint.budget?.usage;
+			const cancelled = createCoordinatorEvent(state, "workflow.run.cancelled", { reason }, "team.run.cancelled");
+			await commit(state, {
+				checkpoint: null,
+				events: [cancelled]
+			});
+			return true;
+		} catch (error) {
+			if (error instanceof FevexRunError && error.code === "RUN_CONFLICT" && (await runStore.getRun(runId))?.status !== "paused") return false;
+			throw error;
+		} finally {
+			await runStore.releaseLease(runId, ownerId, lease.generation).catch(() => {});
+		}
+	};
+	const prepareWorkflowExecutionBody = async (name, request, kind = "workflow") => {
+		if (isClosed()) throw new FevexRunError("RUNTIME_CLOSED", "Runtime is not accepting new runs");
 		const workflow = workflows.get(name);
 		const team = kind === "team" ? teams.get(name) : void 0;
 		if (!workflow || kind === "team" && !team || kind === "workflow" && teams.has(name)) throw new FevexRunError(kind === "team" ? "TEAM_NOT_FOUND" : "WORKFLOW_NOT_FOUND", `${kind === "team" ? "Team" : "Workflow"} "${name}" is not registered`);
@@ -2520,9 +3134,9 @@ function createWorkflowEngine(composition, core, agentEngine) {
 			session = stored;
 		}
 		if (activeSessions.has(session.id)) throw new FevexRunError("RUN_CONFLICT", `Session "${session.id}" already has an active run`);
-		activeSessions.add(session.id);
 		const controller = new AbortController();
-		const signal = request.signal ? AbortSignal.any([controller.signal, request.signal]) : controller.signal;
+		const signal = runSignal(controller, request);
+		const deadlineAt = deadlineAtFromMs(request.deadlineMs);
 		const input = toJsonValue(workflow.inputSchema === void 0 ? request.input : await abortable(() => validateSchema(workflow.inputSchema, request.input, `Input for ${kind} "${name}" does not match inputSchema`), signal), `${kind === "team" ? "Team" : "Workflow"} input must be a string or JSON-serializable value`);
 		const id = crypto.randomUUID();
 		const run = kind === "team" ? {
@@ -2533,7 +3147,8 @@ function createWorkflowEngine(composition, core, agentEngine) {
 			status: "running",
 			revision: 0,
 			createdAt: now,
-			updatedAt: now
+			updatedAt: now,
+			...deadlineAt === void 0 ? {} : { deadlineAt }
 		} : {
 			kind: "workflow",
 			id,
@@ -2542,7 +3157,8 @@ function createWorkflowEngine(composition, core, agentEngine) {
 			status: "running",
 			revision: 0,
 			createdAt: now,
-			updatedAt: now
+			updatedAt: now,
+			...deadlineAt === void 0 ? {} : { deadlineAt }
 		};
 		const checkpoint = kind === "team" ? {
 			version: 2,
@@ -2569,6 +3185,7 @@ function createWorkflowEngine(composition, core, agentEngine) {
 			steps: {},
 			limits: combineLimits(workflow.limits, request.limits)
 		};
+		activeSessions.add(session.id);
 		const state = {
 			run,
 			session,
@@ -2610,6 +3227,14 @@ function createWorkflowEngine(composition, core, agentEngine) {
 		activeWorkflowRuns.set(run.id, state);
 		return state;
 	};
+	const prepareWorkflowExecution = async (name, request, kind = "workflow") => {
+		const release = await admitStart(kind, name, request);
+		try {
+			return await prepareWorkflowExecutionBody(name, request, kind);
+		} finally {
+			release();
+		}
+	};
 	async function* executeWorkflow(name, state) {
 		const workflow = workflows.get(name);
 		const events = [];
@@ -2771,7 +3396,10 @@ function createWorkflowEngine(composition, core, agentEngine) {
 					if (!child) throw new Error(`Child run "${existing.childRunId}" does not exist`);
 					if (child.status === "running") {
 						if (!state.recoveryActor) throw new FevexRunError("RUN_NOT_RECOVERABLE", `Child run "${child.id}" is still running`, state.run.id);
-						child = await resumeAgent(child.id, void 0, true, state.recoveryActor);
+						child = await resumeAgent(child.id, void 0, true, state.recoveryActor, {
+							admit: false,
+							internal: true
+						});
 					}
 					if (child.status === "completed") return completeAgentStep(stepId, existing.agentName, existing.childRunId, toJsonValue(child.output, "Child agent output must be JSON-serializable"), options);
 					if (child.status === "paused" && child.pause) return pauseForChild(stepId, new RunPausedError(child.id, child.pause));
@@ -2782,11 +3410,16 @@ function createWorkflowEngine(composition, core, agentEngine) {
 				const childSignal = request.signal ? AbortSignal.any([state.request.signal, request.signal]) : state.request.signal;
 				const childState = await prepareExecution(agentName, {
 					...request,
+					deadlineMs: minDeadline(remainingDeadlineMs(state.run.deadlineAt, state.run.id), request.deadlineMs),
 					model: request.model ?? state.request.model,
 					reasoning: request.reasoning ?? state.request.reasoning,
 					context: mergeExecutionContext(state.request.context, request.context),
 					limits: combineLimits(request.limits, remainingWorkflowLimits(state.checkpoint.limits, state.checkpoint.budget)),
 					signal: childSignal
+				}, {
+					admit: false,
+					parentRunId: state.run.id,
+					rootRunId: state.run.rootRunId ?? state.run.id
 				});
 				const action = options?.metadata?.teamAction === "handoff" ? "handoff" : "delegate";
 				const lifecycleEvents = [];
@@ -2799,11 +3432,13 @@ function createWorkflowEngine(composition, core, agentEngine) {
 				const started = createCoordinatorEvent(state, "workflow.step.started", {
 					stepId,
 					kind: "agent",
-					agentName
+					agentName,
+					childRunId: childState.run.id
 				}, "team.agent.assigned", {
 					delegationId: stepId,
 					agentName,
 					action,
+					childRunId: childState.run.id,
 					...typeof options?.metadata?.expectedOutput === "string" ? { expectedOutput: options.metadata.expectedOutput } : {},
 					...Array.isArray(options?.metadata?.constraints) ? { constraints: options.metadata.constraints } : {}
 				});
@@ -3121,8 +3756,10 @@ function createWorkflowEngine(composition, core, agentEngine) {
 			};
 		} catch (error) {
 			let thrown = error;
-			if (state.request.signal.aborted) try {
-				const event = await cancelWorkflowExecution(state);
+			const parentDeadline = state.run.deadlineAt === void 0 ? void 0 : Date.parse(state.run.deadlineAt);
+			const parentTimedOut = isTimeoutError(error) && parentDeadline !== void 0 && Date.now() >= parentDeadline - 10;
+			if (state.request.signal.aborted || parentTimedOut) try {
+				const event = await cancelWorkflowExecution(state, parentTimedOut ? "timeout" : void 0);
 				if (event) {
 					events.push(event);
 					yield event;
@@ -3184,13 +3821,18 @@ function createWorkflowEngine(composition, core, agentEngine) {
 			}
 		}
 	};
-	const resumeWorkflow = async (runId, resolution, recoveryActor) => {
+	const resumeWorkflowBody = async (runId, resolution, recoveryActor) => {
 		if (!isDurableRunStore(runStore)) throw new FevexRunError("DURABLE_STORE_REQUIRED", "resumeRun requires DurableRunStore", runId);
 		const run = await runStore.getRun(runId);
 		const checkpoint = await runStore.getCheckpoint(runId);
 		if (!run || !checkpoint) throw new FevexRunError(resolution ? "RUN_NOT_RESUMABLE" : "RUN_NOT_RECOVERABLE", `Run "${runId}" cannot be ${resolution ? "resumed" : "recovered"}`, runId);
 		if (checkpoint.version !== 2) throw new FevexRunError("CHECKPOINT_UNSUPPORTED", `Checkpoint for run "${runId}" is unsupported`, runId);
 		if (resolution && run.status !== "paused" && run.status !== "running" || !resolution && run.status !== "running") throw new FevexRunError(resolution ? "RUN_NOT_RESUMABLE" : "RUN_NOT_RECOVERABLE", `Run "${runId}" is not ${resolution ? "resumable" : "recoverable"}`, runId);
+		if (run.deadlineAt !== void 0 && Date.parse(run.deadlineAt) <= Date.now()) {
+			if (!await cancelStoredWorkflow(runId, "timeout")) throw new FevexRunError(resolution ? "RUN_NOT_RESUMABLE" : "RUN_NOT_RECOVERABLE", `Run "${runId}" deadline has passed`, runId);
+			return await runStore.getRun(runId);
+		}
+		const deadlineSignal = resumeDeadlineSignal(run.deadlineAt, runId, resolution ? "RUN_NOT_RESUMABLE" : "RUN_NOT_RECOVERABLE");
 		const name = coordinatorName(run);
 		const workflow = workflows.get(name);
 		const team = isTeamRun(run) ? teams.get(name) : void 0;
@@ -3213,6 +3855,7 @@ function createWorkflowEngine(composition, core, agentEngine) {
 			if (!resolution) {
 				if (!recoveryActor?.id.trim()) throw new FevexRunError("RUN_NOT_RECOVERABLE", "Recovery actor is required", runId);
 				const controller = new AbortController();
+				const signal = deadlineSignal ? AbortSignal.any([controller.signal, deadlineSignal]) : controller.signal;
 				const state = {
 					run,
 					session,
@@ -3223,7 +3866,7 @@ function createWorkflowEngine(composition, core, agentEngine) {
 						sessionId: session.id,
 						context: checkpoint.context,
 						limits: checkpoint.limits,
-						signal: controller.signal
+						signal
 					},
 					controller,
 					eventSequence: (await runStore.listEvents(runId)).at(-1)?.sequence ?? 0,
@@ -3266,6 +3909,7 @@ function createWorkflowEngine(composition, core, agentEngine) {
 					if (validatedPayload !== void 0) eventPayload = toJsonValue(validatedPayload, "Workflow event payload must be JSON-serializable");
 				}
 				const controller = new AbortController();
+				const signal = deadlineSignal ? AbortSignal.any([controller.signal, deadlineSignal]) : controller.signal;
 				const state = {
 					run,
 					session,
@@ -3276,7 +3920,7 @@ function createWorkflowEngine(composition, core, agentEngine) {
 						sessionId: session.id,
 						context: checkpoint.context,
 						limits: checkpoint.limits,
-						signal: controller.signal
+						signal
 					},
 					controller,
 					eventSequence: (await runStore.listEvents(runId)).at(-1)?.sequence ?? 0,
@@ -3314,8 +3958,93 @@ function createWorkflowEngine(composition, core, agentEngine) {
 			if (resolution.type === "timer" || resolution.type === "event") throw new FevexRunError("RUN_NOT_RESUMABLE", `Run "${runId}" cannot be resumed`, runId);
 			const childRunId = workflowPause.type === "workflow_children" ? workflowPause.children.find(({ childPause }) => pauseMatchesResolution(childPause, resolution))?.childRunId : workflowPause.childRunId;
 			if (!childRunId) throw new FevexRunError("RUN_NOT_RESUMABLE", "Resolution does not match a paused child run", runId);
-			const childRun = await resumeAgent(childRunId, resolution, true);
+			let childRun;
+			try {
+				childRun = await resumeAgent(childRunId, resolution, true, void 0, {
+					admit: false,
+					internal: true
+				});
+			} catch (error) {
+				const parentDeadline = run.deadlineAt === void 0 ? void 0 : Date.parse(run.deadlineAt);
+				const child = await runStore.getRun(childRunId);
+				const childDeadline = child?.deadlineAt === void 0 ? void 0 : Date.parse(child.deadlineAt);
+				if (isTimeoutError(error) && parentDeadline !== void 0 && childDeadline !== void 0 && Math.abs(childDeadline - parentDeadline) <= 5) {
+					const pausedChildIds = workflowPause.type === "workflow_children" ? workflowPause.children.map(({ childRunId }) => childRunId) : [workflowPause.childRunId];
+					for (const pausedChildId of pausedChildIds) if (!await cancelStoredAgent(pausedChildId, "timeout")) throw error;
+					const cancelController = new AbortController();
+					const cancelState = {
+						run,
+						session,
+						request: {
+							input: checkpoint.input,
+							...checkpoint.model === void 0 ? {} : { model: checkpoint.model },
+							...checkpoint.reasoning === void 0 ? {} : { reasoning: checkpoint.reasoning },
+							sessionId: session.id,
+							context: checkpoint.context,
+							limits: checkpoint.limits,
+							signal: cancelController.signal
+						},
+						controller: cancelController,
+						eventSequence: (await runStore.listEvents(runId)).at(-1)?.sequence ?? 0,
+						checkpoint,
+						advancing: false,
+						lease,
+						commitQueue: Promise.resolve()
+					};
+					run.status = "cancelled";
+					run.pause = void 0;
+					run.error = "timeout";
+					run.usage = checkpoint.budget?.usage;
+					const cancelled = createCoordinatorEvent(cancelState, "workflow.run.cancelled", { reason: "timeout" }, "team.run.cancelled");
+					await commit(cancelState, {
+						checkpoint: null,
+						events: [cancelled]
+					});
+					await runStore.releaseLease(runId, ownerId, lease.generation).catch(() => {});
+					return structuredClone(run);
+				}
+				if (isTimeoutError(error)) {
+					const pausedChildIds = workflowPause.type === "workflow_children" ? workflowPause.children.map(({ childRunId }) => childRunId) : [workflowPause.childRunId];
+					for (const pausedChildId of pausedChildIds) if (!await cancelStoredAgent(pausedChildId, "aborted")) throw error;
+					const failController = new AbortController();
+					const failState = {
+						run,
+						session,
+						request: {
+							input: checkpoint.input,
+							...checkpoint.model === void 0 ? {} : { model: checkpoint.model },
+							...checkpoint.reasoning === void 0 ? {} : { reasoning: checkpoint.reasoning },
+							sessionId: session.id,
+							context: checkpoint.context,
+							limits: checkpoint.limits,
+							signal: failController.signal
+						},
+						controller: failController,
+						eventSequence: (await runStore.listEvents(runId)).at(-1)?.sequence ?? 0,
+						checkpoint,
+						advancing: false,
+						lease,
+						commitQueue: Promise.resolve()
+					};
+					run.status = "failed";
+					run.pause = void 0;
+					run.error = toErrorMessage(error);
+					run.usage = checkpoint.budget?.usage;
+					const failed = createCoordinatorEvent(failState, "workflow.run.failed", {
+						error: toErrorMessage(error),
+						...runErrorPayload(error)
+					}, "team.run.failed");
+					await commit(failState, {
+						checkpoint: null,
+						events: [failed]
+					});
+					await runStore.releaseLease(runId, ownerId, lease.generation).catch(() => {});
+					return structuredClone(run);
+				}
+				throw error;
+			}
 			const controller = new AbortController();
+			const signal = deadlineSignal ? AbortSignal.any([controller.signal, deadlineSignal]) : controller.signal;
 			const state = {
 				run,
 				session,
@@ -3326,7 +4055,7 @@ function createWorkflowEngine(composition, core, agentEngine) {
 					sessionId: session.id,
 					context: checkpoint.context,
 					limits: checkpoint.limits,
-					signal: controller.signal
+					signal
 				},
 				controller,
 				eventSequence: (await runStore.listEvents(runId)).at(-1)?.sequence ?? 0,
@@ -3339,7 +4068,7 @@ function createWorkflowEngine(composition, core, agentEngine) {
 				run.status = "cancelled";
 				run.pause = void 0;
 				run.error = childRun.error ?? "aborted";
-				const reason = childRun.error === "approval_rejected" ? "approval_rejected" : "aborted";
+				const reason = childRun.error === "approval_rejected" ? "approval_rejected" : childRun.error === "timeout" ? "timeout" : "aborted";
 				const cancelled = createCoordinatorEvent(state, "workflow.run.cancelled", { reason }, "team.run.cancelled");
 				await commit(state, {
 					checkpoint: null,
@@ -3365,35 +4094,104 @@ function createWorkflowEngine(composition, core, agentEngine) {
 			throw error;
 		}
 	};
+	const resumeWorkflow = async (runId, resolution, recoveryActor, options = {}) => {
+		let release;
+		if (options.admit !== false) {
+			const run = await runStore.getRun(runId);
+			const checkpoint = isDurableRunStore(runStore) ? await runStore.getCheckpoint(runId) : void 0;
+			if (run && checkpoint && (run.status === "paused" || run.status === "running")) release = await admitStart(isTeamRun(run) ? "team" : "workflow", coordinatorName(run), {
+				input: "",
+				...checkpoint.context === void 0 ? {} : { context: checkpoint.context }
+			});
+		}
+		try {
+			return await resumeWorkflowBody(runId, resolution, recoveryActor);
+		} finally {
+			release?.();
+		}
+	};
 	return {
 		prepareWorkflowExecution,
 		executeWorkflow,
 		nextWorkflowEvent,
 		drainWorkflowExecution,
 		resumeWorkflow,
-		cancelWorkflowExecution
+		cancelWorkflowExecution,
+		cancelStoredWorkflow
 	};
 }
 //#endregion
 //#region src/internal/runtime.ts
+const DEFAULT_SHUTDOWN_TIMEOUT_MS = 3e4;
+const SHUTDOWN_CLEANUP_MS = 5e3;
 function createRuntime(composition) {
 	const { models, agents, workflows, teams, tools, contextProviders, memoryStore, runStore, credentialStore, sandbox, policies } = composition;
 	const core = createRunCore(composition);
-	const { activeRuns, activeWorkflowRuns, activeSessions, pendingExports, exportFailures, runtimeOwner, createEvent, createCoordinatorEvent, notifyObserver, commit, startLease, cancelExecution, releaseWorkflowExecution, commitWorkflow } = core;
+	const { activeRuns, activeWorkflowRuns, activeSessions, isIdle, waitForIdle, closeAdmission, isClosed, traceExports, runtimeOwner, createEvent, createCoordinatorEvent, notifyObserver, commit, startLease, cancelExecution, releaseWorkflowExecution, commitWorkflow } = core;
 	const agentEngine = createAgentEngine(composition, core);
 	const { prepareExecution, executeAgent, nextEvent, drainExecution, resumeAgent, cancelStoredAgent } = agentEngine;
-	const { prepareWorkflowExecution, executeWorkflow, nextWorkflowEvent, drainWorkflowExecution, resumeWorkflow, cancelWorkflowExecution } = createWorkflowEngine(composition, core, agentEngine);
+	const { prepareWorkflowExecution, executeWorkflow, nextWorkflowEvent, drainWorkflowExecution, resumeWorkflow, cancelWorkflowExecution, cancelStoredWorkflow } = createWorkflowEngine(composition, core, agentEngine);
 	const resumeRun = async (runId, resolution) => {
+		if (isClosed()) throw new FevexRunError("RUNTIME_CLOSED", "Runtime is not accepting new runs", runId);
 		const run = await runStore.getRun(runId);
 		if (run && isCoordinatorRun(run)) return resumeWorkflow(runId, resolution);
 		return resumeAgent(runId, resolution);
 	};
 	const recoverRun = async (runId, actor) => {
+		if (isClosed()) throw new FevexRunError("RUNTIME_CLOSED", "Runtime is not accepting new runs", runId);
 		const run = await runStore.getRun(runId);
 		if (!run) throw new FevexRunError("RUN_NOT_RECOVERABLE", `Run "${runId}" cannot be recovered`, runId);
 		if (isCoordinatorRun(run)) return resumeWorkflow(runId, void 0, actor);
 		return resumeAgent(runId, void 0, false, actor);
 	};
+	const waitForIdleUntil = async (deadline) => {
+		if (isIdle()) return true;
+		const remaining = deadline - Date.now();
+		if (remaining <= 0) return false;
+		return new Promise((resolve) => {
+			let settled = false;
+			let timer;
+			const finish = (idle) => {
+				if (settled) return;
+				settled = true;
+				if (timer) clearTimeout(timer);
+				resolve(idle);
+			};
+			timer = setTimeout(() => finish(false), remaining);
+			waitForIdle().then(() => finish(true));
+		});
+	};
+	const shutdown = async (options = {}) => {
+		const timeoutMs = options.timeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS;
+		if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 0) throw new TypeError("Shutdown timeoutMs must be a non-negative safe integer");
+		closeAdmission();
+		const deadline = Date.now() + timeoutMs;
+		let cleanupDeadline = deadline;
+		let timedOut = false;
+		const cancelled = /* @__PURE__ */ new Set();
+		if (!await waitForIdleUntil(deadline)) {
+			timedOut = true;
+			cleanupDeadline = Date.now() + SHUTDOWN_CLEANUP_MS;
+			for (const { run } of activeWorkflowRuns.values()) cancelled.add(run.id);
+			for (const { run } of activeRuns.values()) cancelled.add(run.id);
+			for (const state of [...activeWorkflowRuns.values(), ...activeRuns.values()]) if (!state.request.signal.aborted) state.controller.abort(new DOMException("Run cancelled", "AbortError"));
+			for (const state of [...activeWorkflowRuns.values()]) if (!state.advancing) await cancelWorkflowExecution(state).catch(() => {});
+			for (const state of [...activeRuns.values()]) if (!state.advancing) await cancelExecution(state).catch(() => {});
+			await waitForIdleUntil(cleanupDeadline);
+		}
+		let exportError;
+		try {
+			await traceExports.flush({ timeoutMs: Math.max(1, cleanupDeadline - Date.now()) });
+		} catch (error) {
+			exportError = error;
+		}
+		return {
+			cancelledRunIds: [...cancelled],
+			timedOut,
+			...exportError === void 0 ? {} : { exportError },
+			observability: traceExports.stats()
+		};
+	};
 	return {
 		async startAgent(name, request) {
 			const state = await prepareExecution(name, request);
@@ -3499,58 +4297,7 @@ function createRuntime(composition) {
 			}
 			const run = await runStore.getRun(runId);
 			if (!run || run.status !== "paused" && run.status !== "running") return false;
-			if (!isDurableRunStore(runStore)) return false;
-			const session = await runStore.getSession(run.sessionId);
-			if (!session) return false;
-			if (isCoordinatorRun(run)) {
-				const checkpoint = await runStore.getCheckpoint(runId);
-				if (!checkpoint) return false;
-				const ownerId = `${runtimeOwner}:${crypto.randomUUID()}`;
-				const lease = {
-					generation: 0,
-					runId,
-					ownerId,
-					expiresAt: new Date(Date.now() + LEASE_MS).toISOString()
-				};
-				if (!await runStore.acquireLease(lease)) return false;
-				try {
-					const childRunIds = Object.values(checkpoint.steps).filter((record) => record.type === "agent" && record.status === "running").map(({ childRunId }) => childRunId);
-					for (const childRunId of childRunIds) if (!await cancelStoredAgent(childRunId)) return false;
-					const state = {
-						run,
-						session,
-						request: {
-							input: checkpoint.input,
-							...checkpoint.reasoning === void 0 ? {} : { reasoning: checkpoint.reasoning },
-							sessionId: session.id,
-							context: checkpoint.context,
-							limits: checkpoint.limits,
-							signal: new AbortController().signal
-						},
-						controller: new AbortController(),
-						eventSequence: (await runStore.listEvents(runId)).at(-1)?.sequence ?? 0,
-						checkpoint,
-						advancing: false,
-						lease,
-						commitQueue: Promise.resolve()
-					};
-					run.status = "cancelled";
-					run.pause = void 0;
-					run.error = "aborted";
-					run.usage = checkpoint.budget?.usage;
-					const cancelled = createCoordinatorEvent(state, "workflow.run.cancelled", { reason: "aborted" }, "team.run.cancelled");
-					await commit(state, {
-						checkpoint: null,
-						events: [cancelled]
-					});
-					return true;
-				} catch (error) {
-					if (error instanceof FevexRunError && error.code === "RUN_CONFLICT" && (await runStore.getRun(runId))?.status !== "paused") return false;
-					throw error;
-				} finally {
-					await runStore.releaseLease(runId, ownerId, lease.generation).catch(() => {});
-				}
-			}
+			if (isCoordinatorRun(run)) return cancelStoredWorkflow(runId);
 			return cancelStoredAgent(runId);
 		},
 		resumeRun(runId, resolution) {
@@ -3559,6 +4306,10 @@ function createRuntime(composition) {
 		recoverRun(runId, options) {
 			return recoverRun(runId, options.actor);
 		},
+		async purgeRuns(options) {
+			if (!isRetainableRunStore(runStore)) throw new FevexRunError("RETENTION_UNSUPPORTED", "The configured run store does not support purgeRuns");
+			return runStore.purgeRuns(options);
+		},
 		async compactSession(sessionId, summary) {
 			if (typeof summary !== "string" || !summary.trim()) throw new Error("Session summary must be a non-empty string");
 			if (activeSessions.has(sessionId)) throw new Error(`Session "${sessionId}" has an active run`);
@@ -3572,13 +4323,13 @@ function createRuntime(composition) {
 			await runStore.saveSession(session);
 			return structuredClone(session);
 		},
-		async flushObservability() {
-			while (pendingExports.size) await Promise.all([...pendingExports]);
-			if (exportFailures.length) {
-				const failures = exportFailures.splice(0);
-				throw new AggregateError(failures, "Observability export failed");
-			}
-		}
+		flushObservability(options) {
+			return traceExports.flush(options);
+		},
+		getObservabilityStats() {
+			return traceExports.stats();
+		},
+		shutdown
 	};
 }
 //#endregion
@@ -3593,4 +4344,4 @@ function createFevex(config) {
 	return createRuntime(createComposition(config));
 }
 //#endregion
-export { ChannelError, FEVEX_JSON_SCHEMA_PROFILE_VERSION, FevexConfigurationError, FevexRunError, InMemoryMemoryStore, InMemoryRunStore, IntegrationError, PROVIDER_REASONING_UNSUPPORTED, PROVIDER_SCHEMA_UNSUPPORTED, RunPausedError, SCHEMA_NOT_TRANSPORTABLE, SandboxError, compileFevexJsonSchema, createFevex, createLocalSandbox, createMemoryContextProvider, defineAgent, defineConnection, defineContextProvider, definePolicy, defineSkill, defineTeam, defineTool, defineWorkflow, deliverChannelRun, handleChannelInput, isDurableRunStore, sandboxResultToJson, toToolSpec, validateFevexJsonSchemaProfile, validateListEventsOptions };
+export { ArtifactError, CatalogedArtifactStore, ChannelError, FEVEX_JSON_SCHEMA_PROFILE_VERSION, FevexConfigurationError, FevexRunError, FileSystemArtifactStore, InMemoryArtifactCatalog, InMemoryArtifactStore, InMemoryMemoryStore, InMemoryRunStore, IntegrationError, PROVIDER_REASONING_UNSUPPORTED, PROVIDER_SCHEMA_UNSUPPORTED, RunPausedError, S3ArtifactStore, SCHEMA_NOT_TRANSPORTABLE, SandboxError, artifactTenantId, assertArtifactId, compileFevexJsonSchema, createFevex, createLocalSandbox, createMemoryContextProvider, defineAgent, defineConnection, defineContextProvider, definePolicy, defineSkill, defineTeam, defineTool, defineWorkflow, deliverChannelRun, handleChannelInput, isDurableRunStore, isRetainableRunStore, sandboxResultToJson, toToolSpec, validateFevexJsonSchemaProfile, validateListEventsOptions, validatePurgeRunsOptions };