@agimon-ai/doompi-core 0.0.1-alpha.100

package/dist/src/server/directHarnessRuntime.mjs

@@ -0,0 +1,1958 @@
+import { preserveHistoryBeforeOpen } from "../../historyImport.mjs";
+import { openSqliteSessionStorage } from "../../sqliteSessionStorage.mjs";
+import { createHistoryCreationFileSystem } from "../services/historyCreationFileSystem/index.mjs";
+import { harnessErrorMessage } from "./harnessErrorMessage.mjs";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { BACKGROUND_CONTEXT } from "@earendil-works/pi-agent-core/harness/context";
+import { JSONL_STORAGE_VERSION, JsonlSessionRepo, laneState, pendingEntry, setValue, value } from "@earendil-works/pi-agent-core/harness/session";
+import { NodeExecutionEnv } from "@earendil-works/pi-agent-core/node";
+import { AgentHarness, HarnessFault } from "@earendil-works/pi-agent-core";
+import { createAssistantMessageEventStream, createModels, getSupportedThinkingLevels } from "@earendil-works/pi-ai";
+//#region src/server/directHarnessRuntime.ts
+const DEFAULT_LANE = "main";
+const DEFAULT_SESSION_ROOT = ".pi/sessions";
+const FRAME_ERROR = "error";
+/** Journaled at every run end, so a reopened session can tell when it last settled. */
+const AGENT_SETTLED_ENTRY_TYPE = "doompi.agent-settled";
+const EVENT_TYPES = [
+	"run_start",
+	"run_resume",
+	"run_suspend",
+	"operation_abort",
+	"run_end",
+	"fault",
+	"handler_error",
+	"turn_start",
+	"turn_end",
+	"retry_scheduled",
+	"retry_start",
+	"retry_end",
+	"message_start",
+	"message_update",
+	"message_end",
+	"tool_start",
+	"tool_update",
+	"tool_end",
+	"entry_added",
+	"queue_update",
+	"value_update",
+	"config_update",
+	"compaction_start",
+	"compaction_end",
+	"navigation_start",
+	"navigation_end",
+	"usage",
+	"lane_created"
+];
+const STORAGE_ERROR_CODES = /* @__PURE__ */ new Set([
+	"EACCES",
+	"EBUSY",
+	"EIO",
+	"EMFILE",
+	"ENFILE",
+	"ENOSPC",
+	"EPERM",
+	"EROFS"
+]);
+const EMPTY_LIFECYCLE = {
+	version: 1,
+	revision: 0,
+	paused: false,
+	queue: []
+};
+const RETAINED_RECEIPTS = 128;
+function compactLifecycle(record) {
+	let receipts = 0;
+	const queue = record.queue.toReversed().filter((item) => {
+		if (item.disposition !== "consumed" && item.disposition !== "removed") return true;
+		receipts += 1;
+		return receipts <= RETAINED_RECEIPTS;
+	}).toReversed().map((item) => item.disposition === "consumed" || item.disposition === "removed" ? {
+		id: item.id,
+		text: "",
+		delivery: item.delivery,
+		scheduling: item.scheduling,
+		disposition: item.disposition
+	} : item);
+	return {
+		...record,
+		queue
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+	return typeof value === "string" ? value : void 0;
+}
+/** Run one prompt and return only the assistant text appended by that prompt. */
+async function promptForAssistantText(runtime, text) {
+	const previousEntryIds = new Set((await runtime.readEntries()).entries.map((entry) => entry.id));
+	await runtime.prompt(text);
+	const { entries } = await runtime.readEntries();
+	for (let index = entries.length - 1; index >= 0; index--) {
+		const entry = entries[index];
+		if (!entry || previousEntryIds.has(entry.id)) continue;
+		if (entry.type !== "message" || entry.message.role !== "assistant") continue;
+		return entry.message.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n").trim() || void 0;
+	}
+}
+function modelReference(model, models) {
+	if (model !== void 0 && "api" in model) return model;
+	const requested = model;
+	const resolved = requested === void 0 ? models.getModels()[0] : models.getModel(requested.provider, requested.id);
+	if (resolved === void 0) {
+		const identity = requested === void 0 ? "the first configured model" : `${requested.provider}/${requested.id}`;
+		throw new Error(`Direct harness could not resolve ${identity}`);
+	}
+	return resolved;
+}
+function readDirectHarnessSessionMetadata(filePath) {
+	const absolute = fs.realpathSync(filePath);
+	const firstLine = fs.readFileSync(absolute, "utf8").split("\n", 1)[0];
+	let header;
+	try {
+		const parsed = JSON.parse(firstLine ?? "");
+		if (!isRecord(parsed)) throw new Error("header is not an object");
+		header = parsed;
+	} catch (error) {
+		throw new Error(`Invalid JSONL session header: ${absolute}`, { cause: error });
+	}
+	if (header.kind !== "header" || header.v !== 4) throw new Error(`Session is not an upstream v4 JSONL file: ${absolute}`);
+	const id = stringValue(header.id);
+	const cwd = stringValue(header.cwd);
+	const createdAt = header.createdAt;
+	if (!id || !cwd || typeof createdAt !== "number" || !Number.isFinite(createdAt)) throw new Error(`Invalid JSONL session identity: ${absolute}`);
+	const stat = fs.statSync(absolute);
+	return {
+		id,
+		createdAt,
+		storageVersion: typeof header.storageVersion === "number" ? header.storageVersion : JSONL_STORAGE_VERSION,
+		cwd,
+		path: absolute,
+		modifiedAt: stat.mtimeMs,
+		...typeof header.parentSessionId === "string" ? { parentSessionId: header.parentSessionId } : {},
+		...typeof header.legacyParentSessionPath === "string" ? { legacyParentSessionPath: header.legacyParentSessionPath } : {}
+	};
+}
+function isV3File(filePath) {
+	let firstLine;
+	try {
+		firstLine = fs.readFileSync(path.resolve(filePath), "utf8").split("\n", 1)[0] ?? "";
+	} catch (error) {
+		if (isRecord(error) && error.code === "ENOENT") return false;
+		throw error;
+	}
+	try {
+		const header = JSON.parse(firstLine);
+		return isRecord(header) && header.type === "session" && header.version === 3;
+	} catch {
+		return false;
+	}
+}
+async function acquireHistoryLease(owner, filePath) {
+	const lease = await owner.acquire(filePath);
+	try {
+		await lease.assertQuiescent();
+		return lease;
+	} catch (error) {
+		await Promise.resolve(lease.release()).catch(() => void 0);
+		throw error;
+	}
+}
+async function closeStorage(storage, context) {
+	const failures = [];
+	try {
+		await storage.session?.close(context);
+	} catch (error) {
+		failures.push(error);
+	}
+	try {
+		await storage.repository?.close(context);
+	} catch (error) {
+		failures.push(error);
+	}
+	try {
+		await storage.environment?.cleanup(context);
+	} catch (error) {
+		failures.push(error);
+	}
+	try {
+		await storage.historyLease?.release();
+	} catch (error) {
+		failures.push(error);
+	}
+	storage.historyLease = void 0;
+	if (failures.length) throw new AggregateError(failures, "Direct harness storage cleanup failed");
+}
+async function openStorage(options, context) {
+	if (options.session !== void 0) return {
+		session: options.session,
+		...options.sessionPath === void 0 ? {} : { sessionFile: path.resolve(options.sessionPath) }
+	};
+	if (options.storage === "sqlite") return openSqliteSessionStorage(options, context);
+	const sessionPath = options.sessionPath === void 0 ? void 0 : path.resolve(options.sessionPath);
+	const legacyPath = options.legacySessionPath === void 0 ? sessionPath : path.resolve(options.legacySessionPath);
+	let importedPath = sessionPath;
+	if (legacyPath !== void 0 && isV3File(legacyPath)) throw new Error("Legacy v3 history cannot be opened for writing. Stop Pi, run doompi history-import <v3-source> <v4-destination> --confirm-offline, then open the v4 destination.");
+	const environment = new NodeExecutionEnv({ cwd: options.cwd });
+	const sessionsRoot = path.resolve(options.sessionsRoot ?? (importedPath === void 0 ? path.join(options.cwd, DEFAULT_SESSION_ROOT) : path.dirname(importedPath)));
+	let metadata;
+	if (importedPath === void 0 && options.sessionId !== void 0) {
+		const discovery = new JsonlSessionRepo({
+			fileSystem: environment,
+			sessionsRoot,
+			now: () => Date.now()
+		});
+		try {
+			metadata = (await discovery.list({ cwd: options.cwd }, context)).find((candidate) => candidate.id === options.sessionId);
+			importedPath = metadata?.path;
+		} finally {
+			await discovery.close(context);
+		}
+	}
+	let historyLease;
+	let session;
+	const fileSystem = importedPath === void 0 ? createHistoryCreationFileSystem(environment, async (destinationPath) => {
+		const owner = options.historyOwnership;
+		if (owner === void 0) throw new Error("Creating a writable session requires explicit HistoryOwnership");
+		historyLease = await acquireHistoryLease(owner, destinationPath);
+	}) : environment;
+	const repository = new JsonlSessionRepo({
+		fileSystem,
+		sessionsRoot,
+		now: () => Date.now()
+	});
+	try {
+		if (importedPath !== void 0) {
+			const owner = options.historyOwnership;
+			if (owner === void 0) throw new Error("Opening an existing session requires explicit HistoryOwnership");
+			historyLease = await acquireHistoryLease(owner, importedPath);
+			metadata ??= readDirectHarnessSessionMetadata(importedPath);
+			if (options.sessionId !== void 0 && options.sessionId !== metadata.id) throw new Error(`Session id mismatch: expected ${options.sessionId}, found ${metadata.id}`);
+			await preserveHistoryBeforeOpen(metadata.path, historyLease);
+			session = await repository.open(metadata, context);
+		} else {
+			if (options.historyOwnership === void 0) throw new Error("Creating a writable session requires explicit HistoryOwnership");
+			const created = await repository.create({
+				id: options.sessionId,
+				cwd: options.cwd,
+				...options.parentSessionId === void 0 ? {} : { parentSessionId: options.parentSessionId }
+			}, context);
+			session = created;
+			importedPath = created.metadata.path;
+			if (historyLease === void 0) throw new Error("New history was not admitted before publication");
+		}
+		return {
+			session,
+			sessionFile: importedPath,
+			repository,
+			environment,
+			historyLease
+		};
+	} catch (error) {
+		await closeStorage({
+			session,
+			repository,
+			environment,
+			historyLease
+		}, context);
+		throw error;
+	}
+}
+/**
+* Merge caller-supplied providers into the registry the harness will use.
+* A pi-ai MutableModels exposes setProvider; a Pi ModelRuntime exposes
+* registerNativeProvider instead, and dropping providers for the latter would
+* silently hide every extension-registered provider from the child harness.
+*/
+function mergeProviders(models, providers) {
+	const mutable = models;
+	const register = typeof mutable.setProvider === "function" ? mutable.setProvider.bind(models) : typeof mutable.registerNativeProvider === "function" ? mutable.registerNativeProvider.bind(models) : void 0;
+	if (register === void 0) throw new Error("Direct harness cannot register providers on the supplied Models registry");
+	for (const provider of providers) register(provider);
+}
+function configureModels(options) {
+	if (options.models !== void 0) {
+		if (options.providers !== void 0 && options.providers.length > 0) mergeProviders(options.models, options.providers);
+		return options.models;
+	}
+	if (options.providers === void 0 || options.providers.length === 0) throw new Error("Direct harness requires a public Models registry or at least one Provider");
+	const models = options.credentials === void 0 ? createModels() : createModels({ credentials: options.credentials });
+	for (const provider of options.providers) models.setProvider(provider);
+	return models;
+}
+function textContent(value) {
+	if (typeof value === "string") return value;
+	if (!Array.isArray(value)) return "";
+	return value.filter(isRecord).filter((part) => part.type === "text").map((part) => stringValue(part.text) ?? "").join("");
+}
+function queueText(item) {
+	if (!isRecord(item) || item.type !== "message" || !isRecord(item.message)) return void 0;
+	return textContent(item.message.content);
+}
+function mapQueueUpdate(event) {
+	const queues = Array.isArray(event.queues) ? event.queues : [];
+	const steering = [];
+	const followUp = [];
+	for (const item of queues) {
+		if (!isRecord(item)) continue;
+		const text = queueText(item);
+		if (text === void 0) continue;
+		if (item.kind === "steer") steering.push(text);
+		else if (item.kind === "followUp" || item.kind === "nextRun") followUp.push(text);
+	}
+	return {
+		type: "queue_update",
+		queues,
+		steering,
+		followUp
+	};
+}
+function stateModel(model) {
+	if (!isRecord(model)) return void 0;
+	const provider = stringValue(model.provider);
+	const id = stringValue(model.id) ?? stringValue(model.modelId);
+	return provider && id ? {
+		provider,
+		id
+	} : void 0;
+}
+function mapHarnessEvent(event) {
+	const value = event;
+	switch (event.type) {
+		case "run_start": return [{
+			type: "agent_start",
+			runId: value.runId,
+			startedAt: value.startedAt
+		}];
+		case "run_resume": return [{
+			type: "agent_start",
+			runId: value.runId,
+			resumed: true
+		}];
+		case "run_suspend": return [{
+			type: "run_suspend",
+			runId: value.runId,
+			reason: value.reason,
+			deferred: value.deferred
+		}];
+		case "operation_abort": return [{
+			type: "operation_abort",
+			operationId: value.operationId,
+			steer: value.steer,
+			followUp: value.followUp
+		}];
+		case "run_end": return [{
+			type: "agent_end",
+			runId: value.runId,
+			status: value.status,
+			...value.error === void 0 ? {} : { error: value.error }
+		}, {
+			type: "agent_settled",
+			runId: value.runId,
+			timestamp: value.endedAt
+		}];
+		case "fault": return [{
+			type: FRAME_ERROR,
+			error: value.message,
+			code: value.code
+		}];
+		case "handler_error": return [{
+			type: "handler_error",
+			kind: value.kind,
+			hook: value.hook,
+			event: value.event,
+			error: value.error,
+			stack: value.stack
+		}];
+		case "turn_start": return [{
+			type: "turn_start",
+			runId: value.runId,
+			turnId: value.turnId
+		}];
+		case "turn_end": return [{
+			type: "turn_end",
+			runId: value.runId,
+			turnId: value.turnId,
+			message: value.message,
+			toolResults: value.toolResults
+		}];
+		case "retry_scheduled": return [{
+			type: "auto_retry_start",
+			runId: value.runId,
+			attempt: value.attempt,
+			maxAttempts: value.maxAttempts,
+			error: value.errorMessage
+		}];
+		case "retry_start": return [{
+			type: "auto_retry_start",
+			runId: value.runId,
+			attempt: value.attempt
+		}];
+		case "retry_end": return [{
+			type: "auto_retry_end",
+			runId: value.runId,
+			attempt: value.attempt,
+			success: value.success,
+			error: value.finalError
+		}];
+		case "message_start": return [{
+			type: "message_start",
+			runId: value.runId,
+			message: value.message
+		}];
+		case "message_update": return [{
+			type: "message_update",
+			runId: value.runId,
+			message: value.message,
+			assistantMessageEvent: value.event,
+			...value.frame === void 0 ? {} : { assistantMessageFrame: value.frame }
+		}];
+		case "message_end": return [{
+			type: "message_end",
+			runId: value.runId,
+			message: value.message,
+			entryId: value.entryId
+		}];
+		case "tool_start": return [{
+			type: "tool_execution_start",
+			runId: value.runId,
+			turnId: value.turnId,
+			toolCallId: value.toolCallId,
+			toolName: value.toolName,
+			args: value.args
+		}];
+		case "tool_update": return [{
+			type: "tool_execution_update",
+			runId: value.runId,
+			turnId: value.turnId,
+			toolCallId: value.toolCallId,
+			toolName: value.toolName,
+			partialResult: value.partialResult
+		}];
+		case "tool_end": return [{
+			type: "tool_execution_end",
+			runId: value.runId,
+			turnId: value.turnId,
+			toolCallId: value.toolCallId,
+			toolName: value.toolName,
+			result: value.result,
+			isError: value.isError,
+			terminate: value.terminate
+		}];
+		case "entry_added": return [{
+			type: "entry_appended",
+			entry: value.entry
+		}];
+		case "queue_update": return [mapQueueUpdate(value)];
+		case "value_update":
+			if (value.value === "session_name") return [{
+				type: "session_info_changed",
+				name: value.name
+			}];
+			return [{
+				type: "entry_label_changed",
+				targetId: value.targetId,
+				label: value.label
+			}];
+		case "config_update":
+			if (value.property === "thinkingLevel") return [{
+				type: "thinking_level_changed",
+				level: value.value
+			}];
+			if (value.property === "model") {
+				const model = stateModel(value.value);
+				return model === void 0 ? [] : [{
+					type: "response",
+					command: "get_state",
+					success: true,
+					data: { model }
+				}];
+			}
+			return [{
+				type: "config_update",
+				property: value.property,
+				value: value.value,
+				previous: value.previous
+			}];
+		case "compaction_start": return [{
+			type: "compaction_start",
+			runId: value.runId,
+			reason: value.reason
+		}];
+		case "compaction_end": return [{
+			type: "compaction_end",
+			runId: value.runId,
+			reason: value.reason,
+			status: value.status,
+			entryId: value.entryId
+		}];
+		case "navigation_start": return [{
+			type: "navigation_start",
+			runId: value.runId,
+			targetId: value.targetId
+		}];
+		case "navigation_end": return [{
+			type: "navigation_end",
+			runId: value.runId,
+			status: value.status
+		}];
+		case "usage": return [{
+			type: "usage",
+			lane: value.lane,
+			row: value.row,
+			totals: value.totals
+		}];
+		case "lane_created": return [{
+			type: "lane_created",
+			at: value.at
+		}];
+	}
+}
+function isStorageFailure(error) {
+	if (error instanceof HarnessFault) return true;
+	if (isRecord(error) && typeof error.code === "string" && STORAGE_ERROR_CODES.has(error.code)) return true;
+	return /(?:storage|session|jsonl|journal|commit|mutation).*(?:fail|error|fault|write|invariant)|(?:fail|error|fault|write|invariant).*(?:storage|session|jsonl|journal|commit|mutation)/iu.test(harnessErrorMessage(error));
+}
+function resultError(value) {
+	if (isRecord(value) && value.ok === false) throw value.error;
+	throw value;
+}
+async function entriesForLane(lane, context) {
+	return lane.findEntries({ order: "oldestFirst" }, context);
+}
+/**
+* Creates a same-process AgentHarness and the legacy framed compatibility
+* facade expected by doompi-server. No child process, RPC launcher, or Pi UI
+* runtime is created.
+*/
+async function createDirectHarnessRuntime(options) {
+	const context = options.context ?? BACKGROUND_CONTEXT;
+	const laneName = options.lane ?? DEFAULT_LANE;
+	let disposed = false;
+	let disposePromise;
+	let storageQuarantined = false;
+	let storageFailure;
+	let requestPreparationFailure;
+	let turnPreparationFailure;
+	let contextPreparationFailure;
+	let payloadPreparationFailure;
+	let toolsReady = true;
+	let activeToolNames = new Set(options.activeToolNames ?? options.tools?.map((tool) => tool.name) ?? []);
+	const storage = await openStorage(options, context);
+	let models;
+	let harnessResult;
+	try {
+		const registry = configureModels(options);
+		const dispatchMethods = /* @__PURE__ */ new Set([
+			"stream",
+			"complete",
+			"streamSimple",
+			"completeSimple",
+			"streamDeferred",
+			"fetchDeferred"
+		]);
+		models = new Proxy(registry, { get(target, key) {
+			const value = Reflect.get(target, key, target);
+			if (typeof value !== "function") return value;
+			if (!dispatchMethods.has(key)) return value.bind(target);
+			return (...args) => {
+				try {
+					if (disposed || storageQuarantined || !toolsReady) throw new Error("Direct harness model dispatch is blocked");
+					if (key !== "streamDeferred" && key !== "fetchDeferred") {
+						if (args[1].tools?.some((tool) => !activeToolNames.has(tool.name))) throw new Error("Model request contains a tool disabled after generation preparation");
+					}
+					if (contextPreparationFailure !== void 0) throw contextPreparationFailure.error;
+					if (turnPreparationFailure !== void 0) throw turnPreparationFailure.error;
+					if (requestPreparationFailure !== void 0) throw requestPreparationFailure.error;
+					options.guardModelRequest?.();
+				} catch {
+					const model = args[0];
+					const blocked = {
+						role: "assistant",
+						content: [],
+						api: model.api,
+						provider: model.provider,
+						model: model.id,
+						timestamp: Date.now(),
+						stopReason: "error",
+						errorMessage: "Model request blocked: headless capability preparation is not ready.",
+						usage: {
+							input: 0,
+							output: 0,
+							cacheRead: 0,
+							cacheWrite: 0,
+							totalTokens: 0,
+							cost: {
+								input: 0,
+								output: 0,
+								cacheRead: 0,
+								cacheWrite: 0,
+								total: 0
+							}
+						}
+					};
+					if (key === "complete" || key === "completeSimple" || key === "fetchDeferred") return Promise.resolve(blocked);
+					const stream = createAssistantMessageEventStream();
+					stream.push({
+						type: "error",
+						reason: "error",
+						error: blocked
+					});
+					return stream;
+				}
+				const requestOptions = args[2];
+				if (isRecord(requestOptions) && typeof requestOptions.onPayload === "function") {
+					const onPayload = requestOptions.onPayload;
+					args[2] = {
+						...requestOptions,
+						onPayload: async (payload, requestModel) => {
+							payloadPreparationFailure = void 0;
+							const transformed = await onPayload(payload, requestModel);
+							const failure = payloadPreparationFailure;
+							if (failure !== void 0) throw failure.error;
+							return transformed;
+						}
+					};
+				}
+				return Reflect.apply(value, target, args);
+			};
+		} });
+		harnessResult = await AgentHarness.create({
+			session: storage.session,
+			models,
+			model: modelReference(options.model, models),
+			...options.thinkingLevel === void 0 ? {} : { thinkingLevel: options.thinkingLevel },
+			...options.activeToolNames === void 0 ? {} : { activeToolNames: options.activeToolNames },
+			...options.tools === void 0 ? {} : { tools: options.tools },
+			...options.resources === void 0 ? {} : { resources: options.resources },
+			...options.toolContext === void 0 ? {} : { toolContext: options.toolContext },
+			...options.systemPrompt === void 0 ? {} : { systemPrompt: options.systemPrompt },
+			...options.streamOptions === void 0 ? {} : { streamOptions: options.streamOptions },
+			...options.retry === void 0 ? {} : { retry: options.retry },
+			...options.compaction === void 0 ? {} : { compaction: options.compaction },
+			...options.steeringMode === void 0 ? {} : { steeringMode: options.steeringMode },
+			...options.followUpMode === void 0 ? {} : { followUpMode: options.followUpMode },
+			...options.toolExecution === void 0 ? {} : { toolExecution: options.toolExecution },
+			...options.toProviderMessages === void 0 ? {} : { toProviderMessages: options.toProviderMessages },
+			...options.entryProjectors === void 0 ? {} : { entryProjectors: options.entryProjectors }
+		}, context);
+	} catch (error) {
+		await closeStorage(storage, context);
+		throw error;
+	}
+	const harness = harnessResult.harness;
+	const sessionId = storage.session.metadata.id;
+	const harnessId = options.harnessId ?? `${sessionId}:${laneName}`;
+	const listeners = /* @__PURE__ */ new Set();
+	const lifecycleListeners = /* @__PURE__ */ new Set();
+	let resolveExited;
+	const exited = new Promise((resolve) => {
+		resolveExited = resolve;
+	});
+	let exitResolved = false;
+	let lane;
+	const emitFrame = (frame) => {
+		for (const listener of Array.from(listeners)) try {
+			listener(frame);
+		} catch {}
+	};
+	const emitLifecycle = async (event, eventContext) => {
+		await Promise.all([...lifecycleListeners].map(async (listener) => {
+			try {
+				await listener(event, eventContext);
+			} catch (error) {
+				emitFrame({
+					type: "handler_error",
+					kind: "event",
+					event: event.type,
+					error: harnessErrorMessage(error)
+				});
+			}
+		}));
+	};
+	let settledEvents = Promise.resolve();
+	let toolsThisRun = 0;
+	const deliverHarnessEvent = async (event, eventContext) => {
+		if (event.type === "run_start") toolsThisRun = 0;
+		if (event.type === "tool_start") toolsThisRun += 1;
+		if (event.type === "run_end" && options.storage === "sqlite") {
+			const record = event;
+			try {
+				const latest = await lane.findEntry({
+					type: "custom",
+					customType: AGENT_SETTLED_ENTRY_TYPE,
+					order: "newestFirst"
+				}, eventContext);
+				if ((latest?.type === "custom" && isRecord(latest.data) ? latest.data : void 0)?.runId !== record.runId) await lane.appendCustomEntry(AGENT_SETTLED_ENTRY_TYPE, {
+					runId: String(record.runId),
+					timestamp: Number(record.endedAt),
+					tools: toolsThisRun
+				}, eventContext);
+			} catch (error) {
+				markStorageFailure(error);
+				emitFrame({
+					type: FRAME_ERROR,
+					code: "agent_settled",
+					error: harnessErrorMessage(error)
+				});
+			}
+		}
+		await emitLifecycle(event, eventContext);
+		if (event.type === "fault") markStorageFailure(event);
+		for (const frame of mapHarnessEvent(event)) emitFrame(frame);
+		if ([
+			"run_start",
+			"run_end",
+			"operation_abort",
+			"queue_update",
+			"compaction_start",
+			"compaction_end"
+		].includes(event.type)) (event.type === "queue_update" ? reconcileNativeQueue() : publishLifecycle()).catch((error) => emitFrame({
+			type: FRAME_ERROR,
+			code: "lifecycle_projection",
+			error: harnessErrorMessage(error)
+		}));
+	};
+	const handleHarnessEvent = async (event, eventContext) => {
+		if (event.type === "run_end") {
+			settledEvents = settledEvents.then(() => deliverHarnessEvent(event, eventContext)).catch((error) => emitFrame({
+				type: FRAME_ERROR,
+				code: "settled_event",
+				error: harnessErrorMessage(error)
+			}));
+			return;
+		}
+		await deliverHarnessEvent(event, eventContext);
+	};
+	const unsubscribe = EVENT_TYPES.map((type) => harness.events.on(type, handleHarnessEvent));
+	const guardLive = () => {
+		if (disposed) throw new Error("The direct harness runtime is disposed");
+	};
+	const guardWritable = () => {
+		guardLive();
+		if (storageQuarantined) throw new Error(`Direct harness writes are quarantined after a storage failure: ${harnessErrorMessage(storageFailure)}`, { cause: storageFailure });
+	};
+	const markStorageFailure = (error) => {
+		if (!isStorageFailure(error)) return;
+		if (!storageQuarantined) storageFailure = error;
+		storageQuarantined = true;
+		emitFrame({
+			type: FRAME_ERROR,
+			code: "storage_quarantined",
+			error: harnessErrorMessage(error)
+		});
+	};
+	const writable = async (operation) => {
+		guardWritable();
+		try {
+			await storage.historyLease?.assertQuiescent();
+			return await operation();
+		} catch (error) {
+			markStorageFailure(error);
+			throw error;
+		}
+	};
+	const lifecycleAddress = value("doompi.server.lifecycle", laneName);
+	const readRecord = async () => {
+		const stored = await storage.session.getValue(lifecycleAddress, context);
+		if (stored !== void 0 && stored.value.version !== 1) throw new Error("Unknown server lifecycle format");
+		return stored?.value ?? EMPTY_LIFECYCLE;
+	};
+	const changeRecord = async (change) => writable(() => storage.session.mutate(async (mutator) => {
+		const current = (await mutator.getValue(lifecycleAddress, context))?.value ?? EMPTY_LIFECYCLE;
+		if (current.version !== 1) throw new Error("Unknown server lifecycle format");
+		const decision = change(current);
+		if ("record" in decision) await mutator.commit([setValue(lifecycleAddress, compactLifecycle({
+			...decision.record,
+			revision: current.revision + 1
+		}))], context);
+		return decision.result;
+	}, context));
+	let settlingOperationId;
+	let abortingOperationId;
+	const readLifecycle = async () => {
+		const [record, execution] = await Promise.all([readRecord(), lane.inspectExecution(context)]);
+		const current = execution.current;
+		return {
+			revision: Math.max(record.revision, publicationRevision),
+			operation: current === null ? settlingOperationId === void 0 ? null : {
+				id: settlingOperationId,
+				kind: "run",
+				status: abortingOperationId === settlingOperationId ? "aborting" : "open"
+			} : {
+				id: current.id,
+				kind: current.kind,
+				status: current.status === "aborting" || abortingOperationId === current.id ? "aborting" : "open"
+			},
+			paused: record.paused,
+			queue: record.queue.filter((item) => item.disposition !== "consumed" && item.disposition !== "removed").map(({ id, text, images, delivery, scheduling, disposition }) => ({
+				id,
+				text,
+				...images === void 0 ? {} : { images },
+				delivery,
+				scheduling,
+				disposition
+			}))
+		};
+	};
+	let publishingLifecycle = Promise.resolve();
+	let publicationRevision = 0;
+	const publishLifecycle = () => {
+		const next = publishingLifecycle.then(async () => {
+			if (disposed) return;
+			const lifecycle = await readLifecycle();
+			publicationRevision = Math.max(publicationRevision + 1, lifecycle.revision);
+			emitFrame({
+				type: "lifecycle_update",
+				lifecycle: {
+					...lifecycle,
+					revision: publicationRevision
+				}
+			});
+		});
+		publishingLifecycle = next.catch((error) => {
+			emitFrame({
+				type: FRAME_ERROR,
+				code: "lifecycle_projection",
+				error: harnessErrorMessage(error)
+			});
+		});
+		return next;
+	};
+	const retainedMessage = (id, kind, message) => {
+		const content = message.role === "user" ? message.content : [];
+		const parts = typeof content === "string" ? [{
+			type: "text",
+			text: content
+		}] : content;
+		const text = message.role === "user" ? parts.map((part) => part.type === "text" ? part.text : "").filter(Boolean).join("\n") : "";
+		const images = message.role === "user" ? parts.filter((part) => part.type === "image") : [];
+		return {
+			id,
+			text,
+			...images.length === 0 ? {} : { images },
+			message,
+			delivery: kind,
+			scheduling: "held",
+			disposition: "handoff",
+			nativeEntryId: id
+		};
+	};
+	const adoptNativeQueue = async () => {
+		if (await writable(() => storage.session.mutate(async (mutator) => {
+			const native = await mutator.getValue(laneState(laneName), context);
+			const current = (await mutator.getValue(lifecycleAddress, context))?.value ?? EMPTY_LIFECYCLE;
+			const adopted = [];
+			for (const item of native?.value.inbox ?? []) {
+				if (item.kind !== "steer" && item.kind !== "followUp" && item.kind !== "nextRun") continue;
+				if (current.queue.some((entry) => entry.nativeEntryId === item.entryId || entry.id === item.entryId)) continue;
+				const pending = await mutator.getValue(pendingEntry(item.entryId), context);
+				if (pending?.value.type !== "message") throw new Error(`Native queued input ${item.entryId} has no message payload`);
+				adopted.push(retainedMessage(item.entryId, item.kind, pending.value.payload));
+			}
+			if (adopted.length === 0) return false;
+			await mutator.commit([setValue(lifecycleAddress, {
+				...current,
+				revision: current.revision + 1,
+				queue: [...current.queue, ...adopted]
+			})], context);
+			return true;
+		}, context))) await publishLifecycle();
+	};
+	const reconcileNativeQueue = async () => {
+		if (disposed) return;
+		const native = await storage.session.getValue(laneState(laneName), context);
+		const remaining = new Set((native?.value.inbox ?? []).map((entry) => entry.entryId));
+		const record = await readRecord();
+		for (const item of record.queue.filter((entry) => entry.nativeEntryId !== void 0 && !remaining.has(entry.nativeEntryId))) {
+			if (record.abortOperationId !== void 0) continue;
+			const committed = await storage.session.getEntry(item.nativeEntryId, context);
+			await changeRecord((current) => ({
+				record: {
+					...current,
+					queue: current.queue.map((entry) => entry.id === item.id && entry.nativeEntryId === item.nativeEntryId ? committed !== void 0 ? {
+						...entry,
+						disposition: "consumed"
+					} : current.paused ? {
+						...entry,
+						disposition: "pending",
+						nativeEntryId: void 0,
+						delivery: entry.delivery === "steer" ? "followUp" : entry.delivery
+					} : {
+						...entry,
+						disposition: "uncertain"
+					} : entry)
+				},
+				result: void 0
+			}));
+		}
+		await publishLifecycle();
+	};
+	const unsubscribeHooks = [];
+	if (options.transformContext !== void 0) unsubscribeHooks.push(harness.hooks.on("before_run", () => {
+		contextPreparationFailure = void 0;
+	}));
+	if (options.beforeModelRequest !== void 0) unsubscribeHooks.push(harness.hooks.on("before_run", async (event, hookContext) => {
+		turnPreparationFailure = void 0;
+		requestPreparationFailure = void 0;
+		try {
+			await options.beforeModelRequest?.({
+				phase: "turn",
+				prompt: event.prompt,
+				resources: event.resources
+			}, hookContext);
+		} catch (error) {
+			turnPreparationFailure = { error };
+			throw error;
+		}
+	}), harness.hooks.on("before_request", async (event, hookContext) => {
+		try {
+			await options.beforeModelRequest?.({
+				phase: "request",
+				model: event.model,
+				resources: await harness.getResources(hookContext)
+			}, hookContext);
+			requestPreparationFailure = void 0;
+		} catch (error) {
+			requestPreparationFailure = { error };
+			throw error;
+		}
+	}));
+	if (options.transformContext !== void 0) unsubscribeHooks.push(harness.hooks.on("transform_context", async (event, hookContext) => {
+		try {
+			return await options.transformContext(event, hookContext);
+		} catch (error) {
+			contextPreparationFailure = { error };
+			throw error;
+		}
+	}));
+	if (options.beforePayload !== void 0) unsubscribeHooks.push(harness.hooks.on("before_payload", async (event, hookContext) => {
+		try {
+			return await options.beforePayload(event, hookContext);
+		} catch (error) {
+			payloadPreparationFailure = { error };
+			throw error;
+		}
+	}));
+	if (options.beforeTool !== void 0) unsubscribeHooks.push(harness.hooks.on("before_tool", options.beforeTool));
+	if (options.afterTool !== void 0) unsubscribeHooks.push(harness.hooks.on("after_tool", options.afterTool));
+	if (options.beforeCompaction !== void 0) unsubscribeHooks.push(harness.hooks.on("before_compaction", options.beforeCompaction));
+	try {
+		lane = await harness.lane(laneName, context);
+		if (options.sessionName !== void 0) await writable(() => harness.setName(options.sessionName, context));
+	} catch (error) {
+		for (const unsubscribeHook of unsubscribeHooks) unsubscribeHook();
+		for (const unsubscribeEvent of unsubscribe) unsubscribeEvent();
+		await harness.close(context).catch(() => void 0);
+		await closeStorage(storage, context);
+		throw error;
+	}
+	const settleExit = (code) => {
+		if (exitResolved) return;
+		exitResolved = true;
+		resolveExited(code);
+	};
+	let externalOperationActive = false;
+	let agentOperationsActive = 0;
+	const acquireAgentOperation = () => {
+		if (externalOperationActive) throw new Error("The session is busy with an external tool invocation");
+		agentOperationsActive += 1;
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			agentOperationsActive -= 1;
+		};
+	};
+	const runAgentOperation = async (operation) => {
+		const release = acquireAgentOperation();
+		try {
+			return await operation();
+		} finally {
+			release();
+		}
+	};
+	const runExternalOperation = async (operation) => {
+		guardWritable();
+		if (externalOperationActive) throw new Error("The session is busy with an external tool invocation");
+		if (agentOperationsActive > 0) throw new Error("The session is busy with an agent operation");
+		externalOperationActive = true;
+		try {
+			if ((await lane.inspectExecution(context)).current !== null) throw new Error("The session is busy with an agent operation");
+			return await operation();
+		} finally {
+			externalOperationActive = false;
+		}
+	};
+	let admissionLine = Promise.resolve();
+	const serializeAdmission = async (operation) => {
+		const previous = admissionLine;
+		let release;
+		admissionLine = new Promise((resolve) => {
+			release = resolve;
+		});
+		await previous;
+		try {
+			return await operation();
+		} finally {
+			release();
+		}
+	};
+	let drainingAutomatic = false;
+	let drainRequested = false;
+	const drive = async (operationId) => {
+		settlingOperationId = operationId;
+		let failure;
+		try {
+			const result = await writable(() => lane.drive({
+				operationId,
+				waitForRetry: true
+			}, context));
+			if (!result.ok) resultError(result);
+			if (result.value.kind === "waiting" && result.value.reason === "retry") throw new Error(`Direct harness returned an unexpected retry wait for ${operationId}`);
+		} catch (error) {
+			failure = error;
+		} finally {
+			try {
+				await settledEvents;
+			} catch (error) {
+				if (failure === void 0) failure = error;
+				else emitFrame({
+					type: FRAME_ERROR,
+					code: "settled_event",
+					error: harnessErrorMessage(error)
+				});
+			}
+			if (settlingOperationId === operationId) settlingOperationId = void 0;
+			if (abortingOperationId === operationId) abortingOperationId = void 0;
+			if (!disposed) {
+				let publicationSucceeded = false;
+				try {
+					await publishLifecycle();
+					publicationSucceeded = true;
+				} catch (error) {
+					if (failure === void 0) failure = error;
+				}
+				if (publicationSucceeded && !storageQuarantined) drainAutomatic().catch((error) => emitFrame({
+					type: FRAME_ERROR,
+					code: "queue_drain",
+					error: harnessErrorMessage(error)
+				}));
+			}
+		}
+		if (failure !== void 0) throw failure;
+	};
+	const drainAutomatic = async () => {
+		if (disposed) return;
+		if (drainingAutomatic) {
+			drainRequested = true;
+			return;
+		}
+		drainingAutomatic = true;
+		try {
+			while (!disposed) {
+				if ((await lane.inspectExecution(context)).current !== null) return;
+				const operationId = randomUUID();
+				const claimed = await changeRecord((record) => {
+					if (record.paused || record.abortOperationId !== void 0) return { result: void 0 };
+					const item = record.queue.find((candidate) => candidate.disposition === "pending" && candidate.scheduling === "automatic" && candidate.delivery !== "steer");
+					if (!item) return { result: void 0 };
+					return {
+						record: {
+							...record,
+							queue: record.queue.map((entry) => entry.id === item.id ? {
+								...entry,
+								disposition: "handoff",
+								operationId,
+								attemptId: randomUUID()
+							} : entry)
+						},
+						result: item
+					};
+				});
+				if (!claimed) return;
+				await publishLifecycle();
+				try {
+					const message = claimed.message ?? {
+						role: "user",
+						content: [...claimed.text ? [{
+							type: "text",
+							text: claimed.text
+						}] : [], ...claimed.images ?? []],
+						timestamp: Date.now()
+					};
+					const admitted = await serializeAdmission(async () => {
+						if ((await readRecord()).paused) return void 0;
+						return writable(() => lane.accept({
+							kind: "prompt",
+							operationId,
+							prompt: message
+						}, context));
+					});
+					if (!admitted || !admitted.ok) {
+						if (admitted && admitted.error._tag !== "LaneBusy") resultError(admitted);
+						await changeRecord((record) => ({
+							record: {
+								...record,
+								queue: record.queue.map((entry) => entry.id === claimed.id && entry.operationId === operationId ? {
+									...entry,
+									disposition: "pending",
+									operationId: void 0,
+									attemptId: void 0
+								} : entry)
+							},
+							result: void 0
+						}));
+						await publishLifecycle();
+						return;
+					}
+					await changeRecord((record) => ({
+						record: {
+							...record,
+							queue: record.queue.map((entry) => entry.id === claimed.id && entry.operationId === operationId ? {
+								...entry,
+								disposition: "consumed"
+							} : entry)
+						},
+						result: void 0
+					}));
+					await publishLifecycle();
+					await drive(operationId);
+				} catch (error) {
+					await changeRecord((record) => ({
+						record: {
+							...record,
+							queue: record.queue.map((entry) => entry.id === claimed.id && entry.operationId === operationId && entry.disposition === "handoff" ? {
+								...entry,
+								disposition: "uncertain"
+							} : entry)
+						},
+						result: void 0
+					}));
+					emitFrame({
+						type: FRAME_ERROR,
+						code: "queue_handoff",
+						error: harnessErrorMessage(error)
+					});
+					await publishLifecycle();
+				}
+			}
+		} finally {
+			drainingAutomatic = false;
+			if (drainRequested && !disposed) {
+				drainRequested = false;
+				drainAutomatic().catch((error) => emitFrame({
+					type: FRAME_ERROR,
+					code: "queue_drain",
+					error: harnessErrorMessage(error)
+				}));
+			}
+		}
+	};
+	const admitPrompt = async (text, images, streamingBehavior) => {
+		const execution = await lane.inspectExecution(context);
+		if (execution.current !== null && streamingBehavior !== void 0) {
+			const queued = streamingBehavior === "steer" ? await writable(() => lane.steer(text, images, context)) : await writable(() => lane.followUp(text, images, context));
+			if (!queued.ok) resultError(queued);
+			await adoptNativeQueue();
+			return { settled: Promise.resolve() };
+		}
+		const request = typeof text === "string" ? {
+			kind: "prompt",
+			prompt: text,
+			...images === void 0 ? {} : { images }
+		} : {
+			kind: "prompt",
+			prompt: text
+		};
+		const admission = await serializeAdmission(async () => {
+			const lifecycle = await readRecord();
+			if (lifecycle.paused) {
+				if (execution.current !== null || settlingOperationId !== void 0 || lifecycle.queue.some((entry) => entry.disposition !== "consumed" && entry.disposition !== "removed")) throw new Error("The agent queue is paused; resume before starting a turn");
+				await changeRecord((record) => {
+					if (record.queue.some((entry) => entry.disposition !== "consumed" && entry.disposition !== "removed")) throw new Error("The agent queue is paused; resume before starting a turn");
+					return {
+						record: {
+							...record,
+							paused: false,
+							abortOperationId: void 0
+						},
+						result: void 0
+					};
+				});
+				await publishLifecycle();
+			}
+			for (const item of (await readRecord()).queue.filter((entry) => entry.disposition === "pending" && entry.scheduling === "held")) {
+				await changeRecord((record) => ({
+					record: {
+						...record,
+						queue: record.queue.map((entry) => entry.id === item.id ? {
+							...entry,
+							disposition: "handoff",
+							attemptId: randomUUID()
+						} : entry)
+					},
+					result: void 0
+				}));
+				try {
+					const queued = await writable(() => lane.followUp(item.message ?? item.text, item.message ? void 0 : item.images, context));
+					if (!queued.ok) resultError(queued);
+					await changeRecord((record) => ({
+						record: {
+							...record,
+							queue: record.queue.map((entry) => entry.id === item.id ? {
+								...entry,
+								nativeEntryId: queued.value.entryId
+							} : entry)
+						},
+						result: void 0
+					}));
+				} catch (error) {
+					await changeRecord((record) => ({
+						record: {
+							...record,
+							queue: record.queue.map((entry) => entry.id === item.id ? {
+								...entry,
+								disposition: "uncertain"
+							} : entry)
+						},
+						result: void 0
+					}));
+					await publishLifecycle();
+					throw error;
+				}
+			}
+			return writable(() => lane.accept(request, context));
+		});
+		if (!admission.ok) {
+			if (streamingBehavior !== void 0 && admission.error._tag === "LaneBusy") {
+				const queued = await writable(() => streamingBehavior === "steer" ? lane.steer(text, images, context) : lane.followUp(text, images, context));
+				if (!queued.ok) resultError(queued);
+				await adoptNativeQueue();
+				return { settled: Promise.resolve() };
+			}
+			resultError(admission);
+		}
+		return { settled: drive(admission.value.operationId) };
+	};
+	const replaceTools = (tools) => runAgentOperation(async () => {
+		toolsReady = false;
+		await writable(async () => {
+			await harness.setTools(tools, context);
+			await lane.setActiveTools(tools.map((tool) => tool.name), context);
+			activeToolNames = new Set(tools.map((tool) => tool.name));
+			toolsReady = true;
+		});
+	});
+	const replaceResources = async (resources) => {
+		await writable(() => harness.setResources(resources, context));
+	};
+	const readResources = async () => {
+		guardLive();
+		return harness.getResources(context);
+	};
+	const appendCustomEntry = async (customType, data) => writable(() => lane.appendCustomEntry(customType, data, context));
+	const appendMessage = async (message) => writable(() => lane.appendMessage(message, context));
+	const setLabel = async (targetId, label) => writable(() => harness.setLabel(targetId, label, context));
+	const recordUsage = async (usage, options) => {
+		const result = await writable(() => lane.recordUsage(usage, options, context));
+		if (!result.ok) resultError(result);
+		return result.value.usageId;
+	};
+	const tryDispatchCommand = async (text) => await options.dispatchCommand?.(text) ?? false;
+	const dispatchCommand = (text) => runAgentOperation(async () => {
+		guardLive();
+		return tryDispatchCommand(text);
+	});
+	const submitPrompt = async (text, images, streamingBehavior) => {
+		const release = acquireAgentOperation();
+		try {
+			if (await tryDispatchCommand(text)) {
+				release();
+				return {
+					settled: Promise.resolve(),
+					handledCommand: true
+				};
+			}
+			const submission = await admitPrompt(text, images, streamingBehavior);
+			submission.settled.then(release, release);
+			return submission;
+		} catch (error) {
+			release();
+			throw error;
+		}
+	};
+	const prompt = async (text, images) => {
+		await (await submitPrompt(text, images)).settled;
+	};
+	const admitMessage = async (message) => {
+		const release = acquireAgentOperation();
+		try {
+			const submission = await admitPrompt(message);
+			submission.settled.then(release, release);
+			return submission;
+		} catch (error) {
+			release();
+			throw error;
+		}
+	};
+	const enqueueAutomatic = async (text, images) => {
+		if (!text && !images?.length) throw new Error("Queued input must contain text or an image");
+		const id = randomUUID();
+		await changeRecord((record) => ({
+			record: {
+				...record,
+				queue: [...record.queue, {
+					id,
+					text,
+					...images === void 0 ? {} : { images },
+					delivery: "followUp",
+					scheduling: "automatic",
+					disposition: "pending"
+				}]
+			},
+			result: void 0
+		}));
+		await publishLifecycle();
+		drainAutomatic().catch((error) => emitFrame({
+			type: FRAME_ERROR,
+			code: "queue_drain",
+			error: harnessErrorMessage(error)
+		}));
+		return { id };
+	};
+	const removeQueued = async (id) => {
+		const native = (await readRecord()).queue.find((entry) => entry.id === id);
+		if (native?.disposition === "handoff" && native.nativeEntryId !== void 0) {
+			const cancelled = await writable(() => lane.cancelQueued(native.nativeEntryId, context));
+			if (!cancelled.ok) resultError(cancelled);
+			if (cancelled.value.kind === "cancelled") {
+				await changeRecord((record) => ({
+					record: {
+						...record,
+						queue: record.queue.map((entry) => entry.id === id ? {
+							...entry,
+							disposition: "removed"
+						} : entry)
+					},
+					result: void 0
+				}));
+				await publishLifecycle();
+				return "removed";
+			}
+			await reconcileNativeQueue();
+			return cancelled.value.kind === "already_consumed" ? "already_consumed" : "not_found";
+		}
+		const result = await changeRecord((record) => {
+			const item = record.queue.find((entry) => entry.id === id);
+			if (!item) return { result: "not_found" };
+			if (item.disposition === "consumed") return { result: "already_consumed" };
+			if (item.disposition === "removed") return { result: "removed" };
+			if (item.disposition !== "pending") return { result: "in_flight" };
+			return {
+				record: {
+					...record,
+					queue: record.queue.map((entry) => entry.id === id ? {
+						...entry,
+						disposition: "removed"
+					} : entry)
+				},
+				result: "removed"
+			};
+		});
+		if (result === "removed") await publishLifecycle();
+		return result;
+	};
+	const deliverPromoted = (id, operationId) => serializeAdmission(async () => {
+		const execution = await lane.inspectExecution(context);
+		if (execution.current?.id !== operationId || execution.current.status === "aborting") {
+			await changeRecord((record) => ({
+				record: {
+					...record,
+					queue: record.queue.map((entry) => entry.id === id && entry.operationId === operationId ? {
+						...entry,
+						delivery: "followUp",
+						disposition: "pending",
+						operationId: void 0
+					} : entry)
+				},
+				result: void 0
+			}));
+			await publishLifecycle();
+			drainAutomatic().catch((error) => emitFrame({
+				type: FRAME_ERROR,
+				code: "queue_drain",
+				error: harnessErrorMessage(error)
+			}));
+			return;
+		}
+		const item = (await readRecord()).queue.find((entry) => entry.id === id && entry.operationId === operationId);
+		if (!item || item.disposition !== "pending") return;
+		const message = item.message ?? {
+			role: "user",
+			content: [...item.text ? [{
+				type: "text",
+				text: item.text
+			}] : [], ...item.images ?? []],
+			timestamp: Date.now()
+		};
+		if (!await changeRecord((record) => {
+			const current = record.queue.find((entry) => entry.id === id && entry.operationId === operationId);
+			if (!current || current.disposition !== "pending" || record.paused) return { result: false };
+			return {
+				record: {
+					...record,
+					queue: record.queue.map((entry) => entry.id === id ? {
+						...entry,
+						disposition: "handoff",
+						attemptId: randomUUID()
+					} : entry)
+				},
+				result: true
+			};
+		})) return;
+		await publishLifecycle();
+		try {
+			const queued = await writable(() => lane.steer(message, void 0, context));
+			if (!queued.ok) resultError(queued);
+			const after = await lane.inspectExecution(context);
+			if (after.current?.id !== operationId || after.current.status === "aborting") {
+				const cancelled = await writable(() => lane.cancelQueued(queued.value.entryId, context));
+				if (!cancelled.ok) resultError(cancelled);
+				await changeRecord((record) => ({
+					record: {
+						...record,
+						queue: record.queue.map((entry) => entry.id === id ? cancelled.value.kind === "cancelled" ? {
+							...entry,
+							delivery: "followUp",
+							disposition: "pending",
+							operationId: void 0,
+							attemptId: void 0
+						} : {
+							...entry,
+							disposition: cancelled.value.kind === "already_consumed" ? "consumed" : "uncertain",
+							nativeEntryId: queued.value.entryId
+						} : entry)
+					},
+					result: void 0
+				}));
+				await publishLifecycle();
+				if (cancelled.value.kind === "cancelled") drainAutomatic().catch((error) => emitFrame({
+					type: FRAME_ERROR,
+					code: "queue_drain",
+					error: harnessErrorMessage(error)
+				}));
+				return;
+			}
+			await changeRecord((record) => ({
+				record: {
+					...record,
+					queue: record.queue.map((entry) => entry.id === id ? {
+						...entry,
+						nativeEntryId: queued.value.entryId
+					} : entry)
+				},
+				result: void 0
+			}));
+			await reconcileNativeQueue();
+		} catch (error) {
+			await changeRecord((record) => ({
+				record: {
+					...record,
+					queue: record.queue.map((entry) => entry.id === id && entry.disposition === "handoff" ? {
+						...entry,
+						disposition: "uncertain"
+					} : entry)
+				},
+				result: void 0
+			}));
+			await publishLifecycle();
+			emitFrame({
+				type: FRAME_ERROR,
+				code: "steer_handoff",
+				error: harnessErrorMessage(error)
+			});
+		}
+	});
+	const promoteQueued = async (id, operationId) => {
+		const execution = await lane.inspectExecution(context);
+		const result = await changeRecord((record) => {
+			const item = record.queue.find((entry) => entry.id === id);
+			if (!item || item.disposition === "removed" || item.disposition === "consumed") return { result: "not_found" };
+			if (item.disposition !== "pending") return { result: "in_flight" };
+			if (record.paused || execution.current?.id !== operationId || execution.current.status === "aborting") return { result: "target_changed" };
+			return {
+				record: {
+					...record,
+					queue: record.queue.map((entry) => entry.id === id ? {
+						...entry,
+						delivery: "steer",
+						operationId
+					} : entry)
+				},
+				result: "promoted"
+			};
+		});
+		if (result === "promoted") {
+			await publishLifecycle();
+			deliverPromoted(id, operationId).catch((error) => emitFrame({
+				type: FRAME_ERROR,
+				code: "steer_handoff",
+				error: harnessErrorMessage(error)
+			}));
+		}
+		return result;
+	};
+	const resumeQueue = async () => {
+		if ((await lane.inspectExecution(context)).current !== null) throw new Error("Wait for the active turn to settle before resuming the queue");
+		await changeRecord((record) => ({
+			record: {
+				...record,
+				paused: false,
+				abortOperationId: void 0,
+				queue: record.queue.map((entry) => entry.disposition === "pending" && entry.delivery === "steer" ? {
+					...entry,
+					delivery: "followUp",
+					operationId: void 0,
+					scheduling: "automatic"
+				} : entry)
+			},
+			result: void 0
+		}));
+		await publishLifecycle();
+		drainAutomatic().catch((error) => emitFrame({
+			type: FRAME_ERROR,
+			code: "queue_drain",
+			error: harnessErrorMessage(error)
+		}));
+	};
+	const steer = (message, images, targetOperationId) => runAgentOperation(async () => {
+		const execution = await lane.inspectExecution(context);
+		const id = randomUUID();
+		const retained = typeof message === "string" ? {
+			id,
+			text: message,
+			...images === void 0 ? {} : { images }
+		} : {
+			...retainedMessage(id, "steer", message),
+			id
+		};
+		const target = targetOperationId ?? execution.current?.id;
+		const active = target !== void 0 && execution.current?.id === target && execution.current.status !== "aborting";
+		await changeRecord((record) => ({
+			record: {
+				...record,
+				queue: [...record.queue, {
+					...retained,
+					delivery: active ? "steer" : "followUp",
+					scheduling: "automatic",
+					disposition: "pending",
+					nativeEntryId: void 0,
+					...active ? { operationId: target } : {}
+				}]
+			},
+			result: void 0
+		}));
+		await publishLifecycle();
+		if (active) deliverPromoted(id, target).catch((error) => emitFrame({
+			type: FRAME_ERROR,
+			code: "steer_handoff",
+			error: harnessErrorMessage(error)
+		}));
+		else drainAutomatic().catch((error) => emitFrame({
+			type: FRAME_ERROR,
+			code: "queue_drain",
+			error: harnessErrorMessage(error)
+		}));
+	});
+	const followUp = (message, images) => runAgentOperation(async () => {
+		const result = await writable(() => lane.followUp(message, images, context));
+		if (!result.ok) resultError(result);
+		await adoptNativeQueue();
+	});
+	const nextRun = (message, images) => runAgentOperation(async () => {
+		const result = await writable(() => lane.nextRun(message, images, context));
+		if (!result.ok) resultError(result);
+		await adoptNativeQueue();
+	});
+	const abortCurrent = async (targetOperationId) => {
+		const currentId = (await lane.inspectExecution(context)).current?.id;
+		if (!currentId || targetOperationId !== void 0 && targetOperationId !== currentId) return;
+		if (!await serializeAdmission(async () => {
+			if ((await lane.inspectExecution(context)).current?.id !== currentId) return false;
+			if (!await writable(() => storage.session.mutate(async (mutator) => {
+				const record = (await mutator.getValue(lifecycleAddress, context))?.value ?? EMPTY_LIFECYCLE;
+				const native = await mutator.getValue(laneState(laneName), context);
+				if (native?.value.currentOperationId !== currentId) return false;
+				const adopted = [];
+				for (const pending of native.value.inbox) {
+					if (pending.kind !== "steer" && pending.kind !== "followUp") continue;
+					if (record.queue.some((item) => item.id === pending.entryId || item.nativeEntryId === pending.entryId)) continue;
+					const payload = await mutator.getValue(pendingEntry(pending.entryId), context);
+					if (payload?.value.type !== "message") throw new Error(`Native queued input ${pending.entryId} has no message payload`);
+					adopted.push(retainedMessage(pending.entryId, pending.kind, payload.value.payload));
+				}
+				await mutator.commit([setValue(lifecycleAddress, {
+					...record,
+					revision: record.revision + 1,
+					paused: true,
+					abortOperationId: currentId,
+					queue: [...record.queue.map((entry) => entry.disposition === "pending" && entry.delivery === "steer" ? {
+						...entry,
+						delivery: "followUp",
+						operationId: void 0
+					} : entry), ...adopted]
+				})], context);
+				return true;
+			}, context))) return false;
+			abortingOperationId = currentId;
+			await publishLifecycle();
+			return true;
+		})) return;
+		const result = await writable(() => lane.requestAbort(currentId, context));
+		if (!result.ok) {
+			if (result.error._tag === "OperationMismatch") return;
+			resultError(result);
+		}
+		const returned = [...result.value.steer.map((message) => ({
+			kind: "steer",
+			message
+		})), ...result.value.followUp.map((message) => ({
+			kind: "followUp",
+			message
+		}))];
+		const latest = await readRecord();
+		const native = await storage.session.getValue(laneState(laneName), context);
+		const remaining = new Set((native?.value.inbox ?? []).map((item) => item.entryId));
+		const consumed = await Promise.all(latest.queue.filter((item) => item.nativeEntryId !== void 0).map(async (item) => [item.id, await storage.session.getEntry(item.nativeEntryId, context)]));
+		const committed = new Set(consumed.filter(([, entry]) => entry !== void 0).map(([id]) => id));
+		const removedUnconsumed = latest.queue.filter((item) => item.nativeEntryId !== void 0 && !remaining.has(item.nativeEntryId) && !committed.has(item.id));
+		const unmatched = {
+			steer: removedUnconsumed.filter((item) => item.delivery === "steer").length,
+			followUp: removedUnconsumed.filter((item) => item.delivery === "followUp").length
+		};
+		const ambiguous = returned.filter(({ kind }) => kind === "steer").length !== unmatched.steer || returned.filter(({ kind }) => kind === "followUp").length !== unmatched.followUp;
+		const extras = returned.filter(({ kind }) => {
+			if (!ambiguous && unmatched[kind] > 0) {
+				unmatched[kind] -= 1;
+				return false;
+			}
+			return true;
+		}).map(({ kind, message }) => ({
+			...retainedMessage(randomUUID(), kind, message),
+			delivery: kind === "steer" ? "followUp" : kind,
+			scheduling: "held",
+			disposition: "pending",
+			nativeEntryId: void 0
+		}));
+		await changeRecord((current) => ({
+			record: {
+				...current,
+				queue: [...current.queue.map((item) => {
+					if (item.nativeEntryId === void 0 || remaining.has(item.nativeEntryId)) return item;
+					if (committed.has(item.id)) return {
+						...item,
+						disposition: "consumed"
+					};
+					return ambiguous ? {
+						...item,
+						disposition: "uncertain"
+					} : {
+						...item,
+						disposition: "pending",
+						nativeEntryId: void 0,
+						delivery: item.delivery === "steer" ? "followUp" : item.delivery,
+						scheduling: item.delivery === "steer" ? "automatic" : item.scheduling
+					};
+				}), ...extras]
+			},
+			result: void 0
+		}));
+		await publishLifecycle();
+	};
+	const abort = (targetOperationId) => runAgentOperation(() => abortCurrent(targetOperationId));
+	const interrupt = async () => {
+		guardLive();
+		await abortCurrent();
+		await lane.waitForIdle(context);
+	};
+	const compact = (customInstructions) => runAgentOperation(async () => {
+		const result = await writable(() => lane.compact(customInstructions === void 0 ? void 0 : { customInstructions }, context));
+		if (!result.ok) resultError(result);
+	});
+	const recover = async () => {
+		await adoptNativeQueue();
+		const record = await readRecord();
+		if (record.abortOperationId !== void 0) {
+			if ((await lane.inspectExecution(context)).current?.id === record.abortOperationId) {
+				await abort(record.abortOperationId);
+				const afterAbort = await lane.inspectExecution(context);
+				if (afterAbort.current?.id === record.abortOperationId && afterAbort.current.status !== "aborting") throw new Error("Cannot resume a turn before its persisted abort intent reaches native cancellation");
+				if (afterAbort.current?.id === record.abortOperationId) {
+					const resumed = await writable(() => lane.resume(context));
+					if (!resumed.ok && resumed.error._tag !== "NothingToResume") resultError(resumed);
+				}
+			}
+			await changeRecord((current) => ({
+				record: {
+					...current,
+					abortOperationId: void 0,
+					paused: true
+				},
+				result: void 0
+			}));
+		}
+		for (const item of (await readRecord()).queue.filter((entry) => entry.disposition === "handoff" && entry.attemptId !== void 0 && entry.operationId === void 0 && entry.nativeEntryId === void 0)) await changeRecord((record) => ({
+			record: {
+				...record,
+				queue: record.queue.map((entry) => entry.id === item.id ? {
+					...entry,
+					disposition: "uncertain"
+				} : entry)
+			},
+			result: void 0
+		}));
+		const current = await readRecord();
+		for (const item of current.queue.filter((entry) => entry.disposition === "handoff" && entry.operationId !== void 0)) {
+			const execution = await lane.inspectExecution(context);
+			const result = await lane.getResult(item.operationId, context);
+			if (item.delivery !== "steer" && (execution.current?.id === item.operationId || result !== void 0)) await changeRecord((record) => ({
+				record: {
+					...record,
+					queue: record.queue.map((entry) => entry.id === item.id ? {
+						...entry,
+						disposition: "consumed"
+					} : entry)
+				},
+				result: void 0
+			}));
+			else await changeRecord((record) => ({
+				record: {
+					...record,
+					queue: record.queue.map((entry) => entry.id === item.id ? {
+						...entry,
+						disposition: "uncertain"
+					} : entry)
+				},
+				result: void 0
+			}));
+		}
+		await reconcileNativeQueue();
+		await publishLifecycle();
+	};
+	const resume = () => runAgentOperation(async () => {
+		await recover();
+		if ((await readRecord()).paused) return false;
+		const result = await writable(() => lane.resume(context));
+		if (!result.ok && result.error._tag === "NothingToResume") {
+			drainAutomatic().catch((error) => emitFrame({
+				type: FRAME_ERROR,
+				code: "queue_drain",
+				error: harnessErrorMessage(error)
+			}));
+			return false;
+		}
+		if (!result.ok) resultError(result);
+		return true;
+	});
+	const readState = async () => {
+		const [lifecycle, retained, persisted, stats, thinking] = await Promise.all([
+			readLifecycle(),
+			readRecord(),
+			storage.session.getValue(laneState(laneName), context),
+			storage.session.getStats(context),
+			lane.getThinkingLevel(context)
+		]);
+		const configuredModel = await lane.getModel(context);
+		const name = await harness.getName(context);
+		return {
+			model: configuredModel === void 0 ? void 0 : {
+				provider: configuredModel.provider,
+				id: configuredModel.id
+			},
+			thinkingLevel: thinking,
+			isStreaming: lifecycle.operation?.kind === "run",
+			isCompacting: lifecycle.operation?.kind === "compaction",
+			...lifecycle.operation === null ? {} : {
+				operationId: lifecycle.operation.id,
+				executionStatus: lifecycle.operation.status
+			},
+			queuePaused: lifecycle.paused,
+			queueRevision: lifecycle.revision,
+			steeringMode: await harness.getSteeringMode(context),
+			followUpMode: await harness.getFollowUpMode(context),
+			sessionFile: storage.sessionFile,
+			sessionId,
+			...name === void 0 ? {} : { sessionName: name },
+			autoCompactionEnabled: (await harness.getCompactionSettings(context)).enabled,
+			messageCount: stats.messageCount,
+			pendingMessageCount: lifecycle.queue.length + (persisted?.value.inbox.filter((entry) => entry.kind !== "write" && !retained.queue.some((item) => item.id === entry.entryId || item.nativeEntryId === entry.entryId)).length ?? 0)
+		};
+	};
+	const readEntries = async () => ({
+		entries: await entriesForLane(lane, context),
+		leafId: await lane.getTipId(context)
+	});
+	const listCommands = () => [...options.listCommands?.() ?? []];
+	const setModel = async (model) => {
+		if (models.getModel(model.provider, model.id) === void 0) throw new Error(`Model not found: ${model.provider}/${model.id}`);
+		await writable(() => lane.setModel({
+			provider: model.provider,
+			modelId: model.id
+		}, context));
+	};
+	const availableModels = () => models.getAvailable();
+	const availableThinkingLevels = async () => {
+		const model = await lane.getModel(context);
+		if (!model) throw new Error("No model is selected");
+		return getSupportedThinkingLevels(model);
+	};
+	const setThinkingLevel = (level) => writable(() => lane.setThinkingLevel(level, context));
+	const setSteeringMode = (mode) => writable(() => harness.setSteeringMode(mode, context));
+	const setFollowUpMode = (mode) => writable(() => harness.setFollowUpMode(mode, context));
+	const navigateTree = (targetId, navigationOptions) => runAgentOperation(async () => {
+		const result = await writable(() => lane.navigateTree(targetId, navigationOptions, context));
+		if (!result.ok) resultError(result);
+		return {
+			cancelled: result.value.navigation.status !== "completed",
+			entries: await entriesForLane(lane, context)
+		};
+	});
+	const clearQueue = async () => {
+		await changeRecord((record) => ({
+			record: {
+				...record,
+				queue: record.queue.map((entry) => entry.disposition === "pending" ? {
+					...entry,
+					disposition: "removed"
+				} : entry)
+			},
+			result: void 0
+		}));
+		const queued = (await storage.session.getValue(laneState(laneName), context))?.value.inbox ?? [];
+		for (const item of queued) {
+			if (item.kind === "write") continue;
+			const result = await writable(() => lane.cancelQueued(item.entryId, context));
+			if (!result.ok) resultError(result);
+			if (result.value.kind === "cancelled") await changeRecord((record) => ({
+				record: {
+					...record,
+					queue: record.queue.map((entry) => entry.nativeEntryId === item.entryId ? {
+						...entry,
+						disposition: "removed"
+					} : entry)
+				},
+				result: void 0
+			}));
+		}
+		await publishLifecycle();
+		return {
+			steering: [],
+			followUp: []
+		};
+	};
+	const setName = (name) => writable(() => harness.setName(name, context));
+	const getSessionStats = () => storage.session.getStats(context);
+	const dispose = () => {
+		if (disposed) return disposePromise?.then(() => void 0, () => void 0) ?? Promise.resolve();
+		disposePromise ??= (async () => {
+			let failure;
+			try {
+				const execution = await lane.inspectExecution(context);
+				if (execution.current !== null) await abortCurrent(execution.current.id);
+			} catch (error) {
+				failure = error;
+				markStorageFailure(error);
+			}
+			disposed = true;
+			for (const unsubscribeEvent of unsubscribe) unsubscribeEvent();
+			for (const unsubscribeHook of unsubscribeHooks) unsubscribeHook();
+			try {
+				await harness.close(context);
+			} catch (error) {
+				failure ??= error;
+				markStorageFailure(error);
+			}
+			try {
+				await closeStorage(storage, context);
+			} catch (error) {
+				failure ??= error;
+				markStorageFailure(error);
+			}
+			settleExit(failure === void 0 ? 0 : 1);
+			if (failure !== void 0) throw failure;
+		})();
+		return disposePromise;
+	};
+	return {
+		sessionId,
+		laneName,
+		harnessId,
+		completeModel: models.complete?.bind(models),
+		session: storage.session,
+		harness,
+		lane,
+		exited,
+		get storageQuarantined() {
+			return storageQuarantined;
+		},
+		onPresentationFrame(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		onEvent(listener) {
+			lifecycleListeners.add(listener);
+			return () => lifecycleListeners.delete(listener);
+		},
+		stop() {
+			abort().catch(() => void 0).finally(() => dispose().catch(() => void 0));
+		},
+		readState,
+		readLifecycle,
+		enqueueAutomatic,
+		removeQueued,
+		promoteQueued,
+		resumeQueue,
+		recover,
+		readEntries,
+		listCommands,
+		dispatchCommand,
+		setModel,
+		availableModels,
+		availableThinkingLevels,
+		setThinkingLevel,
+		setSteeringMode,
+		setFollowUpMode,
+		navigateTree,
+		clearQueue,
+		setName,
+		getSessionStats,
+		replaceTools,
+		replaceResources,
+		readResources,
+		runExternalOperation,
+		appendCustomEntry,
+		appendMessage,
+		setLabel,
+		recordUsage,
+		submitPrompt,
+		prompt,
+		admitMessage,
+		steer,
+		followUp,
+		nextRun,
+		abort,
+		interrupt,
+		compact,
+		resume,
+		dispose
+	};
+}
+//#endregion
+export { AGENT_SETTLED_ENTRY_TYPE, createDirectHarnessRuntime, promptForAssistantText, readDirectHarnessSessionMetadata };
+
+//# sourceMappingURL=directHarnessRuntime.mjs.map