@agimon-ai/po-core 0.0.0-alpha.2 → 0.0.0-alpha.21

package/dist/src/server/directHarnessRuntime.mjs

@@ -1,46 +1,27 @@
-import { DoomHeadlessToolBusyError } from "../schemas/headless.mjs";
-import { SessionIdentityDoc, SessionMetadataDoc, openSqliteSessionStorage } from "../../sqliteSessionStorage.mjs";
-import { initializeDurableNavigation, navigateDurableConversation } from "../services/durableNavigation/index.mjs";
+import { PoHeadlessToolBusyError } from "../schemas/headless.mjs";
+import { AgentLockDoc, FastModeDoc, IdentityHistoryDoc, LabelsDoc, SessionIdentityDoc, SessionMetadataDoc } from "../services/durableSession/docs.mjs";
+import "../schemas/profileIdentity.mjs";
 import { projectDurableEntries } from "../services/transcriptPages/index.mjs";
-import { contextTokensOf, contextUsageOf, latestAssistantUsage } from "../services/contextUsage/index.mjs";
-import { formatSkillsForSystemPrompt } from "../services/piExtensionHost/index.mjs";
+import { SESSION_GROUPS_CHANGED_FRAME } from "../schemas/sessionProtocol.mjs";
+import { formatSkillsForSystemPrompt } from "../services/skillPrompt/index.mjs";
+import { AGENT_SETTLED_ENTRY_TYPE } from "../constants/agentSettled.mjs";
+import { contextTokensOf, contextUsageOf } from "../services/contextUsage/index.mjs";
+import { initializeDurableNavigation, navigateDurableConversation } from "../services/durableNavigation/index.mjs";
+import { HeldQueueDoc } from "../services/durableQueue/docs.mjs";
+import { admitSelected, heldContent, heldRequestId } from "../services/durableQueue/index.mjs";
+import { SubagentsExtension } from "../services/durableSubagents/extension.mjs";
+import { subagentConversations } from "../services/durableSubagents/index.mjs";
+import { convertToLlm } from "../services/piMessages/index.mjs";
 import { randomUUID } from "node:crypto";
-import { convertToLlm } from "@earendil-works/pi-coding-agent";
-import { AgentDoc, CompactionTask, GenerationTask, Harness, InboxDoc, LiveDoc, ToolTask, UsageDoc, UserEntry, createRegistry, defineDoc, hook, watchEvents } from "@earendil-works/pi-durable";
+import { AgentDoc, CompactionTask, DEFAULT_COMPACTION_POLICY, GenerationTask, Harness, InboxDoc, LiveDoc, ProviderDoc, ToolTask, UsageDoc, createRegistry, hook, watchEvents } from "@earendil-works/pi-durable";
 import { BACKGROUND_CONTEXT, awaitWithContext, withAbortSignal } from "@earendil-works/chord/context";
-import { isDeepStrictEqual } from "node:util";
 import { createAssistantMessageEventStream, createModels, getSupportedThinkingLevels } from "@earendil-works/pi-ai";
+import { isDeepStrictEqual } from "node:util";
 import { getCurrentSystemPrompt, getCurrentTools } from "@earendil-works/pi-ai/utils/transcript";
-import { NodeExecutionEnv } from "@earendil-works/pi-durable/env/node";
 //#region src/server/directHarnessRuntime.ts
-const AGENT_SETTLED_ENTRY_TYPE = "po.agent-settled";
-const LifecycleDoc = defineDoc({
-	kind: "po.server.lifecycle",
-	version: 1,
-	scope: "session",
-	initial: () => ({ json: "{\"revision\":0,\"paused\":false,\"queue\":[]}" })
-});
-const FastModeDoc = defineDoc({
-	kind: "po.fast-mode",
-	version: 1,
-	scope: "session",
-	initial: () => ({ enabled: false })
-});
-const AgentLockDoc = defineDoc({
-	kind: "po.agent-lock",
-	version: 1,
-	scope: "session",
-	initial: () => ({ locked: false })
-});
 const AGENT_LOCKED_ERROR = "The local agent is locked. Unlock it to start a turn.";
 const CODEX_API = "openai-codex-responses";
 const CODEX_PROVIDER = "openai-codex";
