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

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");
@@ -594,8 +613,11 @@ 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 } : {},
@@ -732,6 +754,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 +889,9 @@ 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, admitStart, markInternalRun, resolveModel, resolveCheckpointModel, notifyObserver, createEvent, emitEvent, releaseExecution, commit, startLease, cancelExecution, authorize } = core;
+	const prepareExecutionBody = async (name, request, internal = false) => {
 		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,9 +910,10 @@ 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,
@@ -899,8 +923,10 @@ function createAgentEngine(composition, core) {
 			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 +1007,14 @@ 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);
+		} 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 +1553,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 +1575,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 +1607,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 +1715,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 +1723,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 +1751,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 +1762,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 +1931,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 +1994,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,6 +2017,37 @@ 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([
@@ -2236,14 +2341,103 @@ 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 internalRuns = /* @__PURE__ */ new Set();
+	const pendingTenantStarts = /* @__PURE__ */ new Map();
+	let pendingStarts = 0;
 	const pendingExports = /* @__PURE__ */ new Set();
 	const exportFailures = [];
 	const exportedRuns = /* @__PURE__ */ new Set();
 	const runtimeOwner = crypto.randomUUID();
+	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 (!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");
@@ -2302,14 +2496,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,6 +2520,7 @@ 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;
@@ -2411,6 +2609,7 @@ 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;
@@ -2452,6 +2651,8 @@ function createRunCore({ models, agents, tools, runStore, policies, onEvent, obs
 		pendingExports,
 		exportFailures,
 		runtimeOwner,
+		admitStart,
+		markInternalRun,
 		resolveModel,
 		resolveCheckpointModel,
 		notifyObserver,
@@ -2479,7 +2680,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, 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 +2689,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 +2702,76 @@ 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") => {
 		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 +2790,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 +2803,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 +2813,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 +2841,7 @@ function createWorkflowEngine(composition, core, agentEngine) {
 			steps: {},
 			limits: combineLimits(workflow.limits, request.limits)
 		};
+		activeSessions.add(session.id);
 		const state = {
 			run,
 			session,
@@ -2610,6 +2883,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 +3052,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,12 +3066,13 @@ 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 });
 				const action = options?.metadata?.teamAction === "handoff" ? "handoff" : "delegate";
 				const lifecycleEvents = [];
 				if (isTeamRun(state.run) && action === "handoff") lifecycleEvents.push(createEvent(state, "team.handoff.created", {
@@ -3121,8 +3406,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 +3471,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 +3505,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 +3516,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 +3559,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 +3570,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 +3608,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 +3705,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 +3718,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,13 +3744,30 @@ 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
@@ -3382,7 +3778,7 @@ function createRuntime(composition) {
 	const { activeRuns, activeWorkflowRuns, activeSessions, pendingExports, exportFailures, 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) => {
 		const run = await runStore.getRun(runId);
 		if (run && isCoordinatorRun(run)) return resumeWorkflow(runId, resolution);
@@ -3499,58 +3895,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 +3904,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`);
@@ -3593,4 +3942,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 };