@agentium/harness 4.0.0

package/dist/driver-Cr2BGG4h.cjs

@@ -0,0 +1,2138 @@
+let node_crypto = require("node:crypto");
+let _agentium_core = require("@agentium/core");
+let node_path = require("node:path");
+let zod_v3 = require("zod/v3");
+//#region src/runtime/middleware.ts
+/** Stable topological sort; declaration order breaks ties between ready nodes. */
+function sortHarnessMiddleware(middleware) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const item of middleware) {
+		if (!item.id || byId.has(item.id)) throw new Error("Harness middleware IDs must be nonempty and unique");
+		byId.set(item.id, item);
+	}
+	const edges = new Map(middleware.map((item) => [item.id, /* @__PURE__ */ new Set()]));
+	const degrees = new Map(middleware.map((item) => [item.id, 0]));
+	const link = (from, to) => {
+		if (!byId.has(from) || !byId.has(to)) throw new Error("Harness middleware references an unknown ordering ID");
+		if (!edges.get(from).has(to)) {
+			edges.get(from).add(to);
+			degrees.set(to, degrees.get(to) + 1);
+		}
+	};
+	for (const item of middleware) {
+		for (const id of item.before ?? []) link(item.id, id);
+		for (const id of item.after ?? []) link(id, item.id);
+	}
+	const result = [];
+	const consumed = /* @__PURE__ */ new Set();
+	while (result.length < middleware.length) {
+		const item = middleware.find((candidate) => !consumed.has(candidate.id) && degrees.get(candidate.id) === 0);
+		if (!item) throw new Error("Harness middleware ordering contains a cycle");
+		result.push(item);
+		consumed.add(item.id);
+		for (const id of edges.get(item.id)) degrees.set(id, degrees.get(id) - 1);
+	}
+	return result;
+}
+async function runBeforeModel(middleware, messages, ctx) {
+	let current = structuredClone(messages);
+	for (const item of middleware) {
+		ctx.signal?.throwIfAborted();
+		if (!item.beforeModel) continue;
+		const previous = structuredClone(current);
+		const next = await item.beforeModel(current, ctx);
+		(0, _agentium_core.validateConversationTransform)(previous, next);
+		current = next;
+	}
+	return current;
+}
+async function runAfterModel(middleware, response, ctx) {
+	for (const item of middleware) {
+		ctx.signal?.throwIfAborted();
+		await item.afterModel?.(structuredClone(response), ctx);
+	}
+}
+async function runAfterTool(middleware, result, ctx) {
+	for (const item of middleware) {
+		ctx.signal?.throwIfAborted();
+		await item.afterTool?.(structuredClone(result), ctx);
+	}
+}
+//#endregion
+//#region src/runtime/context-policy.ts
+/** Request projections never mutate the canonical history. */
+async function projectHarnessContext(policy, history, ctx, entries = []) {
+	const original = structuredClone(history);
+	if (!policy) return {
+		messages: original,
+		provenance: []
+	};
+	const result = await policy.project({
+		history: structuredClone(original),
+		entries: structuredClone(entries)
+	}, ctx);
+	(0, _agentium_core.validateConversationTransform)(original, result.messages);
+	if (!Array.isArray(result.provenance) || result.provenance.some((item) => !item || typeof item.sourceId !== "string" || typeof item.included !== "boolean" || item.reason !== void 0 && typeof item.reason !== "string")) throw new Error("Context policy must return provenance");
+	return {
+		messages: structuredClone(result.messages),
+		provenance: structuredClone(result.provenance)
+	};
+}
+//#endregion
+//#region src/runtime/context.ts
+const DEFAULT_BUDGET = {
+	maxEntries: 32,
+	maxBytes: 65536,
+	maxTokens: 16e3,
+	deadlineMs: 5e3
+};
+function sourceMessage(sourceId, entry, text) {
+	const provenance = {
+		version: 1,
+		sourceId,
+		entryId: entry.id,
+		trust: "source",
+		...entry.source ? { source: {
+			uri: entry.source.uri,
+			...entry.source.version === void 0 ? {} : { version: entry.source.version },
+			...entry.source.locator === void 0 ? {} : { locator: entry.source.locator }
+		} } : {}
+	};
+	return {
+		role: "user",
+		content: JSON.stringify({
+			kind: "harness-source-data",
+			...provenance,
+			text
+		}),
+		providerExtras: { harnessContext: provenance }
+	};
+}
+/** All limits apply across every source. Tokens are centrally estimated, never accepted from the source. */
+async function fetchHarnessContext(sources, query, ctx, configured) {
+	const budget = {
+		...DEFAULT_BUDGET,
+		...configured
+	};
+	for (const [key, value] of Object.entries(budget)) if (value !== void 0 && (!Number.isFinite(value) || !Number.isInteger(value) || value < 0)) throw new Error(`Invalid harness context budget: ${key}`);
+	const messages = [];
+	const diagnostics = [];
+	const sourceIds = /* @__PURE__ */ new Set();
+	for (const source of sources) {
+		if (typeof source.id !== "string" || !source.id || sourceIds.has(source.id)) throw new Error("Harness context source IDs must be nonempty and unique");
+		sourceIds.add(source.id);
+	}
+	const deadline = Date.now() + budget.deadlineMs;
+	let bytes = 0;
+	let tokens = 0;
+	for (const source of sources) {
+		if (ctx.signal?.aborted) throw new _agentium_core.RunCancelledError();
+		const remaining = {
+			maxEntries: budget.maxEntries - messages.length,
+			maxBytes: budget.maxBytes - bytes,
+			...budget.maxTokens === void 0 ? {} : { maxTokens: budget.maxTokens - tokens },
+			deadlineMs: Math.max(0, deadline - Date.now())
+		};
+		if (!remaining.maxEntries || !remaining.maxBytes || remaining.maxTokens === 0 || !remaining.deadlineMs) {
+			diagnostics.push({
+				sourceId: source.id,
+				code: remaining.deadlineMs ? "budget" : "deadline",
+				message: "Shared context retrieval budget exhausted"
+			});
+			break;
+		}
+		const controller = new AbortController();
+		const childCtx = new _agentium_core.RunContext({
+			sessionId: ctx.sessionId,
+			runId: ctx.runId,
+			userId: ctx.userId,
+			tenantId: ctx.tenantId,
+			metadata: ctx.metadata,
+			eventBus: ctx.eventBus,
+			sessionState: ctx.sessionState,
+			dependencies: ctx.dependencies,
+			questions: ctx.questions,
+			executionPolicy: ctx.executionPolicy,
+			runMode: ctx.runMode,
+			signal: controller.signal
+		});
+		let timer;
+		let abort;
+		let entries;
+		try {
+			entries = await Promise.race([Promise.resolve().then(() => {
+				if (childCtx.signal?.aborted || ctx.signal?.aborted) throw new _agentium_core.RunCancelledError();
+				return source.fetch(query, childCtx, remaining);
+			}), new Promise((_resolve, reject) => {
+				timer = setTimeout(() => {
+					controller.abort();
+					reject(/* @__PURE__ */ new Error("deadline"));
+				}, remaining.deadlineMs);
+				abort = () => {
+					controller.abort();
+					reject(new _agentium_core.RunCancelledError());
+				};
+				ctx.signal?.addEventListener("abort", abort, { once: true });
+				if (ctx.signal?.aborted) abort();
+			})]);
+		} catch {
+			if (ctx.signal?.aborted) throw new _agentium_core.RunCancelledError();
+			diagnostics.push({
+				sourceId: source.id,
+				code: controller.signal.aborted ? "deadline" : "failed",
+				message: "Context source could not complete within its budget"
+			});
+			continue;
+		} finally {
+			if (timer) clearTimeout(timer);
+			if (abort) ctx.signal?.removeEventListener("abort", abort);
+		}
+		if (!Array.isArray(entries)) {
+			diagnostics.push({
+				sourceId: source.id,
+				code: "invalid",
+				message: "Context source must return an array"
+			});
+			continue;
+		}
+		if (entries.length > remaining.maxEntries) diagnostics.push({
+			sourceId: source.id,
+			code: "budget",
+			message: "Context entries beyond the shared entry limit were discarded"
+		});
+		const entryIds = /* @__PURE__ */ new Set();
+		for (const entry of entries.slice(0, remaining.maxEntries)) {
+			if (ctx.signal?.aborted) throw new _agentium_core.RunCancelledError();
+			if (Date.now() >= deadline) {
+				diagnostics.push({
+					sourceId: source.id,
+					code: "deadline",
+					message: "Shared context retrieval deadline expired"
+				});
+				break;
+			}
+			if (!entry || typeof entry.id !== "string" || !entry.id || entryIds.has(entry.id) || typeof entry.text !== "string" || entry.expiresAt !== void 0 && !Number.isFinite(entry.expiresAt)) {
+				diagnostics.push({
+					sourceId: source.id,
+					code: "invalid",
+					message: "Invalid or duplicate context entry was discarded"
+				});
+				continue;
+			}
+			if (entry.source && (typeof entry.source.uri !== "string" || entry.source.version !== void 0 && typeof entry.source.version !== "string" || entry.source.locator !== void 0 && typeof entry.source.locator !== "string")) {
+				diagnostics.push({
+					sourceId: source.id,
+					entryId: entry.id,
+					code: "invalid",
+					message: "Invalid context source provenance was discarded"
+				});
+				continue;
+			}
+			entryIds.add(entry.id);
+			if (entry.expiresAt !== void 0 && entry.expiresAt <= Date.now()) {
+				diagnostics.push({
+					sourceId: source.id,
+					entryId: entry.id,
+					code: "expired",
+					message: "Expired context entry was discarded"
+				});
+				continue;
+			}
+			if (entry.trust !== "source") diagnostics.push({
+				sourceId: source.id,
+				entryId: entry.id,
+				code: "trust_downgraded",
+				message: "Retrieved context is always source data; host trust declarations are ignored"
+			});
+			const fits = (message) => {
+				const text = message.content;
+				return Buffer.byteLength(text, "utf8") <= budget.maxBytes - bytes && (budget.maxTokens === void 0 || (0, _agentium_core.countTokens)(text) <= budget.maxTokens - tokens);
+			};
+			let message = sourceMessage(source.id, entry, entry.text);
+			if (!fits(message)) {
+				if (!fits(sourceMessage(source.id, entry, ""))) {
+					diagnostics.push({
+						sourceId: source.id,
+						entryId: entry.id,
+						code: "budget",
+						message: "Context entry metadata exceeds the remaining budget"
+					});
+					continue;
+				}
+				let low = 0;
+				let high = entry.text.length;
+				while (low < high) {
+					const middle = Math.ceil((low + high) / 2);
+					if (fits(sourceMessage(source.id, entry, entry.text.slice(0, middle)))) low = middle;
+					else high = middle - 1;
+				}
+				if (low > 0 && /[\uD800-\uDBFF]/.test(entry.text[low - 1])) low--;
+				message = sourceMessage(source.id, entry, entry.text.slice(0, low));
+				diagnostics.push({
+					sourceId: source.id,
+					entryId: entry.id,
+					code: "truncated",
+					message: "Context text truncated to the shared byte/token budget (tokens estimated)"
+				});
+			}
+			messages.push(message);
+			bytes += Buffer.byteLength(message.content, "utf8");
+			tokens += (0, _agentium_core.countTokens)(message.content);
+		}
+	}
+	return {
+		messages,
+		diagnostics
+	};
+}
+//#endregion
+//#region src/runtime/events.ts
+var HarnessEventGapError = class extends Error {
+	earliestCursor;
+	code = "event_gap";
+	constructor(earliestCursor) {
+		super(`Event history gap; earliest available cursor is ${earliestCursor}`);
+		this.earliestCursor = earliestCursor;
+	}
+};
+/** Bounded in-process history; no durability, network delivery, or audio backpressure promise. */
+var InMemoryHarnessEventStore = class {
+	identity;
+	capacity;
+	durable = false;
+	history = [];
+	sequence = 0;
+	finished = false;
+	listeners = /* @__PURE__ */ new Set();
+	constructor(identity, capacity = 256) {
+		this.identity = identity;
+		this.capacity = capacity;
+		if (!Number.isInteger(capacity) || capacity < 2) throw new Error("Event capacity must be an integer >= 2");
+	}
+	get cursor() {
+		return this.sequence;
+	}
+	append(payload) {
+		if (this.finished) throw new Error("Event stream is already terminal");
+		const event = {
+			...this.identity,
+			schemaVersion: 1,
+			eventId: (0, node_crypto.randomUUID)(),
+			sequence: ++this.sequence,
+			timestamp: Date.now(),
+			payload: structuredClone(payload)
+		};
+		this.history.push(event);
+		if (this.history.length > this.capacity) this.history.shift();
+		if (payload.type === "run.terminal") this.finished = true;
+		for (const notify of this.listeners) notify();
+		return structuredClone(event);
+	}
+	events(options = {}) {
+		let cursor = options.after ?? 0;
+		if (!Number.isInteger(cursor) || cursor < 0 || cursor > this.sequence) throw new Error("Invalid event cursor");
+		let closed = false;
+		let queued = Promise.resolve();
+		let wake;
+		const close = () => {
+			closed = true;
+			if (wake) {
+				this.listeners.delete(wake);
+				wake();
+				wake = void 0;
+			}
+		};
+		return {
+			[Symbol.asyncIterator]() {
+				return this;
+			},
+			[Symbol.asyncDispose]: async () => {
+				close();
+			},
+			next: () => {
+				const result = queued.then(async () => {
+					while (!closed) {
+						const earliest = this.history[0]?.sequence ?? 1;
+						if (cursor < earliest - 1) {
+							close();
+							throw new HarnessEventGapError(earliest - 1);
+						}
+						const next = this.history.find((event) => event.sequence > cursor);
+						if (next) {
+							cursor = next.sequence;
+							return {
+								value: structuredClone(next),
+								done: false
+							};
+						}
+						if (this.finished) break;
+						await new Promise((resolve) => {
+							wake = resolve;
+							this.listeners.add(resolve);
+						});
+						if (wake) this.listeners.delete(wake);
+						wake = void 0;
+					}
+					close();
+					return {
+						value: void 0,
+						done: true
+					};
+				});
+				queued = result.catch(() => {});
+				return result;
+			},
+			return: async () => {
+				close();
+				return {
+					value: void 0,
+					done: true
+				};
+			},
+			throw: async (error) => {
+				close();
+				throw error;
+			}
+		};
+	}
+};
+//#endregion
+//#region src/runtime/runtime-registry.ts
+/** Registry resolution is static; it never initializes providers or executes drivers. */
+function resolveHarnessRuntime(definition) {
+	const references = definition.kind === "portable" ? definition.manifest.runtime : definition.runtimeReferences;
+	const direct = definition.kind === "local" ? definition.runtime : void 0;
+	const result = {
+		...direct,
+		modelRoles: direct?.modelRoles ?? references?.modelRoles
+	};
+	for (const key of [
+		"driver",
+		"controller",
+		"contextPolicy",
+		"completionPolicy"
+	]) {
+		const reference = references?.[key];
+		if (!reference) continue;
+		const matches = (definition.runtimeRegistry?.[key] ?? []).filter((entry) => entry.id === reference.id && entry.version === reference.version);
+		if (matches.length !== 1) throw new Error(`runtime.${key}: expected exactly one approved registry implementation for ${reference.id}@${reference.version}`);
+		const implementation = matches[0].implementation;
+		if (direct?.[key] && direct[key] !== implementation) throw new Error(`runtime.${key}: direct binding differs from its approved export mapping`);
+		result[key] = implementation;
+	}
+	return Object.freeze(result);
+}
+//#endregion
+//#region src/runtime/resolve.ts
+var HarnessValidationError = class extends Error {
+	diagnostics;
+	constructor(path, message, code = "invalid_harness") {
+		super(`${path}: ${message}`);
+		this.name = "HarnessValidationError";
+		this.diagnostics = [{
+			code,
+			path,
+			message,
+			severity: "error"
+		}];
+	}
+};
+const generatedIds = /* @__PURE__ */ new WeakSet();
+const definitions = /* @__PURE__ */ new WeakSet();
+const metadata = /* @__PURE__ */ new WeakMap();
+const secretKeys = /* @__PURE__ */ new Set([
+	"apikey",
+	"password",
+	"secret",
+	"authorization",
+	"accesstoken",
+	"refreshtoken",
+	"clientsecret",
+	"privatekey",
+	"credentials"
+]);
+function fail(path, message) {
+	throw new HarnessValidationError(path, message);
+}
+function object(input, path) {
+	if (!input || typeof input !== "object" || Array.isArray(input) || ![Object.prototype, null].includes(Object.getPrototypeOf(input))) fail(path, "expected a plain object");
+	return input;
+}
+function keys(input, allowed, path) {
+	for (const key of Object.keys(input)) if (!allowed.includes(key)) fail(`${path}.${key}`, "unknown field");
+}
+function id(input, path) {
+	if (typeof input !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:/-]*$/.test(input)) fail(path, "expected a stable nonempty identifier");
+	return input;
+}
+function integer(input, path, min = 0) {
+	if (typeof input !== "number" || !Number.isFinite(input) || !Number.isInteger(input) || input < min) fail(path, `expected an integer >= ${min}`);
+	return input;
+}
+function json(input, path, seen = /* @__PURE__ */ new Set()) {
+	if (input === null || typeof input === "boolean" || typeof input === "string") return input;
+	if (typeof input === "number" && Number.isFinite(input)) return input;
+	if (typeof input !== "object" || input === null) fail(path, "expected JSON data");
+	if (seen.has(input)) fail(path, "cyclic data is not portable");
+	seen.add(input);
+	try {
+		if (Array.isArray(input)) {
+			if (Object.getOwnPropertySymbols(input).length || Object.keys(input).some((key) => !/^(0|[1-9][0-9]*)$/.test(key))) fail(path, "array properties are not portable");
+			return Array.from({ length: input.length }, (_, index) => {
+				const descriptor = Object.getOwnPropertyDescriptor(input, index);
+				if (!descriptor || !("value" in descriptor)) fail(`${path}[${index}]`, "sparse arrays and accessors are not portable");
+				return json(descriptor.value, `${path}[${index}]`, seen);
+			});
+		}
+		const source = object(input, path);
+		if (Object.getOwnPropertySymbols(source).length) fail(path, "symbol properties are not portable");
+		const result = {};
+		for (const key of Object.keys(source)) {
+			if (secretKeys.has(key.replace(/[_-]/g, "").toLowerCase())) fail(`${path}.${key}`, "credentials belong in host bindings");
+			const descriptor = Object.getOwnPropertyDescriptor(source, key);
+			if (!("value" in descriptor)) fail(`${path}.${key}`, "accessors are not portable");
+			Object.defineProperty(result, key, {
+				value: json(descriptor.value, `${path}.${key}`, seen),
+				enumerable: true,
+				writable: true,
+				configurable: true
+			});
+		}
+		return result;
+	} finally {
+		seen.delete(input);
+	}
+}
+function freeze(value) {
+	if (value && typeof value === "object" && !Object.isFrozen(value)) {
+		for (const child of Object.values(value)) freeze(child);
+		Object.freeze(value);
+	}
+	return value;
+}
+function validateDefaults(input, path = "defaults") {
+	const data = object(json(input, path), path);
+	keys(data, [
+		"workspace",
+		"skillDirs",
+		"contextFiles",
+		"filesystem",
+		"subagents",
+		"fileMemory",
+		"searchPastSessions"
+	], path);
+	for (const [key, value] of Object.entries(data)) if (key === "workspace") {
+		if (value === false) continue;
+		const workspace = object(value, `${path}.workspace`);
+		keys(workspace, ["path", "mode"], `${path}.workspace`);
+		if (typeof workspace.path !== "string" || !workspace.path.length || !["read", "write"].includes(workspace.mode)) fail(`${path}.workspace`, "expected a path and read/write mode");
+	} else if (key === "skillDirs") {
+		if (value !== false && (!Array.isArray(value) || value.some((item) => typeof item !== "string" || !item.length))) fail(`${path}.skillDirs`, "expected a list of paths or false");
+	} else if (typeof value !== "boolean") fail(`${path}.${key}`, "expected a boolean");
+	return data;
+}
+function validateLimits(input, path = "limits") {
+	const data = object(json(input, path), path);
+	keys(data, ["toolRoundtrips", "maxChildDepth"], path);
+	for (const [key, value] of Object.entries(data)) integer(value, `${path}.${key}`);
+	return data;
+}
+function validateSelection(input, path) {
+	const data = object(input, path);
+	keys(data, [
+		"instanceId",
+		"type",
+		"version",
+		"options"
+	], path);
+	return {
+		instanceId: id(data.instanceId, `${path}.instanceId`),
+		type: id(data.type, `${path}.type`),
+		version: integer(data.version, `${path}.version`, 1),
+		options: object(json(data.options, `${path}.options`), `${path}.options`)
+	};
+}
+function validateRuntimeReferences(input, path = "runtime") {
+	const data = object(json(input, path), path);
+	keys(data, [
+		"driver",
+		"controller",
+		"contextPolicy",
+		"completionPolicy",
+		"modelRoles"
+	], path);
+	for (const [key, value] of Object.entries(data)) {
+		const item = object(value, `${path}.${key}`);
+		if (key === "modelRoles") for (const [role, name] of Object.entries(item)) {
+			id(role, `${path}.modelRoles`);
+			id(name, `${path}.modelRoles.${role}`);
+		}
+		else {
+			keys(item, ["id", "version"], `${path}.${key}`);
+			id(item.id, `${path}.${key}.id`);
+			integer(item.version, `${path}.${key}.version`, 1);
+		}
+	}
+	return freeze(data);
+}
+function validateHarnessManifest(input) {
+	const data = object(json(input, "manifest"), "manifest");
+	keys(data, [
+		"contractVersion",
+		"id",
+		"abilities",
+		"defaults",
+		"limits",
+		"runtime"
+	], "manifest");
+	if (data.contractVersion !== 1) fail("manifest.contractVersion", "unsupported contract version");
+	if (!Array.isArray(data.abilities)) fail("manifest.abilities", "expected an array");
+	const abilities = data.abilities.map((ability, index) => validateSelection(ability, `manifest.abilities[${index}]`));
+	unique(abilities.map((ability) => ability.instanceId), "manifest.abilities");
+	return freeze({
+		contractVersion: 1,
+		id: id(data.id, "manifest.id"),
+		abilities,
+		...data.runtime !== void 0 ? { runtime: validateRuntimeReferences(data.runtime) } : {},
+		...data.defaults !== void 0 ? { defaults: validateDefaults(data.defaults) } : {},
+		...data.limits !== void 0 ? { limits: validateLimits(data.limits) } : {}
+	});
+}
+function unique(values, path) {
+	if (new Set(values).size !== values.length) fail(path, "duplicate identifiers");
+}
+function registry(factories) {
+	if (!Array.isArray(factories)) fail("factories", "expected an approved factory registry");
+	const map = /* @__PURE__ */ new Map();
+	for (const factory of factories) {
+		if (!factory || typeof factory !== "object") fail("factory", "expected a trusted factory");
+		id(factory.type, "factory.type");
+		integer(factory.version, "factory.version", 1);
+		if (typeof factory.validateOptions !== "function" || typeof factory.describe !== "function" || typeof factory.bind !== "function") fail("factory", "missing validation, description or binding function");
+		const key = `${factory.type}@${factory.version}`;
+		if (map.has(key) && map.get(key) !== factory) fail("factories", "conflicting implementations for a registered type/version");
+		map.set(key, factory);
+	}
+	return map;
+}
+function snapshotRuntimeRegistry(input) {
+	keys(object(input, "runtimeRegistry"), [
+		"driver",
+		"controller",
+		"contextPolicy",
+		"completionPolicy"
+	], "runtimeRegistry");
+	const result = {};
+	for (const [key, entries] of Object.entries(input)) {
+		if (!Array.isArray(entries)) fail(`runtimeRegistry.${key}`, "expected approved registry entries");
+		const names = [];
+		result[key] = Object.freeze(entries.map((entry) => {
+			id(entry.id, `runtimeRegistry.${key}.id`);
+			integer(entry.version, `runtimeRegistry.${key}.version`, 1);
+			names.push(`${entry.id}@${entry.version}`);
+			if (!entry.implementation || typeof entry.implementation !== "object") fail(`runtimeRegistry.${key}`, "missing trusted implementation");
+			return Object.freeze({ ...entry });
+		}));
+		unique(names, `runtimeRegistry.${key}`);
+	}
+	return Object.freeze(result);
+}
+function normalizePortable(manifest, factories, runtimeRegistry) {
+	const approved = registry(factories);
+	const abilities = manifest.abilities.map((selection, index) => {
+		const factory = approved.get(`${selection.type}@${selection.version}`);
+		if (!factory) fail(`manifest.abilities[${index}]`, "no approved factory for ability type/version");
+		let options;
+		try {
+			options = factory.validateOptions(json(selection.options, "options"));
+		} catch {
+			fail(`manifest.abilities[${index}].options`, "ability option validation failed");
+		}
+		return {
+			...selection,
+			options: object(json(options, `manifest.abilities[${index}].options`), "options")
+		};
+	});
+	const definition = Object.freeze({
+		kind: "portable",
+		manifest: validateHarnessManifest({
+			...manifest,
+			abilities
+		}),
+		factories: Object.freeze([...approved.values()]),
+		...runtimeRegistry ? { runtimeRegistry: snapshotRuntimeRegistry(runtimeRegistry) } : {}
+	});
+	resolveHarnessRuntime(definition);
+	definitions.add(definition);
+	return definition;
+}
+function loadHarnessManifest(input, factories, runtimeRegistry) {
+	return normalizePortable(validateHarnessManifest(input), factories, runtimeRegistry);
+}
+function createHarnessDefinition(input) {
+	object(input, "definition");
+	if (definitions.has(input)) return input;
+	if ("kind" in input && input.kind === "portable") {
+		keys(object(input, "definition"), [
+			"kind",
+			"manifest",
+			"factories",
+			"runtimeRegistry"
+		], "definition");
+		return loadHarnessManifest(input.manifest, input.factories, input.runtimeRegistry);
+	}
+	const local = input;
+	keys(object(input, "definition"), [
+		"kind",
+		"id",
+		"abilities",
+		"defaults",
+		"limits",
+		"runtime",
+		"runtimeReferences",
+		"runtimeRegistry"
+	], "definition");
+	if ("kind" in input && input.kind !== "local") fail("definition.kind", "unsupported definition kind");
+	if (local.abilities !== void 0 && !Array.isArray(local.abilities)) fail("abilities", "expected an ability list");
+	const abilities = [...local.abilities ?? []].map((use, index) => {
+		if (!use || typeof use !== "object") fail(`abilities[${index}]`, "expected an ability use");
+		id(use.instanceId, `abilities[${index}].instanceId`);
+		if (typeof use.validate !== "function" || typeof use.describe !== "function" || typeof use.bind !== "function") fail(`abilities[${index}]`, "missing validation, description or binding function");
+		try {
+			use.validate();
+		} catch {
+			fail(`abilities[${index}]`, "ability option validation failed");
+		}
+		const portable = use.portable ? freeze(validateSelection(json(use.portable, `abilities[${index}].portable`), `abilities[${index}].portable`)) : void 0;
+		if (portable && portable.instanceId !== use.instanceId) fail(`abilities[${index}].portable.instanceId`, "portable and local IDs must match");
+		if (portable && use.factory && (portable.type !== use.factory.type || portable.version !== use.factory.version)) fail(`abilities[${index}].factory`, "factory mapping does not match selection");
+		return Object.freeze({
+			...use,
+			...portable ? { portable } : {}
+		});
+	});
+	unique(abilities.map((use) => use.instanceId), "abilities");
+	registry(abilities.flatMap((use) => use.factory ? [use.factory] : []));
+	const definition = Object.freeze({
+		kind: "local",
+		id: local.id === void 0 ? `local-${(0, node_crypto.randomUUID)()}` : id(local.id, "definition.id"),
+		abilities: Object.freeze(abilities),
+		...local.runtime ? { runtime: Object.freeze({ ...local.runtime }) } : {},
+		...local.runtimeReferences ? { runtimeReferences: validateRuntimeReferences(local.runtimeReferences) } : {},
+		...local.runtimeRegistry ? { runtimeRegistry: snapshotRuntimeRegistry(local.runtimeRegistry) } : {},
+		...local.defaults !== void 0 ? { defaults: freeze(validateDefaults(local.defaults)) } : {},
+		...local.limits !== void 0 ? { limits: freeze(validateLimits(local.limits)) } : {}
+	});
+	resolveHarnessRuntime(definition);
+	definitions.add(definition);
+	if (local.id === void 0 || generatedIds.has(input)) generatedIds.add(definition);
+	metadata.set(definition, metadata.get(input) ?? {
+		provenance: [
+			...Object.keys(local.defaults ?? {}).map((key) => ({
+				path: `defaults.${key}`,
+				origin: definition.id
+			})),
+			...Object.keys(local.limits ?? {}).map((key) => ({
+				path: `limits.${key}`,
+				origin: definition.id
+			})),
+			...abilities.map((use) => ({
+				path: `abilities.${use.instanceId}`,
+				origin: definition.id
+			}))
+		],
+		diagnostics: []
+	});
+	return definition;
+}
+function asLocal(definition) {
+	if (definition.kind === "local") return definition;
+	const approved = registry(definition.factories);
+	return {
+		kind: "local",
+		id: definition.manifest.id,
+		defaults: definition.manifest.defaults,
+		limits: definition.manifest.limits,
+		runtimeReferences: definition.manifest.runtime,
+		runtimeRegistry: definition.runtimeRegistry,
+		abilities: definition.manifest.abilities.map((selection) => {
+			const factory = approved.get(`${selection.type}@${selection.version}`);
+			return {
+				instanceId: selection.instanceId,
+				portable: selection,
+				factory,
+				validate: () => {},
+				describe: () => factory.describe(selection.options),
+				bind: (ctx) => factory.bind(selection.options, ctx)
+			};
+		})
+	};
+}
+function extendHarnessDefinition(base, extension) {
+	keys(object(extension, "extension"), [
+		"id",
+		"abilities",
+		"disable",
+		"replaceAbilities",
+		"defaults",
+		"limits",
+		"runtime",
+		"runtimeReferences",
+		"runtimeRegistry"
+	], "extension");
+	const source = asLocal(createHarnessDefinition(base));
+	const disabled = new Set(extension.disable ?? []);
+	unique([...extension.disable ?? []], "extension.disable");
+	for (const target of disabled) if (!source.abilities.some((use) => use.instanceId === target)) fail("extension.disable", "unknown ability identifier");
+	const replacements = new Map((extension.replaceAbilities ?? []).map((use) => [use.instanceId, use]));
+	unique([...(extension.replaceAbilities ?? []).map((use) => use.instanceId)], "extension.replaceAbilities");
+	for (const target of replacements.keys()) if (disabled.has(target) || !source.abilities.some((use) => use.instanceId === target)) fail("extension.replaceAbilities", "replacement must match an enabled existing ability");
+	const defaults = {
+		...source.defaults,
+		...extension.defaults ? validateDefaults(extension.defaults) : {}
+	};
+	if (extension.defaults?.skillDirs && source.defaults?.skillDirs) defaults.skillDirs = [.../* @__PURE__ */ new Set([...source.defaults.skillDirs, ...extension.defaults.skillDirs])];
+	const definition = createHarnessDefinition({
+		id: extension.id ?? source.id,
+		runtime: {
+			...source.runtime,
+			...extension.runtime
+		},
+		runtimeReferences: extension.runtimeReferences ?? source.runtimeReferences,
+		runtimeRegistry: extension.runtimeRegistry ?? source.runtimeRegistry,
+		abilities: [...source.abilities.filter((use) => !disabled.has(use.instanceId)).map((use) => replacements.get(use.instanceId) ?? use), ...extension.abilities ?? []],
+		defaults,
+		limits: {
+			...source.limits,
+			...extension.limits ? validateLimits(extension.limits) : {}
+		}
+	});
+	if (generatedIds.has(base) && !extension.id) generatedIds.add(definition);
+	const previous = metadata.get(base);
+	const origin = extension.id ?? source.id ?? "local";
+	metadata.set(definition, {
+		provenance: [
+			...previous?.provenance ?? [],
+			...Object.keys(extension.defaults ?? {}).map((key) => ({
+				path: `defaults.${key}`,
+				origin
+			})),
+			...Object.keys(extension.limits ?? {}).map((key) => ({
+				path: `limits.${key}`,
+				origin
+			}))
+		],
+		diagnostics: [...previous?.diagnostics ?? [], ...[...disabled].map((instanceId) => ({
+			code: "ability_disabled",
+			path: `abilities.${instanceId}`,
+			message: "Ability explicitly disabled",
+			severity: "info"
+		}))]
+	});
+	return definition;
+}
+function abilityDescription(input, path) {
+	if (!input || !Array.isArray(input.toolNames) || !Array.isArray(input.requirements)) fail(path, "expected tool and requirement declarations");
+	for (const name of input.toolNames) id(name, `${path}.toolNames`);
+	for (const requirement of input.requirements) id(requirement, `${path}.requirements`);
+	unique(input.toolNames, `${path}.toolNames`);
+	if (input.runtimeDependent !== void 0 && typeof input.runtimeDependent !== "boolean") fail(path, "invalid runtimeDependent declaration");
+	return {
+		toolNames: [...input.toolNames],
+		requirements: [...new Set(input.requirements)],
+		...input.runtimeDependent !== void 0 ? { runtimeDependent: input.runtimeDependent } : {}
+	};
+}
+function describeHarnessDefinition(input) {
+	const definition = createHarnessDefinition(input);
+	const local = asLocal(definition);
+	const abilities = local.abilities.map((use, index) => {
+		let description;
+		try {
+			description = use.describe();
+		} catch {
+			fail(`abilities[${index}]`, "ability description failed");
+		}
+		return {
+			instanceId: use.instanceId,
+			...use.portable ? {
+				type: use.portable.type,
+				version: use.portable.version
+			} : {},
+			...abilityDescription(description, `abilities[${index}]`)
+		};
+	});
+	return freeze({
+		id: local.id,
+		kind: definition.kind,
+		contractVersion: 1,
+		abilities,
+		toolNames: abilities.flatMap((ability) => [...ability.toolNames]),
+		requirements: [...new Set(abilities.flatMap((ability) => [...ability.requirements]))],
+		runtimeDependent: abilities.some((ability) => ability.runtimeDependent),
+		defaults: local.defaults ?? {},
+		limits: local.limits ?? {},
+		diagnostics: metadata.get(input)?.diagnostics ?? []
+	});
+}
+function resolveHarness(input, options) {
+	if (typeof options.projectRoot !== "string" || !(0, node_path.isAbsolute)(options.projectRoot)) fail("projectRoot", "an absolute host project root is required");
+	const definition = createHarnessDefinition(input);
+	const description = describeHarnessDefinition(definition);
+	const provided = new Set(options.requirements ?? []);
+	for (const requirement of description.requirements) if (!provided.has(requirement)) fail(`requirements.${requirement}`, "missing host-provided requirement");
+	const defaults = { ...description.defaults };
+	if (defaults.workspace) defaults.workspace = typeof defaults.workspace === "string" ? {
+		path: (0, node_path.resolve)(options.projectRoot, defaults.workspace),
+		mode: "read"
+	} : {
+		...defaults.workspace,
+		path: (0, node_path.resolve)(options.projectRoot, defaults.workspace.path)
+	};
+	if (defaults.skillDirs) defaults.skillDirs = [...new Set(defaults.skillDirs.map((path) => (0, node_path.resolve)(options.projectRoot, path)))];
+	const provenance = metadata.get(input)?.provenance ?? [
+		...Object.keys(defaults).map((key) => ({
+			path: `defaults.${key}`,
+			origin: description.id
+		})),
+		...Object.keys(description.limits).map((key) => ({
+			path: `limits.${key}`,
+			origin: description.id
+		})),
+		...description.abilities.map((ability) => ({
+			path: `abilities.${ability.instanceId}`,
+			origin: description.id
+		}))
+	];
+	return Object.freeze({
+		definition,
+		defaults: freeze(defaults),
+		limits: description.limits,
+		description,
+		provenance: freeze([...provenance])
+	});
+}
+function exportHarnessManifest(input) {
+	const definition = createHarnessDefinition(input);
+	if (definition.kind === "portable") return definition.manifest;
+	if (generatedIds.has(input) || generatedIds.has(definition)) fail("definition.id", "an explicit stable ID is required for export");
+	for (const key of [
+		"driver",
+		"controller",
+		"contextPolicy",
+		"completionPolicy"
+	]) if (definition.runtime?.[key] && !definition.runtimeReferences?.[key]) fail(`runtime.${key}`, "approved registry reference required for export");
+	resolveHarnessRuntime(definition);
+	const abilities = definition.abilities.map((use, index) => {
+		if (!use.portable || !use.factory) fail(`abilities[${index}]`, "portable selection and approved factory mapping required for export");
+		return use.portable;
+	});
+	return normalizePortable(validateHarnessManifest({
+		contractVersion: 1,
+		id: definition.id,
+		abilities,
+		...definition.runtimeReferences || definition.runtime?.modelRoles ? { runtime: {
+			...definition.runtimeReferences,
+			...definition.runtime?.modelRoles ? { modelRoles: definition.runtime.modelRoles } : {}
+		} } : {},
+		...definition.defaults !== void 0 ? { defaults: definition.defaults } : {},
+		...definition.limits !== void 0 ? { limits: definition.limits } : {}
+	}), definition.abilities.map((use) => use.factory), definition.runtimeRegistry).manifest;
+}
+function canonical(value) {
+	if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+	if (value !== null && typeof value === "object") return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+function hashHarnessManifest(input) {
+	return (0, node_crypto.createHash)("sha256").update(canonical(validateHarnessManifest(input)), "utf8").digest("hex");
+}
+async function bindHarness(resolved, ctx) {
+	const local = asLocal(resolved.definition);
+	const bindings = [];
+	const diagnostics = [];
+	let disposing;
+	const dispose = () => disposing ??= (async () => {
+		for (let index = bindings.length - 1; index >= 0; index--) try {
+			await bindings[index].dispose?.();
+		} catch {
+			diagnostics.push({
+				code: "cleanup_failed",
+				path: `abilities[${index}]`,
+				message: "Ability cleanup failed",
+				severity: "warning"
+			});
+		}
+		return freeze([...diagnostics]);
+	})();
+	try {
+		for (const [index, ability] of local.abilities.entries()) {
+			if (ctx.signal?.aborted) fail(`abilities[${index}]`, "run cancelled before binding");
+			const binding = await ability.bind(ctx);
+			if (binding && typeof binding === "object") bindings.push(binding);
+			if (!binding || !Array.isArray(binding.tools)) fail(`abilities[${index}]`, "binding must contain tools");
+			if (ctx.signal?.aborted) fail(`abilities[${index}]`, "run cancelled during binding");
+		}
+		const tools = bindings.flatMap((binding) => [...binding.tools]);
+		const promptFragments = bindings.flatMap((binding) => [...binding.promptFragments ?? []]);
+		const contextSources = bindings.flatMap((binding) => [...binding.contextSources ?? []]);
+		const middleware = bindings.flatMap((binding) => [...binding.middleware ?? []]);
+		unique(tools.map((tool) => id(tool.name, "tools.name")), "tools");
+		unique(promptFragments.map((fragment) => id(fragment.id, "promptFragments.id")), "promptFragments");
+		unique(contextSources.map((source) => id(source.id, "contextSources.id")), "contextSources");
+		unique(middleware.map((item) => id(item.id, "middleware.id")), "middleware");
+		for (const tool of tools) if (typeof tool.execute !== "function" || !tool.parameters || ("_zod" in tool.parameters ? tool.parameters._zod.def.type !== "object" : typeof tool.parameters.safeParse !== "function")) fail("tools", "invalid tool binding");
+		for (const fragment of promptFragments) if (typeof fragment.text !== "string") fail("promptFragments", "expected text");
+		for (const source of contextSources) if (typeof source.fetch !== "function") fail("contextSources", "missing fetch function");
+		return {
+			tools,
+			promptFragments,
+			contextSources,
+			middleware: sortHarnessMiddleware(middleware),
+			dispose
+		};
+	} catch (error) {
+		await dispose();
+		if (error instanceof Error && diagnostics.length) try {
+			Object.defineProperty(error, "cleanupDiagnostics", { value: [...diagnostics] });
+		} catch {}
+		throw error;
+	}
+}
+//#endregion
+//#region src/runtime/session-bindings.ts
+var HarnessSessionConflict = class extends Error {
+	code = "session_conflict";
+	constructor() {
+		super("A writer already owns this tenant/session");
+	}
+};
+function harnessSessionKey(identity, sessionId) {
+	return JSON.stringify([
+		identity.tenantId,
+		identity.userId,
+		sessionId
+	]);
+}
+/** One writer per scoped session; deliberately rejects rather than silently interleaving. */
+var InMemoryHarnessSessionStore = class {
+	guarantees = {
+		durable: false,
+		compareAndSwap: false,
+		singleWriter: "process"
+	};
+	records = /* @__PURE__ */ new Map();
+	active = /* @__PURE__ */ new Set();
+	async acquire(identity, sessionId) {
+		const key = harnessSessionKey(identity, sessionId);
+		if (this.active.has(key)) throw new HarnessSessionConflict();
+		this.active.add(key);
+		let released = false;
+		const check = () => {
+			if (released) throw new Error("Session lease has been released");
+		};
+		return {
+			read: () => {
+				check();
+				return structuredClone(this.records.get(key) ?? {
+					history: [],
+					state: {},
+					revision: 0,
+					replayable: true
+				});
+			},
+			commit: (snapshot) => {
+				check();
+				const revision = (this.records.get(key)?.revision ?? 0) + 1;
+				this.records.set(key, structuredClone({
+					...snapshot,
+					revision
+				}));
+			},
+			release: () => {
+				if (!released) {
+					released = true;
+					this.active.delete(key);
+				}
+			}
+		};
+	}
+	/** Imported display-only transcripts are readable but never represented as complete replay state. */
+	importLegacy(identity, sessionId, history) {
+		const key = harnessSessionKey(identity, sessionId);
+		if (this.active.has(key)) throw new HarnessSessionConflict();
+		this.records.set(key, {
+			history: structuredClone(history),
+			state: {},
+			revision: 0,
+			replayable: false
+		});
+	}
+};
+/** Session resources live until explicit closeSession; run resources use their returned lease. */
+var HarnessResourcePool = class {
+	sessions = /* @__PURE__ */ new Map();
+	pending = /* @__PURE__ */ new Map();
+	async acquire(identity, sessionId, id, scope, initialize) {
+		if (scope === "run" || scope === "host") {
+			const resource = await initialize();
+			if (scope === "host" && resource.ownership !== "host") {
+				try {
+					await resource.dispose?.();
+				} catch {}
+				throw new Error("Host resources must be externally owned");
+			}
+			let released = false;
+			return {
+				value: resource.value,
+				release: async () => {
+					if (!released) {
+						released = true;
+						if (resource.ownership === "runtime") await resource.dispose?.();
+					}
+				}
+			};
+		}
+		const key = harnessSessionKey(identity, sessionId);
+		let resources = this.sessions.get(key);
+		if (!resources) {
+			resources = /* @__PURE__ */ new Map();
+			this.sessions.set(key, resources);
+		}
+		let entry = resources.get(id);
+		if (!entry) {
+			const pendingKey = JSON.stringify([key, id]);
+			let promise = this.pending.get(pendingKey);
+			if (!promise) {
+				promise = initialize();
+				this.pending.set(pendingKey, promise);
+			}
+			try {
+				const resource = await promise;
+				entry = resources.get(id);
+				if (!entry) {
+					entry = {
+						resource,
+						users: 0
+					};
+					resources.set(id, entry);
+				}
+			} finally {
+				this.pending.delete(pendingKey);
+			}
+		}
+		entry.users++;
+		let released = false;
+		return {
+			value: entry.resource.value,
+			release: async () => {
+				if (!released) {
+					released = true;
+					entry.users--;
+				}
+			}
+		};
+	}
+	async closeSession(identity, sessionId) {
+		const key = harnessSessionKey(identity, sessionId);
+		const resources = this.sessions.get(key);
+		if (!resources) return [];
+		if ([...resources.values()].some((entry) => entry.users > 0) || [...this.pending.keys()].some((pending) => JSON.parse(pending)[0] === key)) throw new HarnessSessionConflict();
+		this.sessions.delete(key);
+		const failures = [];
+		for (const [id, entry] of [...resources].reverse()) try {
+			if (entry.resource.ownership === "runtime") await entry.resource.dispose?.();
+		} catch {
+			failures.push(id);
+		}
+		return failures;
+	}
+};
+//#endregion
+//#region src/runtime/driver.ts
+var HarnessUnsupportedError = class extends Error {
+	operation;
+	code = "unsupported";
+	constructor(operation) {
+		super(`Unsupported harness operation: ${operation}`);
+		this.operation = operation;
+	}
+};
+var HarnessBudgetError = class extends Error {
+	code = "budget_exhausted";
+	constructor(message) {
+		super(message);
+	}
+};
+const zero = () => ({
+	promptTokens: 0,
+	completionTokens: 0,
+	totalTokens: 0
+});
+function narrow(base, selected, label) {
+	if (new Set(selected).size !== selected.length || selected.some((value) => !base.includes(value))) throw new Error(`Cannot widen ${label} grants`);
+	return [...selected];
+}
+/** Local lifecycle owner. Custom driver code is trusted; services enforce all intercepted effects. */
+var HarnessRuntime = class {
+	sessions;
+	resources;
+	config;
+	artifacts = /* @__PURE__ */ new Map();
+	getArtifact(identity, sessionId, id) {
+		const entry = this.artifacts.get(id);
+		if (!entry || entry.owner !== harnessSessionKey(identity, sessionId)) return void 0;
+		return structuredClone(entry.value);
+	}
+	constructor(config) {
+		const definition = config.definition ? createHarnessDefinition(config.definition) : void 0;
+		const bindings = definition ? resolveHarnessRuntime(definition) : {};
+		const driver = config.driver ?? bindings.driver;
+		if (!driver) throw new Error("A trusted execution driver is required");
+		config = {
+			...bindings,
+			...config,
+			driver,
+			definition
+		};
+		if (bindings.modelRoles) {
+			config.models = { ...config.models };
+			for (const [role, name] of Object.entries(bindings.modelRoles)) {
+				const binding = config.models[name];
+				if (!binding) throw new Error(`runtime.modelRoles.${role}: missing host model binding ${name}`);
+				config.models = {
+					...config.models,
+					[role]: binding
+				};
+			}
+		}
+		if (!driver.id || !Number.isInteger(driver.version) || driver.version < 1) throw new Error("Invalid execution driver identity");
+		if (driver.capabilities.durable) throw new HarnessUnsupportedError("durable recovery without a recovery adapter");
+		if (driver.capabilities.controls.includes("replace")) throw new HarnessUnsupportedError("interrupt-and-replace without a driver checkpoint adapter");
+		if (driver.capabilities.policyCoverage !== "local" || !driver.capabilities.controlledExecution) throw new HarnessUnsupportedError("mandatory local execution coverage");
+		for (const value of Object.values(config.budgets ?? {})) if (!Number.isInteger(value) || value < 0) throw new Error("Harness budgets must be nonnegative integers");
+		this.config = {
+			...config,
+			projectRoot: (0, node_path.resolve)(config.projectRoot ?? process.cwd()),
+			requirements: config.requirements && Object.freeze([...config.requirements]),
+			budgets: { ...config.budgets },
+			models: Object.fromEntries(Object.entries(config.models ?? {}).map(([role, binding]) => [role, Object.freeze({
+				...binding,
+				options: Object.freeze([...binding.options ?? []])
+			})])),
+			contextPolicy: config.contextPolicy && Object.freeze({
+				id: config.contextPolicy.id,
+				project: config.contextPolicy.project.bind(config.contextPolicy)
+			}),
+			completionPolicy: config.completionPolicy && Object.freeze({
+				id: config.completionPolicy.id,
+				evaluate: config.completionPolicy.evaluate.bind(config.completionPolicy)
+			}),
+			controller: config.controller && Object.freeze({
+				id: config.controller.id,
+				prepareRun: config.controller.prepareRun?.bind(config.controller),
+				prepareStep: config.controller.prepareStep?.bind(config.controller)
+			}),
+			driver: Object.freeze({
+				id: driver.id,
+				version: driver.version,
+				start: driver.start.bind(driver),
+				capabilities: Object.freeze({
+					...driver.capabilities,
+					controls: Object.freeze([...driver.capabilities.controls])
+				})
+			}),
+			tools: [...config.tools ?? []],
+			grants: {
+				toolIds: [...config.grants.toolIds],
+				modelRoles: [...config.grants.modelRoles],
+				requiredToolIds: [...config.grants.requiredToolIds ?? []]
+			}
+		};
+		this.sessions = config.sessionStore ?? new InMemoryHarnessSessionStore();
+		this.resources = config.resources ?? new HarnessResourcePool();
+	}
+	run(input, options) {
+		return this.start(input, options).result();
+	}
+	stream(input, options) {
+		return this.start(input, options).events();
+	}
+	start(input, options) {
+		if (!options.identity?.tenantId || !options.identity.userId || !options.sessionId) throw new Error("Verified tenant, actor and session identity are required");
+		const config = this.config;
+		if (options.runMode !== void 0 && options.runMode !== "execute" && options.runMode !== "plan") throw new Error("Invalid run mode");
+		const grants = options.grants ? {
+			toolIds: narrow(config.grants.toolIds, options.grants.toolIds, "tool"),
+			modelRoles: narrow(config.grants.modelRoles, options.grants.modelRoles, "model"),
+			requiredToolIds: [.../* @__PURE__ */ new Set([...config.grants.requiredToolIds ?? [], ...options.grants.requiredToolIds ?? []])]
+		} : config.grants;
+		if (grants.requiredToolIds?.some((id) => !grants.toolIds.includes(id))) throw new Error("Required tool omitted by grants");
+		if (options.deadline !== void 0 && !Number.isFinite(options.deadline)) throw new Error("Deadline must be finite");
+		const controller = new AbortController();
+		const runId = (0, node_crypto.randomUUID)();
+		const request = Object.freeze({
+			input: structuredClone(input),
+			identity: Object.freeze({ ...options.identity }),
+			sessionId: options.sessionId,
+			runId,
+			attemptId: (0, node_crypto.randomUUID)(),
+			parentRunId: options.parentRunId,
+			rootRunId: options.rootRunId ?? runId,
+			signal: controller.signal,
+			deadline: options.deadline,
+			grants: Object.freeze({
+				toolIds: Object.freeze([...grants.toolIds]),
+				modelRoles: Object.freeze([...grants.modelRoles]),
+				requiredToolIds: Object.freeze([...grants.requiredToolIds ?? []])
+			}),
+			runMode: options.runMode ?? "execute"
+		});
+		const events = new InMemoryHarnessEventStore({
+			runId,
+			sessionId: request.sessionId,
+			attemptId: request.attemptId,
+			parentRunId: request.parentRunId,
+			rootRunId: request.rootRunId
+		}, config.eventCapacity);
+		const startedAt = Date.now();
+		config.telemetry?.emit("run.start", {
+			runId,
+			agentName: config.driver.id,
+			input: "",
+			sessionId: request.sessionId,
+			tenantId: request.identity.tenantId,
+			userId: request.identity.userId,
+			parentRunId: request.parentRunId,
+			rootRunId: request.rootRunId,
+			attemptId: request.attemptId
+		});
+		const observeControl = async (operation, work) => {
+			const controllerCallId = (0, node_crypto.randomUUID)();
+			const identity = {
+				runId,
+				controllerCallId,
+				operation
+			};
+			config.telemetry?.emit("controller.start", identity);
+			try {
+				const result = await work();
+				controller.signal.throwIfAborted();
+				const decision = result;
+				config.telemetry?.emit("controller.result", {
+					...identity,
+					decision: decision?.stop ? "stop" : decision?.action ?? "continue",
+					modelRole: decision?.modelRole,
+					activeToolCount: decision?.activeToolIds?.length
+				});
+				return result;
+			} catch (error) {
+				config.telemetry?.emit("controller.error", {
+					...identity,
+					status: controller.signal.aborted ? "cancelled" : "error"
+				});
+				throw error;
+			}
+		};
+		const observeModel = (provider) => {
+			const identity = {
+				runId,
+				modelCallId: (0, node_crypto.randomUUID)(),
+				providerId: provider.providerId,
+				modelId: provider.modelId
+			};
+			config.telemetry?.emit("model.start", identity);
+			return (complete, amount) => {
+				if (complete) config.telemetry?.emit("model.result", {
+					...identity,
+					usage: amount,
+					status: "success"
+				});
+				else config.telemetry?.emit("model.error", {
+					...identity,
+					status: controller.signal.aborted ? "cancelled" : "error",
+					...amount ? { usage: amount } : {}
+				});
+			};
+		};
+		const generateObserved = async (provider, messages, supplied) => {
+			const end = observeModel(provider);
+			try {
+				const response = await provider.generate(messages, supplied);
+				end(!controller.signal.aborted, response.usage);
+				return response;
+			} catch (error) {
+				end(false);
+				throw error;
+			}
+		};
+		let terminal = false;
+		const inbox = [];
+		const cancel = (reason = "Run cancelled") => {
+			if (!terminal && !controller.signal.aborted) {
+				events.append({
+					type: "control",
+					operation: "cancel",
+					reason
+				});
+				controller.abort(new Error(reason));
+			}
+		};
+		const onAbort = () => cancel("Caller cancelled the run");
+		const callerSignal = options.signal;
+		callerSignal?.addEventListener("abort", onAbort, { once: true });
+		if (callerSignal?.aborted) onAbort();
+		let timer;
+		const scheduleDeadline = () => {
+			if (request.deadline === void 0 || controller.signal.aborted) return;
+			const remaining = request.deadline - Date.now();
+			if (remaining <= 0) cancel("Run deadline exceeded");
+			else timer = setTimeout(scheduleDeadline, Math.min(remaining, 2147483647));
+		};
+		scheduleDeadline();
+		const result = Promise.resolve().then(async () => {
+			let lease;
+			let bound;
+			const releases = [];
+			const usage = zero();
+			let modelCalls = 0;
+			let reservedTokens = 0;
+			const cleanupDiagnostics = [];
+			let toolCalls = 0;
+			let revision = 0;
+			let currentRole = "main";
+			let prepareDefaults = {};
+			let final = {
+				text: "",
+				status: "failed"
+			};
+			let canonical = [];
+			let conversations = {};
+			let state = {};
+			let replayable = true;
+			let committed = false;
+			let acceptingOperations = true;
+			const owned = /* @__PURE__ */ new Set();
+			const streams = /* @__PURE__ */ new Set();
+			const track = (operation) => {
+				owned.add(operation);
+				operation.then(() => owned.delete(operation), () => owned.delete(operation));
+				return operation;
+			};
+			const ensureActive = () => {
+				if (request.deadline !== void 0 && Date.now() >= request.deadline) cancel("Run deadline exceeded");
+				controller.signal.throwIfAborted();
+				if (!acceptingOperations) throw new Error("Run has finished accepting operations");
+			};
+			const activeTools = /* @__PURE__ */ new Map();
+			try {
+				ensureActive();
+				lease = await this.sessions.acquire(request.identity, request.sessionId);
+				ensureActive();
+				const snapshot = lease.read();
+				canonical = snapshot.history;
+				conversations = snapshot.conversations ?? {};
+				state = snapshot.state;
+				replayable = snapshot.replayable;
+				let policy;
+				let services;
+				const ctx = new _agentium_core.RunContext({
+					executionPolicy: {
+						decide: (call, callCtx) => policy.decide(call, callCtx),
+						resolveEffect: (call, callCtx) => policy.resolveEffect?.(call, callCtx) ?? "unknown"
+					},
+					sessionId: request.sessionId,
+					userId: request.identity.userId,
+					tenantId: request.identity.tenantId,
+					runId,
+					signal: controller.signal,
+					runMode: request.runMode,
+					eventBus: new _agentium_core.EventBus(),
+					sessionState: state,
+					metadata: {
+						parentRunId: request.parentRunId,
+						rootRunId: request.rootRunId
+					}
+				});
+				Object.defineProperty(ctx, "executionServices", {
+					get: () => services,
+					configurable: false
+				});
+				policy = {
+					decide: async (call, callCtx) => {
+						ensureActive();
+						if (!request.grants.toolIds.includes(call.toolName) || activeTools.has(callCtx.runId) && !activeTools.get(callCtx.runId).includes(call.toolName)) return {
+							action: "deny",
+							reason: "Tool is outside the effective grants"
+						};
+						if (revision > 0 && !config.allowRevisionEffects) return {
+							action: "deny",
+							reason: "Completion revisions cannot execute effects without host opt-in"
+						};
+						if (toolCalls >= (config.budgets?.maxToolCalls ?? Infinity)) return {
+							action: "deny",
+							reason: "Aggregate tool budget exhausted"
+						};
+						toolCalls++;
+						return (0, _agentium_core.evaluateExecutionPolicy)(config.executionPolicy, call, callCtx);
+					},
+					resolveEffect: config.executionPolicy?.resolveEffect
+				};
+				const resolved = config.definition ? resolveHarness(config.definition, {
+					projectRoot: config.projectRoot ?? process.cwd(),
+					requirements: config.requirements
+				}) : void 0;
+				if (resolved) bound = await bindHarness(resolved, ctx);
+				ensureActive();
+				const tools = [...config.tools ?? [], ...bound?.tools ?? []];
+				if (new Set(tools.map((tool) => tool.name)).size !== tools.length) throw new Error("Duplicate runtime tool bindings");
+				const executor = new _agentium_core.ToolExecutor(tools, {
+					approvalManager: config.approvalManager,
+					executionPolicy: policy
+				});
+				const sources = bound ? await fetchHarnessContext(bound.contextSources, typeof input === "string" ? input : JSON.stringify(input), ctx) : { messages: [] };
+				const entries = sources.messages.map((message) => {
+					const source = JSON.parse(String(message.content));
+					return {
+						id: source.entryId,
+						text: source.text,
+						trust: "source",
+						source: source.source,
+						byteLength: Buffer.byteLength(source.text)
+					};
+				});
+				const middleware = bound?.middleware ?? [];
+				const prompts = (bound?.promptFragments ?? []).map((fragment) => ({
+					role: "system",
+					content: fragment.text
+				}));
+				const prepare = async (provider, messages, supplied = {}, callCtx = ctx) => {
+					ensureActive();
+					if (modelCalls >= (config.budgets?.maxModelCalls ?? Infinity) || usage.totalTokens >= (config.budgets?.maxTokens ?? Infinity)) throw new HarnessBudgetError("Aggregate model/token budget exhausted");
+					const index = modelCalls++;
+					const next = config.controller?.prepareStep ? await observeControl("prepareStep", () => config.controller.prepareStep({
+						index,
+						tools: supplied.tools ?? []
+					}, callCtx)) : void 0;
+					const overrides = {
+						...prepareDefaults,
+						...next
+					};
+					if (overrides.stop) throw new HarnessBudgetError(overrides.stop.reason);
+					const role = overrides.modelRole ?? "main";
+					if (!request.grants.modelRoles.includes(role)) throw new Error("Controller selected an ungranted model role");
+					const binding = config.models?.[role];
+					const selected = binding?.provider ?? (role === "main" ? provider : void 0);
+					if (!selected) throw new Error("No host model binding for selected role");
+					const active = overrides.activeToolIds ?? (supplied.tools ?? []).map((tool) => tool.name).filter((id) => request.grants.toolIds.includes(id));
+					narrow(request.grants.toolIds, active, "active tool");
+					if (request.grants.requiredToolIds?.some((id) => !active.includes(id))) throw new Error("Controller omitted a required tool");
+					if (active.some((id) => !(supplied.tools ?? []).some((tool) => tool.name === id))) throw new Error("Controller selected an unavailable tool");
+					for (const key of Object.keys(overrides.options ?? {})) if (!binding?.options?.includes(key)) throw new HarnessUnsupportedError(`model option ${key}`);
+					if (currentRole !== role && messages.some((message) => message.providerExtras && !message.providerExtras.harnessContext)) throw new Error("Cannot switch model roles while opaque provider continuation is present");
+					currentRole = role;
+					const composed = [
+						...prompts,
+						...sources.messages,
+						...messages
+					];
+					const transformed = await runBeforeModel(middleware, composed, callCtx);
+					const projection = await projectHarnessContext(overrides.contextPolicy ?? config.contextPolicy, transformed, callCtx, entries);
+					ensureActive();
+					const remaining = (config.budgets?.maxTokens ?? Infinity) - usage.totalTokens - reservedTokens;
+					if (remaining <= 0) throw new HarnessBudgetError("Aggregate token budget exhausted or reserved by another call");
+					for (const value of [supplied.maxTokens, overrides.options?.maxTokens]) if (value !== void 0 && (!Number.isSafeInteger(value) || value <= 0)) throw new HarnessUnsupportedError("maxTokens must be a finite positive integer");
+					const options = {
+						...supplied,
+						...overrides.options,
+						signal: controller.signal,
+						tools: supplied.tools?.filter((tool) => active.includes(tool.name)),
+						...Number.isFinite(remaining) ? { maxTokens: Math.min(supplied.maxTokens ?? Infinity, overrides.options?.maxTokens ?? Infinity, remaining) } : {}
+					};
+					activeTools.set(callCtx.runId, active);
+					const reservation = Number.isFinite(remaining) ? options.maxTokens ?? remaining : 0;
+					reservedTokens += reservation;
+					return {
+						provider: selected,
+						messages: projection.messages,
+						options,
+						reservation
+					};
+				};
+				const account = (provider, amount) => {
+					if ([
+						amount.promptTokens,
+						amount.completionTokens,
+						amount.totalTokens
+					].some((value) => !Number.isFinite(value) || value < 0)) throw new Error("Provider returned invalid token usage");
+					usage.promptTokens += amount.promptTokens;
+					usage.completionTokens += amount.completionTokens;
+					usage.totalTokens += amount.totalTokens;
+					for (const key of [
+						"reasoningTokens",
+						"cachedTokens",
+						"audioInputTokens",
+						"audioOutputTokens"
+					]) if (amount[key] !== void 0) usage[key] = (usage[key] ?? 0) + amount[key];
+					if (!controller.signal.aborted && !terminal) events.append({
+						type: "model.complete",
+						providerId: provider.providerId,
+						modelId: provider.modelId,
+						usage: {
+							promptTokens: amount.promptTokens,
+							completionTokens: amount.completionTokens,
+							totalTokens: amount.totalTokens
+						}
+					});
+				};
+				services = {
+					ctx,
+					signal: controller.signal,
+					tools,
+					definitionId: config.definition?.kind === "portable" ? config.definition.manifest.id : config.definition?.id,
+					agentConfiguration: {
+						defaults: resolved?.defaults ?? {},
+						limits: resolved?.limits ?? {},
+						projectRoot: config.projectRoot ?? process.cwd()
+					},
+					executionPolicy: policy,
+					approvalManager: config.approvalManager,
+					state,
+					sessionKey: harnessSessionKey(request.identity, request.sessionId),
+					get history() {
+						return structuredClone(canonical);
+					},
+					controlModel: (role, messages, options = {}) => track((async () => {
+						ensureActive();
+						if (!request.grants.modelRoles.includes(role)) throw new Error("Ungranted control model role");
+						const binding = config.models?.[role];
+						if (!binding) throw new Error("Control model requires an explicit host binding");
+						for (const key of Object.keys(options)) if (!["maxTokens", "temperature"].includes(key) || !binding.options?.includes(key)) throw new HarnessUnsupportedError(`control model option ${key}`);
+						if (options.maxTokens !== void 0 && (!Number.isSafeInteger(options.maxTokens) || options.maxTokens <= 0)) throw new HarnessUnsupportedError("maxTokens must be a finite positive integer");
+						if (options.temperature !== void 0 && (!Number.isFinite(options.temperature) || options.temperature < 0)) throw new HarnessUnsupportedError("temperature must be finite and non-negative");
+						const projection = structuredClone(messages);
+						if (projection.some((message) => message.role === "tool" || message.toolCalls?.length || message.providerExtras)) throw new Error("Control model calls require independent plain messages without provider/tool continuation");
+						(0, _agentium_core.validateConversationTransform)(projection, projection);
+						const remaining = (config.budgets?.maxTokens ?? Infinity) - usage.totalTokens - reservedTokens;
+						if (modelCalls >= (config.budgets?.maxModelCalls ?? Infinity) || remaining <= 0) throw new HarnessBudgetError("Aggregate model/token budget exhausted");
+						const maxTokens = Math.min(options.maxTokens ?? Infinity, remaining);
+						const reservation = Number.isFinite(maxTokens) ? maxTokens : 0;
+						modelCalls++;
+						reservedTokens += reservation;
+						try {
+							ensureActive();
+							const response = await generateObserved(binding.provider, projection, {
+								...options,
+								...Number.isFinite(maxTokens) ? { maxTokens } : {},
+								signal: controller.signal
+							});
+							account(binding.provider, response.usage);
+							ensureActive();
+							if (response.finishReason !== "stop" || response.message.toolCalls?.length) throw new Error("Control model must return a complete tool-free response");
+							return response;
+						} finally {
+							reservedTokens -= reservation;
+						}
+					})()),
+					model: (provider, messages, options, callCtx) => track((async () => {
+						const call = await prepare(provider, messages, options, callCtx);
+						try {
+							ensureActive();
+							const response = await generateObserved(call.provider, call.messages, call.options);
+							account(call.provider, response.usage);
+							ensureActive();
+							await runAfterModel(middleware, response, callCtx ?? ctx);
+							return response;
+						} finally {
+							reservedTokens -= call.reservation;
+						}
+					})()),
+					streamModel: (provider, messages, options, callCtx) => {
+						let finishLifetime;
+						track(new Promise((resolve) => {
+							finishLifetime = resolve;
+						}));
+						const implementation = (async function* () {
+							const call = await prepare(provider, messages, options, callCtx);
+							const endObservation = observeModel(call.provider);
+							let stream;
+							let succeeded = false;
+							let text = "";
+							let finished = false;
+							let amount = zero();
+							let reason = "stop";
+							let extras;
+							const calls = [];
+							try {
+								ensureActive();
+								stream = call.provider.stream(call.messages, call.options);
+								while (true) {
+									const next = await stream.next();
+									if (!next.done && next.value.type === "finish") {
+										if (finished) throw new Error("Provider emitted duplicate terminal usage");
+										finished = true;
+										reason = next.value.finishReason;
+										extras = next.value.providerExtras;
+										amount = next.value.usage ?? zero();
+										account(call.provider, amount);
+									}
+									ensureActive();
+									if (next.done) break;
+									if (next.value.type === "text") text += next.value.text;
+									else if (next.value.type === "tool_call_start") calls.push({
+										...next.value.toolCall,
+										args: ""
+									});
+									else if (next.value.type === "tool_call_delta") {
+										const chunk = next.value;
+										const pending = calls.find((item) => item.id === chunk.toolCallId);
+										if (pending) pending.args += chunk.argumentsDelta;
+									}
+									yield next.value;
+								}
+								if (!finished) throw new Error("Provider stream ended without a terminal response");
+								const response = {
+									message: {
+										role: "assistant",
+										content: text || null,
+										...calls.length ? { toolCalls: calls.map((item) => ({
+											id: item.id,
+											name: item.name,
+											arguments: JSON.parse(item.args)
+										})) } : {},
+										...extras ? { providerExtras: extras } : {}
+									},
+									usage: amount,
+									finishReason: reason === "tool_calls" || reason === "length" || reason === "content_filter" ? reason : "stop",
+									raw: { streamed: true }
+								};
+								await runAfterModel(middleware, response, callCtx ?? ctx);
+								succeeded = true;
+							} finally {
+								endObservation(succeeded, finished ? amount : void 0);
+								reservedTokens -= call.reservation;
+								await stream?.return(void 0);
+							}
+						})();
+						const finish = () => {
+							streams.delete(iterator);
+							finishLifetime();
+						};
+						const iterator = {
+							[Symbol.asyncIterator]() {
+								return this;
+							},
+							[Symbol.asyncDispose]: async () => {
+								await iterator.return(void 0);
+							},
+							next: (...args) => track(implementation.next(...args)).then((item) => {
+								if (item.done) finish();
+								return item;
+							}, (error) => {
+								finish();
+								throw error;
+							}),
+							return: (value) => track(implementation.return(value)).finally(finish),
+							throw: (error) => track(implementation.throw(error)).finally(finish)
+						};
+						streams.add(iterator);
+						return iterator;
+					},
+					runOwned: (operation) => track((async () => {
+						ensureActive();
+						return operation();
+					})()),
+					observeTool: async (result, callCtx) => {
+						ensureActive();
+						await runAfterTool(middleware, result, callCtx ?? ctx);
+						services.emit({
+							type: "tool.complete",
+							toolName: result.toolName,
+							toolCallId: result.toolCallId,
+							denied: Boolean(result.error)
+						});
+					},
+					dispatch: (call) => track((async () => {
+						ensureActive();
+						const [result] = await executor.executeAll([call], ctx);
+						ensureActive();
+						await runAfterTool(middleware, result, ctx);
+						services.emit({
+							type: "tool.complete",
+							toolName: call.name,
+							toolCallId: call.id,
+							denied: Boolean(result.error)
+						});
+						return result;
+					})()),
+					dispatchEffect: (name, args, execute) => track((async () => {
+						ensureActive();
+						let value;
+						const tool = {
+							name,
+							description: "Trusted deterministic workflow step",
+							parameters: zod_v3.z.object({}).passthrough(),
+							execute: async (validated, callCtx) => {
+								value = await execute(validated, callCtx);
+								return "Completed";
+							}
+						};
+						const [result] = await new _agentium_core.ToolExecutor([tool], {
+							approvalManager: config.approvalManager,
+							executionPolicy: policy
+						}).executeAll([{
+							id: (0, node_crypto.randomUUID)(),
+							name,
+							arguments: args
+						}], ctx);
+						ensureActive();
+						await runAfterTool(middleware, result, ctx);
+						services.emit({
+							type: "tool.complete",
+							toolName: name,
+							toolCallId: result.toolCallId,
+							denied: Boolean(result.error)
+						});
+						if (result.error) throw new Error(result.error);
+						return value;
+					})()),
+					recordConversation: (executionId, messages) => {
+						ensureActive();
+						const combined = [...conversations[executionId] ?? [], ...structuredClone(messages)];
+						(0, _agentium_core.validateConversationTransform)(combined, combined);
+						conversations[executionId] = combined;
+						if (executionId === request.runId) canonical.push(...structuredClone(messages));
+					},
+					append: (messages) => {
+						ensureActive();
+						canonical.push(...structuredClone(messages));
+					},
+					emit: (payload) => {
+						ensureActive();
+						if (Buffer.byteLength(JSON.stringify(payload)) > 65536) throw new Error("Generic event exceeds 64KB; store an artifact reference instead");
+						events.append(payload);
+					},
+					takeInput: () => {
+						ensureActive();
+						const index = inbox.findIndex((item) => item.mode === "steer");
+						return index < 0 ? void 0 : inbox.splice(index, 1)[0];
+					},
+					resource: (id, scope, initialize) => track((async () => {
+						ensureActive();
+						const lease = await this.resources.acquire(request.identity, request.sessionId, id, scope, initialize);
+						releases.push(lease.release);
+						ensureActive();
+						return lease.value;
+					})()),
+					putArtifact: (value) => {
+						ensureActive();
+						const id = (0, node_crypto.randomUUID)();
+						this.artifacts.set(id, {
+							owner: services.sessionKey,
+							value: structuredClone(value)
+						});
+						return id;
+					},
+					getArtifact: (id) => {
+						ensureActive();
+						return this.getArtifact(request.identity, request.sessionId, id);
+					}
+				};
+				prepareDefaults = (config.controller?.prepareRun ? await observeControl("prepareRun", () => config.controller.prepareRun(ctx)) : void 0) ?? {};
+				if (prepareDefaults.stop) throw new HarnessBudgetError(prepareDefaults.stop.reason);
+				events.append({
+					type: "run.started",
+					driverId: config.driver.id
+				});
+				let current = request;
+				while (true) {
+					ensureActive();
+					final = await config.driver.start(current, services);
+					if (streams.size) throw new Error("Driver returned with an unfinished model stream");
+					ensureActive();
+					if (!final || typeof final.text !== "string" || final.status !== void 0 && ![
+						"completed",
+						"failed",
+						"cancelled",
+						"stopped",
+						"awaiting_input"
+					].includes(final.status)) throw new Error("Driver returned an invalid terminal output");
+					final = structuredClone(final);
+					JSON.stringify(final);
+					if (final.history) {
+						const proposed = structuredClone(final.history);
+						if (canonical.some((message, index) => JSON.stringify(message) !== JSON.stringify(proposed[index]))) throw new Error("Driver replaced immutable canonical history");
+						(0, _agentium_core.validateConversationTransform)(proposed, proposed);
+						canonical = proposed;
+					}
+					if (final.status && final.status !== "completed") break;
+					const decision = config.completionPolicy ? await observeControl("completion", () => config.completionPolicy.evaluate({
+						text: final.text,
+						structured: final.structured,
+						revision
+					}, ctx)) : void 0;
+					if (decision) {
+						services.emit({
+							type: "completion",
+							action: decision.action,
+							reason: decision.reason
+						});
+						if (decision.action === "stop" || decision.action === "await_input") {
+							final = {
+								...final,
+								status: decision.action === "stop" ? "stopped" : "awaiting_input",
+								reason: {
+									code: decision.action,
+									message: decision.reason
+								}
+							};
+							break;
+						}
+						if (decision.action === "revise") {
+							if (revision >= (config.budgets?.maxRevisions ?? 0)) {
+								final = {
+									...final,
+									status: "stopped",
+									reason: {
+										code: "revision_limit",
+										message: "Completion revision limit reached"
+									}
+								};
+								break;
+							}
+							revision++;
+							current = {
+								...request,
+								input: decision.instruction
+							};
+							continue;
+						}
+					}
+					const followUp = inbox.findIndex((item) => item.mode === "follow_up");
+					if (followUp < 0) break;
+					current = {
+						...request,
+						input: inbox.splice(followUp, 1)[0].input
+					};
+				}
+				const rejected = (await Promise.allSettled([...owned])).find((entry) => entry.status === "rejected");
+				if (rejected?.status === "rejected") throw rejected.reason;
+				ensureActive();
+				lease.commit({
+					history: canonical,
+					conversations,
+					state,
+					replayable
+				});
+				committed = true;
+			} catch (error) {
+				final = {
+					text: "",
+					status: controller.signal.aborted ? "cancelled" : error instanceof HarnessBudgetError ? "stopped" : "failed",
+					reason: {
+						code: controller.signal.aborted ? "cancelled" : error instanceof HarnessBudgetError ? error.code : error?.code ?? "execution_failed",
+						message: controller.signal.aborted ? "Cancellation acknowledged; already started external effects are not rolled back" : error instanceof Error ? error.message : "Execution failed"
+					}
+				};
+			} finally {
+				acceptingOperations = false;
+				await Promise.allSettled([...streams].map((stream) => stream.return(void 0)));
+				await Promise.allSettled([...owned]);
+				if (lease && !committed) try {
+					lease.commit({
+						history: canonical,
+						conversations,
+						state,
+						replayable: false
+					});
+				} catch {
+					cleanupDiagnostics.push("partial_history_commit_failed");
+				}
+				for (const release of releases.reverse()) try {
+					await release();
+				} catch {
+					cleanupDiagnostics.push("resource_release_failed");
+				}
+				try {
+					const diagnostics = await bound?.dispose();
+					cleanupDiagnostics.push(...(diagnostics ?? []).map((item) => item.code));
+				} catch {
+					cleanupDiagnostics.push("binding_release_failed");
+				}
+				try {
+					lease?.release();
+				} catch {
+					cleanupDiagnostics.push("session_release_failed");
+				}
+				if (timer) clearTimeout(timer);
+				callerSignal?.removeEventListener("abort", onAbort);
+			}
+			if (controller.signal.aborted) final = {
+				...final,
+				status: "cancelled",
+				reason: {
+					code: "cancelled",
+					message: "Cancellation acknowledged"
+				}
+			};
+			const terminalResult = {
+				status: final.status ?? "completed",
+				text: final.text,
+				...final.structured !== void 0 ? { structured: final.structured } : {},
+				...final.reason ? { reason: final.reason } : {},
+				...final.artifacts ? { artifacts: final.artifacts } : {},
+				usage: modelCalls ? usage : final.usage ?? usage,
+				runId,
+				sessionId: request.sessionId,
+				finalCursor: events.cursor + 1
+			};
+			if (cleanupDiagnostics.length) terminalResult.cleanupDiagnostics = cleanupDiagnostics;
+			if (Buffer.byteLength(JSON.stringify(terminalResult)) > 65536) {
+				const id = (0, node_crypto.randomUUID)();
+				this.artifacts.set(id, {
+					owner: harnessSessionKey(request.identity, request.sessionId),
+					value: structuredClone(terminalResult)
+				});
+				terminalResult.text = terminalResult.text.slice(0, 4096);
+				delete terminalResult.structured;
+				terminalResult.artifacts = [{
+					id,
+					mimeType: "application/json"
+				}];
+				if (terminalResult.reason) terminalResult.reason = {
+					code: terminalResult.reason.code.slice(0, 128),
+					message: terminalResult.reason.message.slice(0, 2048)
+				};
+			}
+			terminal = true;
+			events.append({
+				type: "run.terminal",
+				result: terminalResult
+			});
+			config.telemetry?.emit("run.complete", {
+				runId,
+				output: {
+					text: "",
+					toolCalls: [],
+					usage: terminalResult.usage,
+					runId,
+					agentName: config.driver.id,
+					sessionId: request.sessionId,
+					durationMs: Date.now() - startedAt,
+					status: terminalResult.status === "failed" ? "error" : terminalResult.status === "awaiting_input" ? "stopped" : terminalResult.status
+				}
+			});
+			return structuredClone(terminalResult);
+		});
+		return {
+			runId,
+			events: (options) => events.events(options),
+			result: () => result.then((value) => structuredClone(value)),
+			cancel,
+			send: async (input, options) => {
+				if (terminal || controller.signal.aborted) throw new Error("Run is no longer active");
+				if (!config.driver.capabilities.controls.includes(options.mode)) throw new HarnessUnsupportedError(options.mode);
+				if (inbox.length >= 32) throw new Error("Run input queue is full");
+				inbox.push({
+					input: structuredClone(input),
+					mode: options.mode
+				});
+				events.append({
+					type: "control",
+					operation: options.mode
+				});
+			}
+		};
+	}
+};
+//#endregion
+Object.defineProperty(exports, "HarnessBudgetError", {
+	enumerable: true,
+	get: function() {
+		return HarnessBudgetError;
+	}
+});
+Object.defineProperty(exports, "HarnessEventGapError", {
+	enumerable: true,
+	get: function() {
+		return HarnessEventGapError;
+	}
+});
+Object.defineProperty(exports, "HarnessResourcePool", {
+	enumerable: true,
+	get: function() {
+		return HarnessResourcePool;
+	}
+});
+Object.defineProperty(exports, "HarnessRuntime", {
+	enumerable: true,
+	get: function() {
+		return HarnessRuntime;
+	}
+});
+Object.defineProperty(exports, "HarnessSessionConflict", {
+	enumerable: true,
+	get: function() {
+		return HarnessSessionConflict;
+	}
+});
+Object.defineProperty(exports, "HarnessUnsupportedError", {
+	enumerable: true,
+	get: function() {
+		return HarnessUnsupportedError;
+	}
+});
+Object.defineProperty(exports, "InMemoryHarnessEventStore", {
+	enumerable: true,
+	get: function() {
+		return InMemoryHarnessEventStore;
+	}
+});
+Object.defineProperty(exports, "InMemoryHarnessSessionStore", {
+	enumerable: true,
+	get: function() {
+		return InMemoryHarnessSessionStore;
+	}
+});
+Object.defineProperty(exports, "createHarnessDefinition", {
+	enumerable: true,
+	get: function() {
+		return createHarnessDefinition;
+	}
+});
+Object.defineProperty(exports, "describeHarnessDefinition", {
+	enumerable: true,
+	get: function() {
+		return describeHarnessDefinition;
+	}
+});
+Object.defineProperty(exports, "exportHarnessManifest", {
+	enumerable: true,
+	get: function() {
+		return exportHarnessManifest;
+	}
+});
+Object.defineProperty(exports, "extendHarnessDefinition", {
+	enumerable: true,
+	get: function() {
+		return extendHarnessDefinition;
+	}
+});
+Object.defineProperty(exports, "hashHarnessManifest", {
+	enumerable: true,
+	get: function() {
+		return hashHarnessManifest;
+	}
+});
+Object.defineProperty(exports, "loadHarnessManifest", {
+	enumerable: true,
+	get: function() {
+		return loadHarnessManifest;
+	}
+});
+Object.defineProperty(exports, "resolveHarnessRuntime", {
+	enumerable: true,
+	get: function() {
+		return resolveHarnessRuntime;
+	}
+});