-const LabelsDoc = defineDoc({
-	kind: "po.labels",
-	version: 1,
-	scope: "session",
-	initial: () => ({ labels: {} })
-});
 function nativeId(id) {
 	const value = Number(id);
 	if (!Number.isSafeInteger(value) || value < 0 || String(value) !== id) throw new Error(`Invalid durable identifier: ${id}`);
@@ -54,12 +35,26 @@ function text(message) {
 	if (!("content" in message)) return "summary" in message ? message.summary : "output" in message ? message.output : "";
 	return typeof message.content === "string" ? message.content : message.content.map((p) => p.type === "text" ? p.text : "").join("");
 }
+function fromContent(content) {
+	const images = (typeof content === "string" ? [{
+		type: "text",
+		text: content
+	}] : content).filter((part) => part.type === "image");
+	return {
+		text: text({
+			role: "user",
+			content,
+			timestamp: 0
+		}),
+		...images.length ? { images } : {}
+	};
+}
 /** Compatibility projection keeps protocol identities strings and retains fork ancestry. */
-async function projectDurableConversationEntries(conversation, context) {
+async function projectDurableConversationEntries(conversation, context, minEntryId) {
 	const records = [];
 	let cursor;
 	do {
-		const page = await conversation.entries({}, 256, cursor, context);
+		const page = await conversation.entries(minEntryId === void 0 ? {} : { minEntryId }, 256, cursor, context);
 		records.push(...page.items);
 		cursor = page.next;
 	} while (cursor);
@@ -69,30 +64,51 @@ async function projectDurableConversationEntries(conversation, context) {
 /**
 * Runs one prompt and returns the newest assistant text it produced. `hold` keeps the run open
 * across later turns started by intercom delivery: while it resolves true, wait for the lane to
-* go idle and ask again. The returned text is the newest one across all of those turns.
+* go idle and ask again. The returned text is the newest one across all of those turns. With a
+* `requestId` the prompt is admitted once: a later call, such as one after a restart, waits for it.
 */
-async function promptForAssistantText(runtime, prompt, hold) {
-	const previous = new Set((await runtime.readEntries()).entries.map((e) => e.id));
-	await (await runtime.submitInternalMessage(prompt)).settled;
-	while (hold && await hold()) await runtime.lane.waitForIdle(BACKGROUND_CONTEXT);
+async function promptForAssistantText(runtime, prompt, hold, requestId) {
+	const lane = runtime.lane;
+	const receipt = requestId === void 0 ? void 0 : await runtime.harness.commit((tx) => tx.submissionByRequest(lane.id, requestId), BACKGROUND_CONTEXT);
+	const before = (await runtime.readEntries()).entries;
+	const previous = new Set((receipt?.entry === void 0 ? before : before.filter((e) => Number(e.id) <= receipt.entry)).map((e) => e.id));
+	if (receipt) {
+		const settled = await (await runtime.harness.submission(receipt.id, BACKGROUND_CONTEXT))?.wait(BACKGROUND_CONTEXT);
+		if (settled?.status === "unanswered" && settled.reason === "aborted") throw Object.assign(/* @__PURE__ */ new Error("The prompt was stopped before it was answered"), { name: "AbortError" });
+	} else await (await runtime.submitInternalMessage(prompt, void 0, requestId)).settled;
+	while (hold && await hold()) await lane.waitForIdle(BACKGROUND_CONTEXT);
 	return (await runtime.readEntries()).entries.toReversed().filter((e) => !previous.has(e.id)).flatMap((e) => e.type === "message" && e.message.role === "assistant" ? [text(e.message).trim()] : [])[0] || void 0;
 }
-async function createDirectHarnessRuntime(options) {
+function createDirectHarnessRuntime(options) {
+	return createLaneRuntime(options, void 0);
+}
+/** The extension holding one lane's tools, prompt and hooks. */
+function laneExtensionName(conversationId) {
+	return `po.lane-${conversationId}`;
+}
+/** The main lane opens its Harness; a further lane runs on the main lane's Harness as one more conversation. */
+async function createLaneRuntime(options, attached) {
 	if (options.initialFastMode !== void 0 && typeof options.initialFastMode !== "boolean") throw new Error("Initial Fast mode must be a boolean.");
 	if (options.initialAgentLocked !== void 0 && typeof options.initialAgentLocked !== "boolean") throw new Error("Initial agent lock must be a boolean.");
 	const context = options.context ?? BACKGROUND_CONTEXT;
-	if (options.storage === "jsonl" || options.legacySessionPath !== void 0) throw new Error("Legacy JSONL direct storage is unsupported; use durable-v1 SQLite");
 	if (options.session && !options.durableStorage) throw new Error("A durable Session injection requires its raw durableStorage");
-	const storage = options.durableStorage ? {
+	const platform = options.platform;
+	const storage = attached?.storage ?? (options.durableStorage ? {
 		storage: options.durableStorage,
-		sessionFile: options.sessionPath,
-		historyLease: void 0,
-		repository: void 0
-	} : await openSqliteSessionStorage(options, context);
+		assertWritable() {},
+		release: async () => {}
+	} : await platform.sessions.open({
+		sessionId: options.sessionId,
+		parentSessionId: options.parentSessionId,
+		existing: options.resume
+	}, context));
 	let startupHarness;
 	try {
-		const registry = createRegistry();
-		const environment = new NodeExecutionEnv({ cwd: options.cwd });
+		const registry = attached?.registry ?? createRegistry();
+		const environment = attached ? void 0 : platform.env(options.cwd);
+		const laneProviderSessions = attached?.laneProviderSessions ?? /* @__PURE__ */ new Set();
+		const manualCompaction = attached?.manualCompaction ?? {};
+		const extensionName = attached ? laneExtensionName(attached.conversation.id) : "po.host";
 		let disposed = false;
 		let quarantined = false;
 		let failure;
@@ -107,6 +123,7 @@ async function createDirectHarnessRuntime(options) {
 		let tools = options.tools ?? [];
 		let activeNames = new Set(options.activeToolNames ?? tools.map((t) => t.name));
 		let settings = {
+			extensions: [{ name: "po.host" }],
 			stream: options.streamOptions,
 			retry: options.retry,
 			compaction: options.compaction,
@@ -117,6 +134,17 @@ async function createDirectHarnessRuntime(options) {
 		const listeners = /* @__PURE__ */ new Set();
 		const eventListeners = /* @__PURE__ */ new Set();
 		const checkpointBoundaries = /* @__PURE__ */ new Set();
+		const toolBoundaryQueue = [];
+		let toolBoundaryDrain;
+		const flushToolBoundary = () => {
+			if (toolBoundaryDrain) return toolBoundaryDrain;
+			toolBoundaryDrain = (async () => {
+				while (toolBoundaryQueue.length && !disposed && !disposePromise) await toolBoundaryQueue.shift().run();
+			})().finally(() => {
+				toolBoundaryDrain = void 0;
+			});
+			return toolBoundaryDrain;
+		};
 		const emit = (frame) => {
 			for (const listener of listeners) try {
 				listener(frame);
@@ -130,7 +158,7 @@ async function createDirectHarnessRuntime(options) {
 		const writable = async (work) => {
 			if (disposed || quarantined) throw new Error("Direct harness writes are unavailable", { cause: failure });
 			try {
-				await storage.historyLease?.assertQuiescent();
+				await storage.assertWritable();
 				return await work();
 			} catch (error) {
 				const code = typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
@@ -179,22 +207,23 @@ async function createDirectHarnessRuntime(options) {
 				"fetchDeferred"
 			].includes(String(key))) return value.bind(target);
 			return (...args) => {
-				if (disposed || quarantined || preparationFailure) throw new Error("Model dispatch unavailable", { cause: preparationFailure });
-				options.guardModelRequest?.();
-				const request = args[1];
-				if (!["complete", "completeSimple"].includes(String(key)) && request?.tools?.some((t) => !activeNames.has(t.name))) throw new Error("Model request contains disabled tools");
 				const requestOptions = args[2];
+				const lane = typeof requestOptions?.sessionId === "string" && laneProviderSessions.has(requestOptions.sessionId);
+				if (disposed || quarantined || !lane && preparationFailure) throw new Error("Model dispatch unavailable", { cause: preparationFailure });
+				if (!lane) options.guardModelRequest?.();
+				const request = args[1];
+				if (!lane && !["complete", "completeSimple"].includes(String(key)) && request?.tools?.some((t) => !activeNames.has(t.name))) throw new Error("Model request contains disabled tools");
 				const usePriority = fastMode && args[0].api === CODEX_API && args[0].provider === CODEX_PROVIDER;
 				const originalOnPayload = requestOptions?.onPayload;
 				args[2] = {
 					...requestOptions,
-					sessionId: key === "complete" ? requestOptions?.sessionId ?? sessionId : sessionId,
+					sessionId: lane ? requestOptions.sessionId : key === "complete" ? requestOptions?.sessionId ?? sessionId : sessionId,
 					...usePriority ? { serviceTier: "priority" } : {},
 					onPayload: async (payload, model) => {
-						options.guardModelRequest?.();
+						if (!lane) options.guardModelRequest?.();
 						const original = typeof originalOnPayload === "function" ? await originalOnPayload(payload, model) : void 0;
 						const transformed = original === void 0 ? payload : original;
-						const patch = await options.beforePayload?.({
+						const patch = lane ? void 0 : await options.beforePayload?.({
 							payload: transformed,
 							model
 						}, context);
@@ -302,8 +331,12 @@ async function createDirectHarnessRuntime(options) {
 			executionMode: tool.executionMode,
 			async execute(args, api, ctx) {
 				if (!activeNames.has(tool.name)) throw new Error(`Tool '${tool.name}' is no longer active`);
+				let reported = "";
 				const pending = tool.execute(api.callId, args, (partial) => {
-					for (const part of partial.content) if (part.type === "text") api.output(part.text);
+					const snapshot = partial.content.map((part) => part.type === "text" ? part.text : "").join("");
+					const chunk = snapshot.startsWith(reported) ? snapshot.slice(reported.length) : `\n${snapshot}`;
+					reported = snapshot;
+					if (chunk) api.output(chunk);
 					if (partial.details !== void 0) api.details(json(partial.details), ctx).catch((error) => emit({
 						type: "error",
 						error: String(error)
@@ -320,14 +353,14 @@ async function createDirectHarnessRuntime(options) {
 				}, ctx);
 				const result = await awaitWithContext(pending, ctx);
 				return {
-					content: result.content,
+					output: result.content,
 					isError: result.isError,
 					...result.details === void 0 ? {} : { details: json(result.details) }
 				};
 			}
 		});
 		const install = () => registry.install({
-			name: "po.host",
+			name: extensionName,
 			tools: tools.map(nativeTool),
 			sections: [{
 				key: "po",
@@ -347,6 +380,7 @@ async function createDirectHarnessRuntime(options) {
 					async afterTools(_assistant, _results, api, ctx) {
 						const lane = conversation;
 						if (lane.id !== api.conversationId) return;
+						await flushToolBoundary();
 						for (const registration of checkpointBoundaries) {
 							if (!registration.active || disposed || ctx.abortSignal?.aborted || external) continue;
 							let open = true;
@@ -360,13 +394,9 @@ async function createDirectHarnessRuntime(options) {
 							}
 						}
 					},
-					async beforeRequest(request, api, ctx) {
+					async beforeRequest(request, _api, ctx) {
 						assertUnlocked();
 						try {
-							const live = await api.snapshot(LiveDoc, api.conversationId, ctx);
-							const retained = await api.snapshot(LifecycleDoc, ctx);
-							const queue = JSON.parse(retained?.json ?? "{\"queue\":[]}");
-							if (live?.run && queue.queue.some((item) => item.operationId !== void 0 && item.submissionId !== void 0 && live.run.inputs.includes(item.submissionId) && item.operationId !== String(live.run.inputs[0]))) throw new Error("Steering target changed before model admission");
 							const agent = await conversation.agent(ctx);
 							const model = agent.model ? models.getModel(agent.model.provider, agent.model.modelId) : void 0;
 							await options.beforeModelRequest?.({
@@ -376,7 +406,7 @@ async function createDirectHarnessRuntime(options) {
 								resources
 							}, ctx);
 							const systemPrompt = getCurrentSystemPrompt(request.messages);
-							const contextMessages = options.transformContext ? await restoreCustomContextMessages(request.messages, ctx, await conversation.context(ctx)) : request.messages.filter((message) => message.role !== "system");
+							const contextMessages = options.transformContext ? restoreCustomContextMessages(request.messages, await conversation.context(ctx)) : request.messages.filter((message) => message.role !== "system");
 							const originalContext = structuredClone(contextMessages);
 							const patch = await options.transformContext?.({
 								messages: contextMessages,
@@ -419,14 +449,16 @@ async function createDirectHarnessRuntime(options) {
 							toolCallId: call.id,
 							toolName: call.name,
 							args: call.arguments,
-							content: result.content ?? [],
+							content: result.output ?? [],
 							details: result.details,
 							isError: result.isError ?? false,
 							usage: result.usage
 						}, ctx);
+						const { content: patchedOutput, terminate: _terminate, ...patchFields } = patch ?? {};
 						return patch ? {
 							...result,
-							...patch,
+							...patchFields,
+							...patchedOutput === void 0 ? {} : { output: patchedOutput },
 							control: patch.terminate || terminatingCalls.delete(call.id) ? {
 								...result.control,
 								terminate: true
@@ -440,7 +472,9 @@ async function createDirectHarnessRuntime(options) {
 						} : void 0;
 					}
 				}),
-				hook(CompactionTask, { async beforeCompact(input, _api, ctx) {
+				hook(CompactionTask, { async beforeCompact(input, api, ctx) {
+					const swapped = manualCompaction.conversationId;
+					if (input.reason === "threshold" && swapped !== void 0 && swapped !== String(api.conversationId)) return { decline: true };
 					if (!options.beforeCompaction) return;
 					const entries = projectDurableEntries(input.entries);
 					const patch = await options.beforeCompaction({
@@ -461,9 +495,9 @@ async function createDirectHarnessRuntime(options) {
 								edited: /* @__PURE__ */ new Set()
 							},
 							settings: {
-								enabled: options.compaction?.enabled ?? true,
-								reserveTokens: options.compaction?.reserveTokens ?? 16384,
-								keepRecentTokens: options.compaction?.keepRecentTokens ?? 2e4
+								enabled: options.compaction?.enabled ?? DEFAULT_COMPACTION_POLICY.enabled,
+								reserveTokens: options.compaction?.reserveTokens ?? DEFAULT_COMPACTION_POLICY.reserveTokens,
+								keepRecentTokens: options.compaction?.keepRecentTokens ?? DEFAULT_COMPACTION_POLICY.keepRecentTokens
 							}
 						}
 					}, ctx);
@@ -473,7 +507,8 @@ async function createDirectHarnessRuntime(options) {
 			]
 		});
 		install();
-		const harness = await Harness.open(storage.storage, {
+		if (!attached) registry.install(SubagentsExtension);
+		const harness = attached?.harness ?? await Harness.open(storage.storage, {
 			models,
 			registry,
 			get settings() {
@@ -485,71 +520,109 @@ async function createDirectHarnessRuntime(options) {
 				error: String(error)
 			})
 		}, context);
-		startupHarness = harness;
-		const root = await harness.root(context, { agent: {
-			cwd: options.cwd,
-			...options.model ?? models.getModels()[0] ? { model: {
-				provider: (options.model ?? models.getModels()[0]).provider,
-				modelId: (options.model ?? models.getModels()[0]).id
-			} } : {},
-			...options.thinkingLevel ? { thinkingLevel: options.thinkingLevel } : {}
-		} });
-		const activeId = await initializeDurableNavigation(harness, root.id, context);
-		let conversation = await harness.conversation(activeId, context);
-		const storedAgent = await harness.snapshot(AgentDoc, conversation.id, context);
-		const initialModel = options.model ?? models.getModels()[0];
-		await conversation.configure({
-			...!storedAgent?.model && initialModel ? { model: {
-				provider: initialModel.provider,
-				modelId: initialModel.id
-			} } : {},
-			...!storedAgent?.thinkingLevel && options.thinkingLevel ? { thinkingLevel: options.thinkingLevel } : {},
-			tools: tools.filter((t) => activeNames.has(t.name)).map(nativeTool)
-		}, context);
-		const storedFastMode = await harness.snapshot(FastModeDoc, context);
-		fastMode = storedFastMode?.enabled ?? options.initialFastMode ?? false;
-		const storedAgentLock = await harness.snapshot(AgentLockDoc, context);
-		agentLocked = storedAgentLock?.locked ?? options.initialAgentLocked ?? false;
-		const storedIdentity = await harness.snapshot(SessionIdentityDoc, context);
-		const sessionId = storedIdentity?.id || options.sessionId || randomUUID();
-		await writable(() => harness.commit(async (tx) => {
-			const identity = await tx.doc(SessionIdentityDoc);
-			if (!identity.id) {
-				identity.id = sessionId;
-				identity.createdAt = Date.now();
-				identity.parentSessionId = options.parentSessionId ?? "";
-			}
-			if (!storedAgentLock && options.initialAgentLocked !== void 0) (await tx.doc(AgentLockDoc)).locked = agentLocked;
-			if (!storedFastMode) {
-				(await tx.doc(FastModeDoc)).enabled = fastMode;
-				if (options.initialFastMode !== void 0) await tx.appendEntry(conversation.id, {
-					kind: "po.fast-mode",
-					data: {
-						version: 1,
-						enabled: fastMode,
-						sessionId
-					}
-				});
-			}
-			const metadata = await tx.doc(SessionMetadataDoc);
-			metadata.workspaceRoot ||= options.cwd;
-			if (options.lane !== void 0) metadata.laneName = options.lane;
-			if (!storedIdentity?.id && options.sessionName !== void 0) metadata.name = options.sessionName;
-		}, context));
+		if (!attached) startupHarness = harness;
+		let conversation;
+		let sessionId;
+		if (attached) {
+			conversation = attached.conversation;
+			if (!options.sessionId) throw new Error("A lane requires its session identity.");
+			sessionId = options.sessionId;
+			await writable(() => conversation.configure({
+				extensions: [{ name: extensionName }],
+				tools: tools.filter((t) => activeNames.has(t.name)).map(nativeTool),
+				modelTools: null,
+				instructions: null,
+				cwd: options.cwd,
+				...options.model ? { model: {
+					provider: options.model.provider,
+					modelId: options.model.id
+				} } : {},
+				...options.thinkingLevel ? { thinkingLevel: options.thinkingLevel } : {}
+			}, context));
+			const provider = await harness.snapshot(ProviderDoc, conversation.id, context);
+			if (provider) laneProviderSessions.add(provider.sessionId);
+		} else {
+			const root = await harness.root(context, { agent: {
+				cwd: options.cwd,
+				...options.model ?? models.getModels()[0] ? { model: {
+					provider: (options.model ?? models.getModels()[0]).provider,
+					modelId: (options.model ?? models.getModels()[0]).id
+				} } : {},
+				...options.thinkingLevel ? { thinkingLevel: options.thinkingLevel } : {}
+			} });
+			const activeId = await initializeDurableNavigation(harness, root.id, context);
+			conversation = await harness.conversation(activeId, context);
+			const storedAgent = await harness.snapshot(AgentDoc, conversation.id, context);
+			const initialModel = options.model ?? models.getModels()[0];
+			await conversation.configure({
+				...!storedAgent?.model && initialModel ? { model: {
+					provider: initialModel.provider,
+					modelId: initialModel.id
+				} } : {},
+				...!storedAgent?.thinkingLevel && options.thinkingLevel ? { thinkingLevel: options.thinkingLevel } : {},
+				tools: tools.filter((t) => activeNames.has(t.name)).map(nativeTool)
+			}, context);
+			const storedFastMode = await harness.snapshot(FastModeDoc, context);
+			fastMode = storedFastMode?.enabled ?? options.initialFastMode ?? false;
+			const storedAgentLock = await harness.snapshot(AgentLockDoc, context);
+			agentLocked = storedAgentLock?.locked ?? options.initialAgentLocked ?? false;
+			const storedIdentity = await harness.snapshot(SessionIdentityDoc, context);
+			const mainSessionId = storedIdentity?.id || options.sessionId || randomUUID();
+			sessionId = mainSessionId;
+			const lane = conversation;
+			await writable(() => harness.commit(async (tx) => {
+				const identity = await tx.doc(SessionIdentityDoc);
+				if (!identity.id) {
+					identity.id = mainSessionId;
+					identity.createdAt = Date.now();
+					identity.parentSessionId = options.parentSessionId ?? "";
+				}
+				if (!storedAgentLock && options.initialAgentLocked !== void 0) (await tx.doc(AgentLockDoc)).locked = agentLocked;
+				if (!storedFastMode) {
+					(await tx.doc(FastModeDoc)).enabled = fastMode;
+					if (options.initialFastMode !== void 0) await tx.appendEntry(lane.id, {
+						kind: "po.fast-mode",
+						data: {
+							version: 1,
+							enabled: fastMode,
+							sessionId: mainSessionId
+						}
+					});
+				}
+				const metadata = await tx.doc(SessionMetadataDoc);
+				metadata.workspaceRoot ||= options.cwd;
+				if (options.lane !== void 0) metadata.laneName = options.lane;
+				if (!storedIdentity?.id && options.sessionName !== void 0) metadata.name = options.sessionName;
+			}, context));
+		}
 		const laneName = options.lane ?? "main";
 		let resolveExited;
 		const exited = new Promise((resolve) => {
 			resolveExited = resolve;
 		});
-		const readRecord = async () => JSON.parse((await harness.snapshot(LifecycleDoc, context))?.json ?? "{\"revision\":0,\"paused\":false,\"queue\":[]}");
-		const changeRecord = async (change) => writable(() => harness.commit(async (tx) => {
-			const doc = await tx.doc(LifecycleDoc);
-			const record = JSON.parse(doc.json);
-			const result = change(record);
-			record.revision++;
-			doc.json = JSON.stringify(record);
-			return result;
-		}, context));
+		let laneRecord = {
+			revision: 0,
+			paused: false,
+			held: []
+		};
+		const readRecord = async () => attached ? structuredClone(laneRecord) : JSON.parse((await harness.snapshot(HeldQueueDoc, context))?.json ?? "{\"revision\":0,\"paused\":false,\"held\":[]}");
+		const changeRecord = async (change) => {
+			if (attached) {
+				const record = structuredClone(laneRecord);
+				const result = change(record);
+				record.revision++;
+				laneRecord = record;
+				return result;
+			}
+			return writable(() => harness.commit(async (tx) => {
+				const doc = await tx.doc(HeldQueueDoc);
+				const record = JSON.parse(doc.json);
+				const result = change(record);
+				record.revision++;
+				doc.json = JSON.stringify(record);
+				return result;
+			}, context));
+		};
 		let userAdmission = false;
 		let promptAdmissions = 0;
 		let userAdmissionSettled = Promise.resolve();
@@ -582,12 +655,54 @@ async function createDirectHarnessRuntime(options) {
 			kind: "run",
 			status: "open"
 		} : null);
+		const runAtToolBoundary = (callback) => {
+			if (disposed || disposePromise) return Promise.reject(/* @__PURE__ */ new Error("Direct harness is disposed"));
+			return new Promise((resolve, reject) => {
+				const pending = {
+					async run() {
+						try {
+							resolve(await callback());
+						} catch (error) {
+							reject(error);
+						}
+					},
+					reject
+				};
+				toolBoundaryQueue.push(pending);
+				nativeExecution().then(async (active) => {
+					if (!active && !external) await flushToolBoundary();
+				}).catch((error) => {
+					const index = toolBoundaryQueue.indexOf(pending);
+					if (index !== -1) {
+						toolBoundaryQueue.splice(index, 1);
+						reject(error);
+					}
+				});
+			});
+		};
 		const readLifecycle = async () => {
 			const record = await readRecord();
+			const inbox = await harness.snapshot(InboxDoc, conversation.id, context);
+			const handedOff = [];
+			for (const item of inbox?.items ?? []) {
+				if (item.mode === "write") continue;
+				const requestId = (await storage.storage.submission(item.id, context))?.requestId;
+				if (!requestId?.startsWith(heldRequestId(""))) continue;
+				handedOff.push({
+					id: requestId.slice(heldRequestId("").length),
+					...fromContent(item.content),
+					delivery: item.mode,
+					scheduling: "automatic",
+					disposition: "handoff"
+				});
+			}
 			return {
 				revision: record.revision,
 				paused: record.paused,
-				queue: record.queue.filter((item) => item.explicitQueue === true && item.disposition !== "consumed" && item.disposition !== "removed").map(({ explicitQueue: _q, submissionId: _s, conversationId: _c, message: _m, operationId: _o, attempt: _a, ...item }) => item),
+				queue: [...handedOff, ...record.held.filter((item) => item.explicitQueue).map(({ explicitQueue: _q, message: _m, entry: _e, ...item }) => ({
+					...item,
+					disposition: "pending"
+				}))],
 				operation: await execution()
 			};
 		};
@@ -645,33 +760,7 @@ async function createDirectHarnessRuntime(options) {
 			if (watcher) await watcher.stop();
 			watcher = await watchEvents(harness, conversation.id, context);
 			let predecessor = watcher.snapshot.entries.at(-1)?.id;
-			const customSources = /* @__PURE__ */ new Map();
-			const generatedSources = /* @__PURE__ */ new Map();
-			const rememberCustom = (raw) => {
-				const projected = projectDurableEntries([raw])[0];
-				const data = raw.data && typeof raw.data === "object" && !Array.isArray(raw.data) ? raw.data : void 0;
-				if (projected?.type === "message" && projected.message.role === "custom" && typeof data?.inputRequestId === "string") customSources.set(data.inputRequestId, projected.message);
-			};
-			for (const raw of watcher.snapshot.entries) rememberCustom(raw);
-			for (const requestId of customSources.keys()) {
-				const receipt = await storage.storage.submissionByRequest(conversation.id, requestId, context);
-				if (receipt && receipt.status !== "queued") customSources.delete(requestId);
-			}
-			const generatedEntrySource = async (raw, ctx) => {
-				if (generatedSources.has(raw.id)) return generatedSources.get(raw.id);
-				let source;
-				if (raw.model?.[0]?.role === "user") for (const [requestId, custom] of customSources) {
-					const receipt = await storage.storage.submissionByRequest(conversation.id, requestId, ctx);
-					if (receipt && "entry" in receipt && receipt.entry === raw.id) {
-						source = custom;
-						customSources.delete(requestId);
-						break;
-					}
-				}
-				generatedSources.set(raw.id, source);
-				while (generatedSources.size > 128) generatedSources.delete(generatedSources.keys().next().value);
-				return source;
-			};
+			const toolOutputs = /* @__PURE__ */ new Map();
 			lastAssistant = void 0;
 			partial = void 0;
 			toolResults = [];
@@ -684,13 +773,11 @@ async function createDirectHarnessRuntime(options) {
 						toolResults = [];
 					}
 					if (event.type === "message_end" || event.type === "entry_appended") {
-						rememberCustom(event.entry);
 						const entry = projectDurableEntries([event.entry])[0];
-						await generatedEntrySource(event.entry, eventContext);
 						if (entry) {
 							entry.parentId = predecessor === void 0 ? null : String(predecessor);
 							const added = {
-								type: "entry_added",
+								type: "entry_appended",
 								entry
 							};
 							emit({
@@ -716,8 +803,7 @@ async function createDirectHarnessRuntime(options) {
 					}
 					if (event.type === "message_end" && event.entry.model?.[0]) {
 						const projected = projectDurableEntries([event.entry])[0];
-						if (projected?.type === "custom" && projected.customType === "po.internal-context") continue;
-						const message = await generatedEntrySource(event.entry, eventContext) ?? (projected?.type === "message" && projected.message.role === "custom" ? projected.message : event.entry.model[0]);
+						const message = projected?.type === "message" && projected.message.role === "custom" ? projected.message : event.entry.model[0];
 						if (message.role === "assistant") lastAssistant = message;
 						if (message.role === "toolResult") toolResults.push(message);
 						mapped = {
@@ -729,12 +815,13 @@ async function createDirectHarnessRuntime(options) {
 					}
 					if (event.type === "tool_execution_start") mapped = {
 						...event,
-						type: "tool_start"
+						type: "tool_execution_start"
 					};
 					if (event.type === "tool_execution_end") {
+						toolOutputs.delete(event.toolCallId);
 						const result = event.entry?.model?.find((m) => m.role === "toolResult");
 						mapped = {
-							type: "tool_end",
+							type: "tool_execution_end",
 							toolCallId: event.toolCallId,
 							toolName: event.toolName,
 							result: {
@@ -775,24 +862,29 @@ async function createDirectHarnessRuntime(options) {
 								}
 							};
 							emit({
-								...update,
-								assistantMessageEvent: update.event
+								type: "message_update",
+								message: update.message
 							});
 							eventsSettled = eventsSettled.then(() => deliver(update, eventContext));
 						}
 					}
-					if (event.type === "tool_execution_update") mapped = {
-						type: "tool_update",
-						toolCallId: event.toolCallId,
-						toolName: event.toolName,
-						partialResult: {
-							content: [{
-								type: "text",
-								text: event.output ? "set" in event.output ? event.output.set : event.output.append ?? "" : ""
-							}],
-							details: event.details
-						}
-					};
+					if (event.type === "tool_execution_update") {
+						const previous = toolOutputs.get(event.toolCallId) ?? "";
+						const output = !event.output ? previous : "set" in event.output ? event.output.set : previous.slice(event.output.trimStart ?? 0) + (event.output.append ?? "");
+						toolOutputs.set(event.toolCallId, output);
+						mapped = {
+							type: "tool_execution_update",
+							toolCallId: event.toolCallId,
+							toolName: event.toolName,
+							partialResult: {
+								content: [{
+									type: "text",
+									text: output
+								}],
+								details: event.details
+							}
+						};
+					}
 					if (event.type === "compaction_end") {
 						const outcome = (await harness.waitForTask(event.taskId, eventContext)).state.outcome;
 						const result = outcome.status === "completed" ? outcome.result : void 0;
@@ -803,7 +895,7 @@ async function createDirectHarnessRuntime(options) {
 							status: outcome.status === "completed" ? result?.entryId !== void 0 || result?.submissionId !== void 0 ? "completed" : "aborted" : outcome.status === "aborted" ? "aborted" : "failed",
 							reason: event.reason,
 							entryId: entryId === void 0 ? void 0 : String(entryId),
-							error: outcome.status !== "completed" && outcome.status !== "aborted" ? new Error("error" in outcome ? outcome.error?.message ?? "Compaction failed" : "Compaction failed") : void 0
+							error: event.error === void 0 ? void 0 : new Error(event.error)
 						};
 					}
 					if (event.type === "inbox_update") mapped = {
@@ -820,10 +912,6 @@ async function createDirectHarnessRuntime(options) {
 						}, eventContext));
 					}
 					if (!mapped) continue;
-					const publishMapped = (event) => emit({
-						...event,
-						type: event.type === "tool_start" ? "tool_execution_start" : event.type === "tool_update" ? "tool_execution_update" : event.type === "tool_end" ? "tool_execution_end" : event.type === "entry_added" ? "entry_appended" : event.type
-					});
 					if (mapped.type === "run_end") {
 						const settledEvent = {
 							runId: String(event.type === "run_end" ? event.inputs[0] : conversation.id),
@@ -838,6 +926,7 @@ async function createDirectHarnessRuntime(options) {
 							}
 						};
 						eventsSettled = eventsSettled.then(async () => {
+							if (!await nativeExecution() && !external) await flushToolBoundary();
 							await reconcile();
 							try {
 								await writable(() => harness.commit((tx) => tx.appendEntry(conversation.id, {
@@ -864,7 +953,7 @@ async function createDirectHarnessRuntime(options) {
 								successorActive,
 								aborted
 							};
-							publishMapped(mapped);
+							emit(mapped);
 							await deliver(mapped, eventContext);
 							release();
 							const lifecycle = await readLifecycle();
@@ -903,14 +992,14 @@ async function createDirectHarnessRuntime(options) {
 									error: String(error)
 								});
 							}
-							drain().catch((error) => emit({
+							dispatch().catch((error) => emit({
 								type: "error",
-								code: "drain",
+								code: "dispatch",
 								error: String(error)
 							}));
 						});
 					} else {
-						publishMapped(mapped);
+						emit(mapped);
 						if (mapped.type === "run_start") {
 							if (!logicalLoopActive) emit({ type: "agent_start" });
 							logicalLoopActive = true;
@@ -927,6 +1016,7 @@ async function createDirectHarnessRuntime(options) {
 			});
 		};
 		await attach();
+		const internalDeliveries = /* @__PURE__ */ new Map();
 		const reconcileInternal = (requestId, item) => {
 			const existing = reconcilingInternal.get(requestId);
 			if (existing) return existing;
@@ -942,50 +1032,17 @@ async function createDirectHarnessRuntime(options) {
 				if (receipt?.status === "queued") return;
 				if (!receipt || receipt.status === "unanswered" && receipt.entry === void 0) {
 					if ((await harness.snapshot(LiveDoc, target.id, context))?.run) return;
-					let envelope = item.message.role === "custom" ? await storage.storage.submissionByRequest(target.id, `${requestId}:message`, context) : void 0;
-					if (item.message.role === "custom" && !envelope) {
-						await (await writable(() => target.submit({
-							type: "write",
-							requestId: `${requestId}:message`,
-							entry: {
-								kind: "po.entry",
-								data: json({
-									type: "message",
-									message: item.message,
-									timestamp: item.message.timestamp,
-									inputRequestId: requestId
-								})
-							}
-						}, context))).wait(context);
-						envelope = await storage.storage.submissionByRequest(target.id, `${requestId}:message`, context);
-					}
-					if (envelope?.status === "queued") {
-						await (await writable(() => target.submit({
-							type: "write",
-							requestId: `${requestId}:message-placement`,
-							entry: { kind: "po.internal-delivery" }
-						}, context))).wait(context);
-						envelope = await storage.storage.submissionByRequest(target.id, `${requestId}:message`, context);
-					}
-					const envelopeId = envelope && "entry" in envelope ? envelope.entry : void 0;
 					const draft = {
 						type: "write",
 						requestId: `${requestId}:context`,
 						entry: {
 							kind: "po.entry",
-							data: json(item.message.role === "custom" ? {
-								type: "custom",
-								customType: "po.internal-context",
-								data: { inputRequestId: requestId }
-							} : {
+							data: json({
 								type: "message",
-								message: item.message
+								message: item.message,
+								timestamp: item.message.timestamp
 							}),
-							...envelopeId === void 0 ? { model: convertToLlm([item.message]) } : { edits: [{
-								target: envelopeId,
-								action: "replace",
-								messages: convertToLlm([item.message])
-							}] }
+							model: convertToLlm([item.message])
 						}
 					};
 					let fallback;
@@ -998,9 +1055,7 @@ async function createDirectHarnessRuntime(options) {
 					}
 					if ((await fallback.wait(context)).status !== "done") throw new Error("Internal context write failed");
 				}
-				await changeRecord((r) => {
-					delete r.internalDeliveries?.[requestId];
-				});
+				internalDeliveries.delete(requestId);
 			})().finally(() => {
 				reconcilingInternal.delete(requestId);
 			});
@@ -1008,156 +1063,83 @@ async function createDirectHarnessRuntime(options) {
 			return work;
 		};
 		const reconcile = async () => {
-			const record = await readRecord();
-			for (const [requestId, item] of Object.entries(record.internalDeliveries ?? {})) {
+			for (const [requestId, item] of internalDeliveries) {
 				if (admittingInternal.has(requestId)) continue;
 				if ((await harness.snapshot(LiveDoc, item.conversationId, context))?.run) continue;
 				const receipt = await storage.storage.submissionByRequest(item.conversationId, requestId, context);
 				if (receipt?.status === "queued") await harness.abortSubmission(receipt.id, context);
 			}
-			for (const [requestId, item] of Object.entries(record.internalDeliveries ?? {})) await reconcileInternal(requestId, item);
-			for (const item of record.queue) {
-				if (item.disposition !== "handoff" && item.disposition !== "uncertain") continue;
-				const status = await (item.submissionId ? await harness.submission(item.submissionId, context) : void 0)?.status(context);
-				if (status?.status === "done" || status?.status === "placed" || status?.status === "unanswered") await changeRecord((r) => {
-					const q = r.queue.find((q) => q.id === item.id);
-					if (!q) return;
-					if (status.status === "unanswered" && status.entry === void 0 && r.paused) {
-						q.disposition = "pending";
-						q.attempt = (q.attempt ?? 0) + 1;
-						delete q.submissionId;
-					} else {
-						q.disposition = "consumed";
-						q.text = "";
-						delete q.message;
-						delete q.images;
-					}
-					const receipts = r.queue.filter((q) => q.disposition === "consumed" || q.disposition === "removed");
-					if (receipts.length > 128) {
-						const expired = new Set(receipts.slice(0, receipts.length - 128).map((q) => q.id));
-						r.queue = r.queue.filter((q) => !expired.has(q.id));
-					}
-				});
-				else if (!status && !handingOff.has(item.id) && !userClaims.has(item.id)) await changeRecord((r) => {
-					const q = r.queue.find((q) => q.id === item.id);
-					if (q) q.disposition = "uncertain";
-				});
+			for (const [requestId, item] of internalDeliveries) await reconcileInternal(requestId, item);
+		};
+		const submitInput = async (draft) => {
+			try {
+				return await writable(() => conversation.submit(draft, context));
+			} catch (error) {
+				const accepted = await storage.storage.submissionByRequest(conversation.id, draft.requestId, context);
+				const submission = accepted && await harness.submission(accepted.id, context);
+				if (!submission) throw error;
+				return submission;
 			}
 		};
 		const handingOff = /* @__PURE__ */ new Set();
-		const userClaims = /* @__PURE__ */ new Set();
-		let drainPromise;
-		let drainRequested = false;
-		const drain = () => {
-			if (drainPromise) {
-				drainRequested = true;
-				return drainPromise;
+		let dispatching;
+		let dispatchRequested = false;
+		const dispatch = () => {
+			if (dispatching) {
+				dispatchRequested = true;
+				return dispatching;
 			}
-			return drainPromise ??= (async () => {
-				await reconcile();
+			return dispatching = (async () => {
 				while (!disposed) {
 					const record = await readRecord();
-					if (agentLocked || userAdmission || record.paused || await execution()) break;
-					const item = record.queue.find((q) => q.disposition === "pending");
-					if (!item) break;
-					const submission = await handoff(item, "reject");
-					if (!submission) continue;
-					await submission.wait(context);
-					await eventsSettled;
-					await reconcile();
+					if (agentLocked || userAdmission || external || record.paused) break;
+					const idle = !await execution();
+					const item = record.held.find((q) => idle || !q.explicitQueue);
+					if (!item || userAdmission || external) break;
+					try {
+						if (!await changeRecord((r) => {
+							if (!r.held.some((q) => q.id === item.id)) return false;
+							handingOff.add(item.id);
+							return true;
+						})) continue;
+						await submitInput({
+							type: "input",
+							content: heldContent(item.message ?? item.text, item.images),
+							whenBusy: "followUp",
+							requestId: heldRequestId(item.id),
+							...item.entry ? { entry: item.entry } : {}
+						});
+						await changeRecord((r) => {
+							r.held = r.held.filter((q) => q.id !== item.id);
+						});
+					} finally {
+						handingOff.delete(item.id);
+					}
 					await publish();
 				}
 			})().finally(() => {
-				drainPromise = void 0;
-				if (drainRequested) {
-					drainRequested = false;
-					drain().catch((error) => emit({
+				dispatching = void 0;
+				if (dispatchRequested) {
+					dispatchRequested = false;
+					dispatch().catch((error) => emit({
 						type: "error",
-						code: "drain",
+						code: "dispatch",
 						error: String(error)
 					}));
 				}
 			});
 		};
-		const handoff = async (item, mode, recovering = false, allowPaused = false) => {
-			if (external || handingOff.has(item.id)) return void 0;
-			handingOff.add(item.id);
-			try {
-				const claimed = await changeRecord((r) => {
-					const q = r.queue.find((q) => q.id === item.id);
-					if (!q || r.paused && !recovering && !allowPaused) return void 0;
-					if (recovering ? q.disposition !== "handoff" || q.submissionId !== void 0 : q.disposition !== "pending") return void 0;
-					q.disposition = "handoff";
-					q.conversationId = conversation.id;
-					q.submissionMode = mode;
-					if (item.operationId !== void 0) {
-						q.delivery = item.delivery;
-						q.operationId = item.operationId;
-					}
-					return q;
-				});
-				if (!claimed) return void 0;
-				const content = input(claimed.message ?? claimed.text, claimed.images);
-				const requestId = `${claimed.id}:${claimed.attempt ?? 0}`;
-				const submit = () => writable(() => conversation.submit(mode === "write" ? {
-					type: "write",
-					requestId,
-					entry: {
-						kind: "po.message",
-						model: [{
-							role: "user",
-							content,
-							timestamp: Date.now()
-						}]
-					}
-				} : {
-					type: "input",
-					content,
-					whenBusy: mode,
-					requestId
-				}, context));
-				let submission;
-				try {
-					submission = await submit();
-				} catch (error) {
-					const accepted = await storage.storage.submissionByRequest(conversation.id, requestId, context);
-					if (!accepted) throw error;
-					submission = await harness.submission(accepted.id, context);
-					if (!submission) throw error;
-				}
-				await changeRecord((r) => {
-					const q = r.queue.find((q) => q.id === item.id);
-					if (q) q.submissionId = submission.id;
-				});
-				await reconcile();
-				await publish();
-				return submission;
-			} finally {
-				handingOff.delete(item.id);
-			}
-		};
-		const input = (message, images) => {
-			if (typeof message !== "string") {
-				if (message.role !== "user") throw new Error("Only user messages can admit an agent run");
-				return message.content;
-			}
-			return images?.length ? [{
-				type: "text",
-				text: message
-			}, ...images] : message;
-		};
-		const enqueue = async (message, images, delivery, scheduling, explicitQueue = false) => {
+		const enqueue = async (message, images, delivery, explicitQueue) => {
 			const id = randomUUID();
 			await changeRecord((r) => {
-				r.queue.push({
+				r.held.push({
 					id,
 					text: text(message),
 					...images ? { images } : {},
 					...typeof message === "string" ? {} : { message },
 					delivery,
-					scheduling,
-					explicitQueue,
-					disposition: "pending"
+					scheduling: "automatic",
+					explicitQueue
 				});
 			});
 			await publish();
@@ -1166,11 +1148,17 @@ async function createDirectHarnessRuntime(options) {
 		const queued = async (message, images, delivery) => {
 			guardUserAdmission();
 			assertUnlocked();
-			await enqueue(message, images, delivery, "automatic");
-			drain().catch((error) => emit({
-				type: "error",
-				error: String(error)
-			}));
+			if (external || (await readRecord()).paused) {
+				await enqueue(message, images, delivery, false);
+				return;
+			}
+			await submitInput({
+				type: "input",
+				content: heldContent(message, images),
+				whenBusy: "followUp",
+				requestId: randomUUID()
+			});
+			await publish();
 		};
 		const dispatchCommand = async (value) => options.dispatchCommand?.(value) ?? false;
 		const admit = async (message, images, mode) => {
@@ -1185,11 +1173,14 @@ async function createDirectHarnessRuntime(options) {
 			promptAdmissions++;
 			try {
 				assertUnlocked();
-				const record = await readRecord();
 				await flushNextTurn();
-				const { id } = await enqueue(message, images, mode ?? "nextRun", "automatic");
-				const submission = await handoff((await readRecord()).queue.find((q) => q.id === id), mode ?? "reject", false, record.paused);
-				if (!submission) return { settled: Promise.resolve() };
+				const submission = await submitInput({
+					type: "input",
+					content: heldContent(message, images),
+					whenBusy: mode ?? "reject",
+					requestId: randomUUID()
+				});
+				await publish();
 				let resolveDelivery;
 				const delivered = new Promise((resolve) => {
 					resolveDelivery = resolve;
@@ -1207,7 +1198,7 @@ async function createDirectHarnessRuntime(options) {
 						await reconcile();
 						await publish();
 						if (status.status === "unanswered" && status.reason !== "aborted") throw new Error(`Agent submission failed: ${status.reason}${typeof status.detail === "string" && status.detail ? `: ${status.detail}` : ""}`);
-						await drain();
+						await dispatch();
 					} finally {
 						internalDelivery.delete(submission.id);
 					}
@@ -1228,17 +1219,51 @@ async function createDirectHarnessRuntime(options) {
 				externalAbort?.abort();
 				return;
 			}
-			const taskId = (await harness.snapshot(LiveDoc, conversation.id, context))?.run?.taskId ?? nativeId(current.id);
-			await changeRecord((r) => {
-				r.paused = true;
-				r.abortOperationId = current.id;
-				r.abortTaskId = taskId;
-			});
-			await publish();
-			await writable(async () => {
+			const stop = () => writable(async () => {
 				if (current.kind === "run") await conversation.abort(context);
-				else await harness.abortTask(taskId, context);
+				else await harness.abortTask(nativeId(current.id), context);
 			});
+			if (attached) {
+				await stop();
+				await reconcile();
+				return;
+			}
+			const captured = /* @__PURE__ */ new Set();
+			if (current.kind === "run") for (const item of (await harness.snapshot(InboxDoc, conversation.id, context))?.items ?? []) {
+				if (item.mode === "write") continue;
+				const requestId = (await storage.storage.submission(item.id, context))?.requestId;
+				if (requestId === void 0 || !internalDeliveries.has(requestId)) captured.add(item.id);
+			}
+			await writable(() => harness.commit(async (tx) => {
+				const doc = await tx.doc(HeldQueueDoc);
+				const record = JSON.parse(doc.json);
+				record.paused = true;
+				record.abortOperationId = current.id;
+				const items = (await tx.doc(InboxDoc, conversation.id)).items;
+				const moved = [];
+				for (let index = items.length - 1; index >= 0; index--) {
+					const item = items[index];
+					if (item.mode === "write" || !captured.has(item.id)) continue;
+					moved.unshift({
+						id: randomUUID(),
+						...fromContent(item.content),
+						...item.entry ? { entry: item.entry } : {},
+						delivery: item.mode,
+						scheduling: "automatic",
+						explicitQueue: true
+					});
+					tx.settleSubmission(item.id, {
+						status: "unanswered",
+						reason: "aborted"
+					});
+					items.splice(index, 1);
+				}
+				record.held.unshift(...moved);
+				record.revision++;
+				doc.json = JSON.stringify(record);
+			}, context));
+			await publish();
+			await stop();
 			await reconcile();
 		};
 		const interrupt = async () => {
@@ -1246,220 +1271,51 @@ async function createDirectHarnessRuntime(options) {
 			await writable(() => conversation.abort(context));
 			await eventsSettled;
 		};
-		const admitSelected = async (selection, replay = false) => writable(() => harness.commit(async (tx) => {
-			const doc = await tx.doc(LifecycleDoc);
-			const record = JSON.parse(doc.json);
-			const q = record.queue.find((q) => q.id === selection.id);
-			if (!q || q.explicitQueue !== true) return "not_found";
-			const requestId = `${q.id}:${q.attempt ?? 0}`;
-			const accepted = await tx.submissionByRequest(conversation.id, requestId);
-			if (accepted && accepted.type !== "input") throw new Error(`Request ${requestId} already identifies a submission of type ${accepted.type}`);
-			if (accepted && replay) return accepted.id;
-			if (q.disposition === "removed" || q.disposition === "consumed") return "not_found";
-			if (accepted || q.disposition !== "pending") return "in_flight";
-			const live = await tx.doc(LiveDoc, conversation.id);
-			const task = live.run ? await tx.task(live.run.taskId) : void 0;
-			if ((live.run ? String(live.run.inputs[0]) : void 0) !== selection.operationId || task?.abortRequested || live.run && record.abortOperationId === selection.operationId) return "target_changed";
-			if (!live.run) {
-				let page = await tx.scanTasks({
-					conversationId: conversation.id,
-					kind: CompactionTask.definition.name,
-					background: false
-				}, 128);
-				while (true) {
-					if (page.items.some((task) => task.state.status !== "terminal")) return "target_changed";
-					if (!page.next) break;
-					page = await tx.scanTasks({
-						conversationId: conversation.id,
-						kind: CompactionTask.definition.name,
-						background: false
-					}, 128, page.next);
-				}
-			}
-			const content = input(q.message ?? q.text, q.images);
-			const inbox = await tx.doc(InboxDoc, conversation.id);
-			let head = live.run ? void 0 : (await tx.latestHeadMarker(conversation.id))?.head;
-			const now = Date.now();
-			let id;
-			if (!live.run && inbox.items.length === 0) {
-				const entry = await tx.appendEntry(UserEntry, conversation.id, { model: [{
-					role: "user",
-					content,
-					timestamp: now
-				}] });
-				id = (await tx.createSubmission({
-					conversationId: conversation.id,
-					requestId,
-					type: "input",
-					status: "placed",
-					entry: entry.id
-				})).id;
-				live.run = {
-					taskId: await tx.createTask(GenerationTask, {}, {
-						ownership: { kind: "conversation" },
-						conversationId: conversation.id
-					}),
-					inputs: [id]
-				};
-			} else {
-				id = (await tx.createSubmission({
-					conversationId: conversation.id,
-					requestId,
-					type: "input",
-					status: "queued"
-				})).id;
-				inbox.items.push({
-					id,
-					mode: "steer",
-					content: json(content)
-				});
-				if (!live.run) {
-					const writes = inbox.items.flatMap((item, index) => item.mode === "write" ? [index] : []);
-					const pick = (mode) => {
-						const indexes = inbox.items.flatMap((item, index) => item.mode === mode ? [index] : []);
-						return (mode === "steer" ? settings.steeringMode : settings.followUpMode) === "all" ? indexes : indexes.slice(0, 1);
-					};
-					const users = [...pick("steer"), ...pick("followUp")].sort((a, b) => a - b);
-					for (const index of writes) {
-						const item = inbox.items[index];
-						if (item.mode !== "write") continue;
-						const draft = item.entry;
-						if (typeof draft.head === "number" && head !== void 0 && draft.head < head) {
-							tx.settleSubmission(item.id, {
-								status: "unanswered",
-								reason: "stale"
-							});
-							continue;
-						}
-						const entry = await tx.appendEntry(conversation.id, draft);
-						if (draft.head !== void 0) head = draft.head === "self" ? entry.id : draft.head;
-						tx.placeSubmission(item.id, entry.id);
-					}
-					const inputs = [];
-					for (const index of users) {
-						const item = inbox.items[index];
-						if (item.mode === "write") continue;
-						const entry = await tx.appendEntry(UserEntry, conversation.id, { model: [{
-							role: "user",
-							content: item.content,
-							timestamp: now
-						}] });
-						tx.placeSubmission(item.id, entry.id);
-						inputs.push(item.id);
-					}
-					for (const index of [...writes, ...users].sort((a, b) => b - a)) inbox.items.splice(index, 1);
-					if (inputs.length) live.run = {
-						taskId: await tx.createTask(GenerationTask, {}, {
-							ownership: { kind: "conversation" },
-							conversationId: conversation.id
-						}),
-						inputs
-					};
-				}
+		const admitUser = async (work) => {
+			userAdmission = true;
+			userAdmissionSettled = new Promise((resolve) => {
+				releaseUserAdmission = resolve;
+			});
+			try {
+				return await work();
+			} finally {
+				userAdmission = false;
+				releaseUserAdmission?.();
+				releaseUserAdmission = void 0;
 			}
-			q.disposition = "handoff";
-			q.conversationId = conversation.id;
-			q.submissionMode = "steer";
-			q.submissionId = id;
-			record.revision++;
-			doc.json = JSON.stringify(record);
-			return id;
-		}, context));
-		const submitUserPrompt = async (message, images, selection, submissionMode = "reject") => {
+		};
+		const submitUserPrompt = async (message, images, submissionMode = "reject") => {
 			guardUserAdmission();
 			if (external) throw new Error("An operation is already running");
-			if (!selection && (typeof message === "string" ? !message && !images?.length : !message.content.length)) throw new Error("User input must contain text or an image");
-			if (!selection && typeof message === "string" && await dispatchCommand(message)) return {
+			if (typeof message === "string" ? !message && !images?.length : !message.content.length) throw new Error("User input must contain text or an image");
+			if (typeof message === "string" && await dispatchCommand(message)) return {
 				settled: Promise.resolve(),
 				handledCommand: true
 			};
 			assertUnlocked();
 			guardUserAdmission();
 			if (external) throw new Error("An operation is already running");
-			userAdmission = true;
-			userAdmissionSettled = new Promise((resolve) => {
-				releaseUserAdmission = resolve;
-			});
-			let claimed;
-			try {
-				if (selection && submissionMode === "steer") {
-					let admitted;
-					try {
-						admitted = await admitSelected(selection);
-					} catch (error) {
-						if (!await storage.storage.submissionByRequest(conversation.id, `${selection.id}:${(await readRecord()).queue.find((q) => q.id === selection.id)?.attempt ?? 0}`, context)) throw error;
-						admitted = await admitSelected(selection, true);
-					}
-					if (typeof admitted === "string") return {
-						settled: Promise.resolve(),
-						queueOutcome: admitted
-					};
-					const submission = await harness.submission(admitted, context);
-					if (!submission) throw new Error("Accepted promotion submission is missing");
-					const settled = (async () => {
-						const status = await submission.wait(context);
-						await eventsSettled;
-						await reconcile();
-						await publish();
-						if (status.status === "unanswered" && status.reason !== "aborted") throw new Error(`Agent submission failed: ${status.reason}`);
-						await drain();
-					})();
-					settled.catch((error) => emit({
-						type: "error",
-						code: "user_prompt",
-						error: String(error)
-					}));
-					await reconcile();
-					await publish();
-					return { settled };
-				}
-				const current = await execution();
-				if (selection) {
-					const outcome = await changeRecord((r) => {
-						const q = r.queue.find((q) => q.id === selection.id);
-						if (!q || q.explicitQueue !== true || q.disposition === "removed" || q.disposition === "consumed") return "not_found";
-						if (q.disposition !== "pending") return "in_flight";
-						if (current?.id !== selection.operationId || current?.status === "aborting") return "target_changed";
-						if (q.message && q.message.role !== "user") throw new Error("Only user input can interrupt and respond");
-						userClaims.add(q.id);
-						if (submissionMode === "reject") r.paused = true;
-						q.disposition = "handoff";
-						q.conversationId = conversation.id;
-						q.submissionMode = submissionMode;
-						return { ...q };
-					});
-					if (typeof outcome === "string") return {
-						settled: Promise.resolve(),
-						queueOutcome: outcome
-					};
-					claimed = outcome;
-				}
+			return admitUser(async () => {
 				if (submissionMode === "reject") {
+					const current = await execution();
 					if (current) await abort(current.id);
 					await conversation.waitForIdle(context);
 					await eventsSettled;
 				}
-				if (!selection) await flushNextTurn();
-				if (!claimed) {
-					const { id } = await enqueue(message, images, submissionMode === "steer" ? "steer" : "nextRun", submissionMode === "steer" ? "automatic" : "held");
-					claimed = await changeRecord((r) => {
-						const q = r.queue.find((q) => q.id === id);
-						if (!q || q.disposition !== "pending") throw new Error("User input was removed before admission");
-						q.disposition = "handoff";
-						q.conversationId = conversation.id;
-						q.submissionMode = submissionMode;
-						return { ...q };
-					});
-				}
-				const submission = await handoff(claimed, submissionMode, true);
-				if (!submission) throw new Error("User admission ownership changed");
+				await flushNextTurn();
+				const submission = await submitInput({
+					type: "input",
+					content: heldContent(message, images),
+					whenBusy: submissionMode,
+					requestId: randomUUID()
+				});
 				const settled = (async () => {
 					const status = await submission.wait(context);
 					await eventsSettled;
 					await reconcile();
 					await publish();
 					if (status.status === "unanswered" && status.reason !== "aborted") throw new Error(`Agent submission failed: ${status.reason}`);
-					await drain();
+					await dispatch();
 				})();
 				settled.catch((error) => emit({
 					type: "error",
@@ -1468,32 +1324,21 @@ async function createDirectHarnessRuntime(options) {
 				}));
 				await publish();
 				return { settled };
-			} finally {
-				if (claimed) userClaims.delete(claimed.id);
-				if (selection) userClaims.delete(selection.id);
-				userAdmission = false;
-				releaseUserAdmission?.();
-				releaseUserAdmission = void 0;
-			}
+			});
 		};
 		const recover = async () => {
 			const r = await readRecord();
-			if (r.abortOperationId) {
-				const task = r.abortTaskId === void 0 ? void 0 : await harness.getTask(r.abortTaskId, context);
-				if (task && task.state.status !== "terminal") await conversation.abort(context);
-			}
-			for (const item of r.queue.filter((q) => q.disposition === "handoff" && !q.submissionId)) {
-				if (item.conversationId !== conversation.id) {
-					await changeRecord((record) => {
-						const q = record.queue.find((q) => q.id === item.id);
-						if (q) q.disposition = "uncertain";
-					});
-					continue;
-				}
-				await handoff(item, item.submissionMode ?? (item.delivery === "steer" ? "steer" : "followUp"), true);
+			const current = r.abortOperationId ? await nativeExecution() : null;
+			if (current?.id === r.abortOperationId) {
+				if (current?.kind === "run") await conversation.abort(context);
+				else if (current) await harness.abortTask(nativeId(current.id), context);
 			}
+			const accepted = /* @__PURE__ */ new Set();
+			for (const item of r.held) if (await storage.storage.submissionByRequest(conversation.id, heldRequestId(item.id), context)) accepted.add(item.id);
 			await reconcile();
-			await changeRecord(() => void 0);
+			await changeRecord((record) => {
+				record.held = record.held.filter((q) => !accepted.has(q.id));
+			});
 		};
 		const admissionBusy = () => userAdmission || promptAdmissions > 0 || settling > 0 || handingOff.size > 0 || admittingInternal.size > 0 || compactionAdmission;
 		const runExternalOperation = async (work, { signal, waitMs = 0 } = {}) => {
@@ -1502,7 +1347,7 @@ async function createDirectHarnessRuntime(options) {
 			const pendingFollowUp = async () => {
 				if (waitMs === 0 || agentLocked) return false;
 				const record = await readRecord();
-				return !record.paused && record.queue.some((item) => item.disposition === "pending" || item.disposition === "handoff");
+				return !record.paused && record.held.length > 0;
 			};
 			for (;;) {
 				if (waitMs === 0) guardUserAdmission();
@@ -1518,12 +1363,13 @@ async function createDirectHarnessRuntime(options) {
 						const changed = await nativeExecution() || await pendingFollowUp();
 						signal?.throwIfAborted();
 						if (disposed || disposePromise) throw new Error("Direct harness is disposed");
-						if (waitMs > 0 && Date.now() >= deadline) throw new DoomHeadlessToolBusyError();
+						if (waitMs > 0 && Date.now() >= deadline) throw new PoHeadlessToolBusyError();
 						admitted = !changed && !admissionBusy();
 					} finally {
 						if (!admitted) {
 							external = void 0;
-							drain().catch((error) => emit({
+							if (!await nativeExecution()) await flushToolBoundary();
+							dispatch().catch((error) => emit({
 								type: "error",
 								error: String(error)
 							}));
@@ -1532,7 +1378,7 @@ async function createDirectHarnessRuntime(options) {
 					if (admitted) break;
 				}
 				const remaining = deadline - Date.now();
-				if (remaining <= 0) throw new DoomHeadlessToolBusyError();
+				if (remaining <= 0) throw new PoHeadlessToolBusyError();
 				let timer;
 				try {
 					await awaitWithContext(new Promise((resolve) => {
@@ -1549,8 +1395,9 @@ async function createDirectHarnessRuntime(options) {
 			} finally {
 				external = void 0;
 				externalAbort = void 0;
+				await flushToolBoundary();
 				await publish();
-				drain().catch((error) => emit({
+				dispatch().catch((error) => emit({
 					type: "error",
 					error: String(error)
 				}));
@@ -1562,29 +1409,17 @@ async function createDirectHarnessRuntime(options) {
 			if (receipt.status !== "done") throw new Error(`Entry write failed: ${receipt.reason}`);
 			return String(receipt.entry);
 		};
-		const restoreCustomContextMessages = async (messages, ctx, view, conversationId = conversation.id) => {
+		const restoreCustomContextMessages = (messages, view) => {
 			const contextContributions = /* @__PURE__ */ new Map();
-			const customByEntry = /* @__PURE__ */ new Map();
-			for (const raw of view.entries) {
-				const entry = projectDurableEntries([raw])[0];
-				if (entry?.type !== "message" || entry.message.role !== "custom") continue;
-				const data = raw.data && typeof raw.data === "object" && !Array.isArray(raw.data) ? raw.data : void 0;
-				const receipt = typeof data?.inputRequestId === "string" ? await storage.storage.submissionByRequest(conversationId, data.inputRequestId, ctx) : void 0;
-				const placed = (receipt?.status === "unanswered" && !("entry" in receipt && receipt.entry !== void 0) && typeof data?.inputRequestId === "string" ? await storage.storage.submissionByRequest(conversationId, `${data.inputRequestId}:context`, ctx) : void 0) ?? receipt;
-				const placedEntry = placed && "entry" in placed && placed.entry !== void 0 ? view.entries.find((candidate) => candidate.id === placed.entry) : void 0;
-				const target = placedEntry?.edits?.some((edit) => edit.target === raw.id) ? raw.id : placedEntry?.id ?? raw.id;
-				const contributions = view.contributions[view.entries.findIndex((candidate) => candidate.id === target)];
-				const model = (placedEntry?.edits?.find((edit) => edit.target === raw.id && edit.action === "replace"))?.messages ?? view.entries.find((candidate) => candidate.id === target)?.model;
-				if (model?.length === 1 && contributions?.length === 1 && JSON.stringify(model[0]) === JSON.stringify(contributions[0])) customByEntry.set(target, entry.message);
-			}
 			for (const [index, raw] of view.entries.entries()) {
-				const custom = customByEntry.get(raw.id);
-				for (const native of view.contributions[index] ?? []) {
+				const entry = projectDurableEntries([raw])[0];
+				const contributions = view.contributions[index] ?? [];
+				const custom = entry?.type === "message" && entry.message.role === "custom" && raw.model?.length === 1 && contributions.length === 1 && JSON.stringify(raw.model[0]) === JSON.stringify(contributions[0]) ? entry.message : void 0;
+				for (const native of contributions) {
 					const key = JSON.stringify(native);
-					const message = custom && view.contributions[index]?.length === 1 ? custom : native;
-					const contributions = contextContributions.get(key) ?? [];
-					contributions.push(message);
-					contextContributions.set(key, contributions);
+					const restored = contextContributions.get(key) ?? [];
+					restored.push(custom ?? native);
+					contextContributions.set(key, restored);
 				}
 			}
 			return messages.filter((message) => message.role !== "system").map((message) => contextContributions.get(JSON.stringify(message))?.shift() ?? message);
@@ -1596,14 +1431,20 @@ async function createDirectHarnessRuntime(options) {
 				leafId: entries.at(-1)?.id ?? null
 			};
 		};
+		let statsCache;
 		const getSessionStats = async () => {
-			const { entries } = await readEntries();
+			const lane = conversation;
+			const cached = statsCache;
+			const previous = cached?.conversation === lane ? cached : void 0;
+			const entries = (await projectDurableConversationEntries(lane, context, previous?.seq)).filter((entry) => previous?.seq === void 0 || entry.seq > previous.seq);
 			const messages = entries.flatMap((e) => e.type === "message" ? [e.message] : []);
 			const agent = await conversation.agent(context);
 			const selected = agent.model ? models.getModel(agent.model.provider, agent.model.modelId) : void 0;
-			const contextUsage = contextUsageOf(contextTokensOf(latestAssistantUsage(entries)), selected?.contextWindow);
-			const usage = await harness.usage(context);
-			const all = [...Object.values(usage.models), ...Object.values(usage.tools)];
+			const latest = messages.findLast((message) => message.role === "assistant");
+			const contextTokens = latest?.role === "assistant" ? contextTokensOf(latest.usage) : previous?.contextTokens ?? null;
+			const contextUsage = contextUsageOf(contextTokens, selected?.contextWindow);
+			const usage = attached ? await harness.snapshot(UsageDoc, conversation.id, context) : await harness.usage(context);
+			const children = attached ? [] : await Promise.all((await subagentConversations(harness, context)).map((id) => harness.snapshot(UsageDoc, id, context)));
 			const tokens = {
 				input: 0,
 				output: 0,
@@ -1612,24 +1453,39 @@ async function createDirectHarnessRuntime(options) {
 				total: 0
 			};
 			let cost = 0;
-			for (const u of all) {
-				tokens.input += u.input;
-				tokens.output += u.output;
-				tokens.cacheRead += u.cacheRead;
-				tokens.cacheWrite += u.cacheWrite;
-				tokens.total += u.totalTokens;
-				cost += u.cost.total;
-			}
+			const add = (ledger, sign) => {
+				const rows = [...Object.values(ledger?.models ?? {}), ...Object.values(ledger?.tools ?? {})];
+				for (const u of rows) {
+					tokens.input += sign * u.input;
+					tokens.output += sign * u.output;
+					tokens.cacheRead += sign * u.cacheRead;
+					tokens.cacheWrite += sign * u.cacheWrite;
+					tokens.total += sign * u.totalTokens;
+					cost += sign * u.cost.total;
+				}
+			};
+			add(usage, 1);
+			for (const child of children) add(child, -1);
+			const next = {
+				conversation: lane,
+				seq: entries.at(-1)?.seq ?? previous?.seq,
+				contextTokens,
+				messageCount: (previous?.messageCount ?? 0) + messages.length,
+				userMessages: (previous?.userMessages ?? 0) + messages.filter((m) => m.role === "user").length,
+				assistantMessages: (previous?.assistantMessages ?? 0) + messages.filter((m) => m.role === "assistant").length,
+				toolCalls: (previous?.toolCalls ?? 0) + messages.flatMap((m) => m.role === "assistant" ? m.content.filter((c) => c.type === "toolCall") : []).length,
+				toolResults: (previous?.toolResults ?? 0) + messages.filter((m) => m.role === "toolResult").length
+			};
+			if (conversation === lane && statsCache === cached) statsCache = next;
 			return {
 				sessionId,
-				sessionFile: storage.sessionFile,
 				...contextUsage === void 0 ? {} : { contextUsage },
-				messageCount: messages.length,
-				totalMessages: messages.length,
-				userMessages: messages.filter((m) => m.role === "user").length,
-				assistantMessages: messages.filter((m) => m.role === "assistant").length,
-				toolCalls: messages.flatMap((m) => m.role === "assistant" ? m.content.filter((c) => c.type === "toolCall") : []).length,
-				toolResults: messages.filter((m) => m.role === "toolResult").length,
+				messageCount: next.messageCount,
+				totalMessages: next.messageCount,
+				userMessages: next.userMessages,
+				assistantMessages: next.assistantMessages,
+				toolCalls: next.toolCalls,
+				toolResults: next.toolResults,
 				tokens,
 				cost,
 				totalCost: cost,
@@ -1651,6 +1507,7 @@ async function createDirectHarnessRuntime(options) {
 		};
 		let disposePromise;
 		const dispose = () => disposePromise ??= (async () => {
+			for (const pending of toolBoundaryQueue.splice(0)) pending.reject(/* @__PURE__ */ new Error("Direct harness is disposed"));
 			const failures = [];
 			const attempt = async (cleanup) => {
 				try {
@@ -1661,14 +1518,15 @@ async function createDirectHarnessRuntime(options) {
 					return false;
 				}
 			};
-			await attempt(interrupt);
+			if (!attached) await attempt(interrupt);
 			disposed = true;
 			await attempt(() => watcher.stop());
 			await attempt(() => eventsSettled);
-			const harnessClosed = await attempt(() => harness.close(context));
-			const repositoryClosed = harnessClosed && await attempt(async () => storage.repository?.close(context));
-			await attempt(() => environment.cleanup(context));
-			if (harnessClosed && repositoryClosed) await attempt(async () => storage.historyLease?.release());
+			if (!attached) {
+				const harnessClosed = await attempt(() => harness.close(context));
+				await attempt(() => environment.cleanup(context));
+				if (harnessClosed) await attempt(() => storage.release(context));
+			}
 			resolveExited(failures.length ? 1 : 0);
 			if (failures.length) throw new AggregateError(failures, "Direct harness cleanup failed");
 		})();
@@ -1706,29 +1564,21 @@ async function createDirectHarnessRuntime(options) {
 			return entryId;
 		};
 		const removeQueued = async (id) => {
-			const item = (await readRecord()).queue.find((q) => q.id === id);
-			if (!item || item.explicitQueue !== true) return "not_found";
-			if (item.disposition === "consumed") return "already_consumed";
-			if (item.disposition === "removed") return "removed";
-			if (item.submissionId) {
-				const result = await harness.abortSubmission(item.submissionId, context, conversation.id);
-				if (result === "already_placed") return "in_flight";
-				if (result === "settled") return "already_consumed";
-			} else if (item.disposition !== "pending") return "in_flight";
-			const result = await changeRecord((r) => {
-				const q = r.queue.find((q) => q.id === id);
-				if (!q || q.explicitQueue !== true) return "not_found";
-				if (q.disposition === "consumed") return "already_consumed";
-				if (q.disposition === "removed") return "removed";
-				if (q.submissionId !== item.submissionId || item.submissionId === void 0 && q.disposition !== "pending") return "in_flight";
-				q.disposition = "removed";
-				q.text = "";
-				delete q.message;
-				delete q.images;
+			const held = await changeRecord((r) => {
+				if (handingOff.has(id)) return "in_flight";
+				const index = r.held.findIndex((q) => q.id === id && q.explicitQueue);
+				if (index === -1) return "not_held";
+				r.held.splice(index, 1);
 				return "removed";
 			});
+			if (held === "in_flight") return held;
+			if (held === "not_held") {
+				const accepted = await storage.storage.submissionByRequest(conversation.id, heldRequestId(id), context);
+				if (!accepted) return "not_found";
+				return accepted.status === "queued" ? "in_flight" : "already_consumed";
+			}
 			await publish();
-			return result;
+			return "removed";
 		};
 		const commitCheckpointMessage = async (registration, lane, message, ctx, scopeIsOpen = () => true, taskId) => {
 			const usable = () => registration.active && scopeIsOpen() && !disposed && !quarantined && !external && conversation.id === lane.id && !ctx.abortSignal?.aborted;
@@ -1753,8 +1603,9 @@ async function createDirectHarnessRuntime(options) {
 				}, ctx);
 			});
 		};
-		const appendMessage = (message) => appendEntry({
+		const appendMessage = (message, requestId) => appendEntry({
 			type: "write",
+			...requestId === void 0 ? {} : { requestId },
 			entry: {
 				kind: "po.entry",
 				data: json({
@@ -1765,9 +1616,11 @@ async function createDirectHarnessRuntime(options) {
 				model: convertToLlm([message])
 			}
 		});
+		const mainOnly = () => {
+			if (attached) throw new Error("Session state belongs to the main lane.");
+		};
 		return {
 			sessionId,
-			sessionFile: storage.sessionFile,
 			laneName,
 			harnessId: options.harnessId ?? `${sessionId}:${laneName}`,
 			session: harness,
@@ -1795,15 +1648,33 @@ async function createDirectHarnessRuntime(options) {
 				}));
 			},
 			readEntries,
+			async readEntriesFrom(seq) {
+				const lane = conversation;
+				const minEntryId = nativeId(String(seq));
+				const entries = await projectDurableConversationEntries(lane, context, minEntryId);
+				if (entries.length > 0 && minEntryId > 0) {
+					const previous = await lane.entries({ maxEntryId: minEntryId - 1 }, 1, void 0, context);
+					const parentId = previous.items[0] === void 0 ? null : String(previous.items[0].id);
+					for (const entry of entries) {
+						if (entry.seq !== entries[0].seq) break;
+						entry.parentId = parentId;
+					}
+				}
+				return {
+					entries,
+					leafId: entries.at(-1)?.id ?? null
+				};
+			},
+			scanEntries: (query, limit, cursor, scanContext) => conversation.entries(query, limit, cursor, scanContext),
+			readIdentities: (readContext) => harness.snapshot(IdentityHistoryDoc, conversation.id, readContext),
 			async getContextMessages() {
 				const assertReadable = () => {
 					if (disposed || quarantined) throw new Error("Direct harness context is unavailable", { cause: failure });
 				};
 				assertReadable();
-				const lane = conversation;
-				const view = await lane.context(context);
+				const view = await conversation.context(context);
 				assertReadable();
-				const messages = await restoreCustomContextMessages(view.messages, context, view, lane.id);
+				const messages = restoreCustomContextMessages(view.messages, view);
 				assertReadable();
 				return structuredClone(messages);
 			},
@@ -1816,12 +1687,10 @@ async function createDirectHarnessRuntime(options) {
 				const metadata = await harness.snapshot(SessionMetadataDoc, context);
 				const stats = await getSessionStats();
 				const inbox = await harness.snapshot(InboxDoc, conversation.id, context);
-				const retained = (await readRecord()).queue;
-				const retainedSubmissions = new Set(retained.map((item) => item.submissionId));
-				const nativePending = inbox?.items.filter((item) => item.mode !== "write" && !retainedSubmissions.has(item.id)).length ?? 0;
+				const held = (await readRecord()).held.length;
+				const nativePending = inbox?.items.filter((item) => item.mode !== "write").length ?? 0;
 				return json({
 					sessionId,
-					sessionFile: storage.sessionFile,
 					sessionName: metadata?.name,
 					model: agent.model ? {
 						provider: agent.model.provider,
@@ -1841,13 +1710,13 @@ async function createDirectHarnessRuntime(options) {
 					followUpMode: settings.followUpMode ?? "one-at-a-time",
 					autoCompactionEnabled: settings.compaction?.enabled ?? true,
 					messageCount: stats.messageCount,
-					pendingMessageCount: retained.filter((item) => item.disposition !== "consumed" && item.disposition !== "removed").length + nativePending + nextTurnMessages.length + deferredInternalCount
+					pendingMessageCount: held + nativePending + nextTurnMessages.length + deferredInternalCount
 				});
 			},
 			enqueueAutomatic: async (value, images) => {
 				assertUnlocked();
-				const result = await enqueue(value, images, "nextRun", "automatic", true);
-				drain().catch((error) => emit({
+				const result = await enqueue(value, images, "nextRun", true);
+				dispatch().catch((error) => emit({
 					type: "error",
 					error: String(error)
 				}));
@@ -1855,26 +1724,43 @@ async function createDirectHarnessRuntime(options) {
 			},
 			removeQueued,
 			async promoteQueued(id, operationId) {
-				return (await submitUserPrompt("", void 0, {
-					id,
-					operationId
-				}, "steer")).queueOutcome ?? "promoted";
+				guardUserAdmission();
+				assertUnlocked();
+				if (handingOff.has(id)) return "in_flight";
+				const result = await admitUser(() => writable(async () => {
+					try {
+						return await harness.commit((tx) => admitSelected(tx, conversation.id, {
+							id,
+							operationId
+						}, settings, false), context);
+					} catch (error) {
+						if (await storage.storage.submissionByRequest(conversation.id, heldRequestId(id), context)) return "promoted";
+						throw error;
+					}
+				}));
+				if (typeof result === "string" && result !== "promoted") {
+					await publish();
+					return result;
+				}
+				harness.resume();
+				await publish();
+				return "promoted";
 			},
 			async resumeQueue() {
 				guardUserAdmission();
 				await changeRecord((r) => {
 					r.paused = false;
 					delete r.abortOperationId;
-					delete r.abortTaskId;
 				});
 				await publish();
-				drain().catch((error) => emit({
+				dispatch().catch((error) => emit({
 					type: "error",
 					error: String(error)
 				}));
 			},
 			recover,
 			async setFastMode(enabled) {
+				mainOnly();
 				if (enabled) {
 					const selected = (await conversation.agent(context)).model;
 					const model = selected ? models.getModel(selected.provider, selected.modelId) : void 0;
@@ -1899,6 +1785,7 @@ async function createDirectHarnessRuntime(options) {
 			},
 			agentLocked: () => agentLocked,
 			async setAgentLock(locked) {
+				mainOnly();
 				if (typeof locked !== "boolean") throw new Error("Agent lock must be a boolean.");
 				await writable(() => harness.commit(async (tx) => {
 					(await tx.doc(AgentLockDoc)).locked = locked;
@@ -1954,6 +1841,7 @@ async function createDirectHarnessRuntime(options) {
 				};
 			},
 			navigateTree: (targetId, navigationOptions) => runExternalOperation(async () => {
+				mainOnly();
 				try {
 					const expected = conversation.id;
 					if (targetId !== null && !await storage.storage.entry(conversation.id, nativeId(targetId), context)) throw new Error("Navigation target is not in the selected conversation");
@@ -2046,6 +1934,7 @@ async function createDirectHarnessRuntime(options) {
 					} } : void 0);
 					const agent = await conversation.agent(context);
 					conversation = await harness.conversation(id, context);
+					statsCache = void 0;
 					if (targetId === null) await conversation.configure({
 						model: agent.model,
 						thinkingLevel: agent.thinkingLevel,
@@ -2059,7 +1948,7 @@ async function createDirectHarnessRuntime(options) {
 						(await tx.doc(LabelsDoc)).labels[targetId] = navigationOptions.label;
 					}, context);
 					for (const entry of result.entries) if (entry.type === "branch_summary") await deliver({
-						type: "entry_added",
+						type: "entry_appended",
 						entry
 					}, context);
 					const event = {
@@ -2091,7 +1980,7 @@ async function createDirectHarnessRuntime(options) {
 				}
 			}),
 			async clearQueue() {
-				const selected = (await readRecord()).queue.filter((item) => item.explicitQueue === true && item.disposition !== "consumed" && item.disposition !== "removed");
+				const selected = (await readLifecycle()).queue;
 				for (const item of selected) await removeQueued(item.id);
 				await publish();
 				return {
@@ -2100,6 +1989,7 @@ async function createDirectHarnessRuntime(options) {
 				};
 			},
 			async setName(name) {
+				mainOnly();
 				await writable(() => harness.commit(async (tx) => {
 					(await tx.doc(SessionMetadataDoc)).name = name;
 				}, context));
@@ -2108,6 +1998,16 @@ async function createDirectHarnessRuntime(options) {
 					name
 				});
 			},
+			async setGroups(groups) {
+				mainOnly();
+				await writable(() => harness.commit(async (tx) => {
+					(await tx.doc(SessionMetadataDoc)).groups = [...groups];
+				}, context));
+				emit({
+					type: SESSION_GROUPS_CHANGED_FRAME,
+					groups: [...groups]
+				});
+			},
 			getSessionStats,
 			async replaceTools(replacement) {
 				tools = replacement;
@@ -2123,23 +2023,35 @@ async function createDirectHarnessRuntime(options) {
 				return resources;
 			},
 			runExternalOperation,
+			runAtToolBoundary,
 			appendCustomEntry: async (customType, data) => {
 				const lane = conversation;
-				return String((await writable(() => lane.commit((tx) => tx.appendEntry(lane.id, {
-					kind: customType,
-					...data === void 0 ? {} : { data: json(data) },
-					...options.entryProjectors?.[customType] ? { model: convertToLlm(options.entryProjectors[customType]({
-						type: "custom",
-						id: "",
-						parentId: null,
-						timestamp: Date.now(),
-						seq: 0,
-						customType,
-						...data === void 0 ? {} : { data: json(data) }
-					})) } : {}
-				}), context))).id);
+				return String((await writable(() => lane.commit(async (tx) => {
+					const entry = await tx.appendEntry(lane.id, {
+						kind: customType,
+						...data === void 0 ? {} : { data: json(data) },
+						...options.entryProjectors?.[customType] ? { model: convertToLlm(options.entryProjectors[customType]({
+							type: "custom",
+							id: "",
+							parentId: null,
+							timestamp: Date.now(),
+							seq: 0,
+							customType,
+							...data === void 0 ? {} : { data: json(data) }
+						})) } : {}
+					});
+					if (customType === "po-profile-identity") {
+						const history = await tx.doc(IdentityHistoryDoc, lane.id);
+						const identity = json(data ?? {});
+						if (JSON.stringify(history.items.at(-1)?.data) !== JSON.stringify(identity)) history.items.push({
+							seq: Number(entry.id),
+							data: identity
+						});
+					}
+					return entry;
+				}, context))).id);
 			},
-			appendMessage,
+			appendMessage: (message) => appendMessage(message),
 			registerCheckpointBoundary(callback) {
 				const registration = {
 					active: true,
@@ -2154,11 +2066,14 @@ async function createDirectHarnessRuntime(options) {
 					}
 				};
 			},
-			setLabel: (targetId, label) => writable(() => harness.commit(async (tx) => {
-				const labels = (await tx.doc(LabelsDoc)).labels;
-				if (label === void 0) delete labels[targetId];
-				else labels[targetId] = label;
-			}, context)),
+			setLabel: (targetId, label) => writable(() => {
+				mainOnly();
+				return harness.commit(async (tx) => {
+					const labels = (await tx.doc(LabelsDoc)).labels;
+					if (label === void 0) delete labels[targetId];
+					else labels[targetId] = label;
+				}, context);
+			}),
 			recordUsage,
 			submitPrompt: admit,
 			submitUserPrompt,
@@ -2182,7 +2097,11 @@ async function createDirectHarnessRuntime(options) {
 					timestamp: Date.now()
 				} : message;
 				if (agentLocked) {
-					await appendMessage(preserved);
+					try {
+						await appendMessage(preserved, requestId);
+					} catch (error) {
+						if (!await storage.storage.submissionByRequest(conversation.id, requestId, context)) throw error;
+					}
 					return { settled: Promise.resolve() };
 				}
 				const deliveryRecord = {
@@ -2192,68 +2111,44 @@ async function createDirectHarnessRuntime(options) {
 				if (userAdmission) {
 					deferredInternalCount++;
 					admittingInternal.add(requestId);
-					try {
-						await changeRecord((r) => {
-							(r.internalDeliveries ??= {})[requestId] = deliveryRecord;
-						});
-					} catch (error) {
+					internalDeliveries.set(requestId, deliveryRecord);
+					const admission = userAdmissionSettled.then(() => {
 						deferredInternalCount--;
 						admittingInternal.delete(requestId);
-						throw error;
-					}
-					const settled = userAdmissionSettled.then(async () => {
-						deferredInternalCount--;
-						admittingInternal.delete(requestId);
-						await (await submitInternalMessage(preserved, delivery, requestId)).settled;
+						return submitInternalMessage(preserved, delivery, requestId);
 					});
+					const settled = admission.then((submission) => submission.settled);
 					settled.catch((error) => emit({
 						type: "error",
 						code: "internal_message",
 						error: String(error)
 					}));
-					return { settled };
+					const admitted = admission.then((submission) => submission.admitted);
+					admitted.catch(() => void 0);
+					return {
+						settled,
+						admitted
+					};
 				}
 				if (external) throw new Error("An operation is already running");
 				const content = typeof message === "string" ? message : message.content;
-				const submit = async (draft) => {
-					try {
-						return await writable(() => conversation.submit(draft, context));
-					} catch (error) {
-						const accepted = await storage.storage.submissionByRequest(conversation.id, draft.requestId, context);
-						const submission = accepted && await harness.submission(accepted.id, context);
-						if (!submission) throw error;
-						return submission;
-					}
-				};
 				admittingInternal.add(requestId);
-				let envelope;
 				let submission;
 				try {
-					await changeRecord((r) => {
-						(r.internalDeliveries ??= {})[requestId] = deliveryRecord;
-					});
-					envelope = typeof message !== "string" && message.role === "custom" ? await submit({
-						type: "write",
-						requestId: `${requestId}:message`,
-						entry: {
+					internalDeliveries.set(requestId, deliveryRecord);
+					submission = await submitInput({
+						type: "input",
+						content,
+						whenBusy: delivery,
+						requestId,
+						...preserved.role === "custom" ? { entry: {
 							kind: "po.entry",
 							data: json({
 								type: "message",
-								message,
-								timestamp: message.timestamp,
-								inputRequestId: requestId
+								message: preserved,
+								timestamp: preserved.timestamp
 							})
-						}
-					}) : void 0;
-					submission = await submit({
-						type: "input",
-						content,
-						whenBusy: delivery,
-						requestId
-					});
-					await changeRecord((r) => {
-						const item = r.internalDeliveries?.[requestId];
-						if (item) item.submissionId = submission.id;
+						} } : {}
 					});
 				} finally {
 					admittingInternal.delete(requestId);
@@ -2278,7 +2173,6 @@ async function createDirectHarnessRuntime(options) {
 							await conversation.waitForIdle(context);
 							await reconcileInternal(requestId, deliveryRecord);
 						}
-						if (envelope && (await envelope.wait(context)).status !== "done") throw new Error("Internal message journal write failed");
 						if (status.status === "done" || status.entry !== void 0) {
 							if (!(await harness.snapshot(LiveDoc, deliveryRecord.conversationId, context))?.run?.inputs.some((id) => String(id) === String(submission.id))) pendingDelivery.resolve();
 							await delivered;
@@ -2298,13 +2192,14 @@ async function createDirectHarnessRuntime(options) {
 			},
 			steer: async (message, images) => {
 				if (typeof message !== "string" && message.role !== "user") throw new Error("Only user messages can steer an agent run");
-				await submitUserPrompt(message, images, void 0, "steer");
+				await submitUserPrompt(message, images, "steer");
 			},
 			followUp: (message, images) => queued(message, images, "followUp"),
 			nextRun: (message, images) => queued(message, images, "nextRun"),
 			abort,
 			interrupt,
 			async compact(instructions) {
+				if (attached) throw new Error("Manual compaction runs on the main lane only.");
 				guardUserAdmission();
 				if (external || compactionAdmission) throw new Error("An operation is already running");
 				compactionAdmission = true;
@@ -2318,17 +2213,20 @@ async function createDirectHarnessRuntime(options) {
 							keepRecentTokens: 0
 						}
 					};
+					manualCompaction.conversationId = String(conversation.id);
 					const task = await writable(() => conversation.compact(instructions, context));
 					const receipt = await harness.waitForTask(task, context);
 					await eventsSettled;
-					if ([
-						"failed",
-						"faulted",
-						"orphaned"
-					].includes(receipt.state.outcome.status)) throw new Error("Compaction failed");
+					const outcome = receipt.state.outcome;
+					if (outcome.status === "failed" || outcome.status === "faulted" || outcome.status === "orphaned") {
+						const reason = outcome.status === "orphaned" ? outcome.reason : outcome.error.message;
+						throw new Error(`Compaction failed: ${reason.trim() || outcome.status}`, { cause: outcome });
+					}
 				} finally {
 					settings = previous;
+					delete manualCompaction.conversationId;
 					compactionAdmission = false;
+					if (!await nativeExecution()) await flushToolBoundary();
 				}
 			},
 			async admitResume() {
@@ -2338,7 +2236,7 @@ async function createDirectHarnessRuntime(options) {
 				const settled = (async () => {
 					await conversation.waitForIdle(context);
 					await eventsSettled;
-					await drain();
+					await dispatch();
 				})();
 				settled.catch((error) => emit({
 					type: "error",
@@ -2358,15 +2256,35 @@ async function createDirectHarnessRuntime(options) {
 					await conversation.waitForIdle(context);
 					await eventsSettled;
 				}
-				drain().catch((error) => emit({
+				dispatch().catch((error) => emit({
 					type: "error",
 					error: String(error)
 				}));
 				return resumed;
 			},
+			openLane(laneConversation, laneOptions) {
+				if (attached) return Promise.reject(/* @__PURE__ */ new Error("Lanes open on the main lane."));
+				return createLaneRuntime({
+					...laneOptions,
+					platform,
+					models: sourceModels
+				}, {
+					harness,
+					storage,
+					registry,
+					conversation: laneConversation,
+					laneProviderSessions,
+					manualCompaction
+				});
+			},
+			closeLane(conversationId) {
+				if (attached) throw new Error("Lanes close on the main lane.");
+				registry.uninstall({ name: laneExtensionName(conversationId) });
+			},
 			dispose
 		};
 	} catch (error) {
+		if (attached) throw error;
 		const failures = [error];
 		try {
 			if (startupHarness) await startupHarness.close(context);
@@ -2375,8 +2293,7 @@ async function createDirectHarnessRuntime(options) {
 			failures.push(closeError);
 		}
 		if (failures.length === 1) try {
-			await storage.repository?.close(context);
-			await storage.historyLease?.release();
+			await storage.release(context);
 		} catch (closeError) {
 			failures.push(closeError);
 		}
@@ -2385,6 +2302,6 @@ async function createDirectHarnessRuntime(options) {
 	}
 }
 //#endregion
-export { AGENT_SETTLED_ENTRY_TYPE, createDirectHarnessRuntime, projectDurableConversationEntries, promptForAssistantText };
+export { createDirectHarnessRuntime, projectDurableConversationEntries, promptForAssistantText };
 
 //# sourceMappingURL=directHarnessRuntime.mjs.map