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

package/dist/src/systems/child/adapters/headlessChildSessionService.cjs

@@ -1,19 +1,12 @@
-const require_runtime = require("../../../../_virtual/_rolldown/runtime.cjs");
+const require_childSession = require("../types/childSession.cjs");
 const require_index = require("../services/childSession/index.cjs");
-const require_historyOwnership = require("../../../../historyOwnership.cjs");
-const require_sqliteSessionStorage = require("../../../../sqliteSessionStorage.cjs");
-const require_index$1 = require("../../../services/durableNavigation/index.cjs");
+const require_docs = require("../../../services/durableSession/docs.cjs");
+const require_index$1 = require("../../../services/transcriptPages/index.cjs");
+const require_index$2 = require("../../../services/durableSubagents/index.cjs");
 const require_directHarnessRuntime = require("../../../server/directHarnessRuntime.cjs");
-const require_nativeChildRuntimes = require("./nativeChildRuntimes.cjs");
-const require_nativeChildTranscriptReader = require("../../../server/nativeChildTranscriptReader.cjs");
-let node_crypto = require("node:crypto");
-let node_fs = require("node:fs");
-node_fs = require_runtime.__toESM(node_fs, 1);
-let node_path = require("node:path");
-node_path = require_runtime.__toESM(node_path, 1);
-let _earendil_works_pi_coding_agent = require("@earendil-works/pi-coding-agent");
-let _earendil_works_pi_durable = require("@earendil-works/pi-durable");
-let _earendil_works_chord_context = require("@earendil-works/chord/context");
+const require_piSessionRuntime = require("../../../pi/piSessionRuntime.cjs");
+const require_index$3 = require("../../../services/nativeChildTools/index.cjs");
+let dist_interop_chordContext_mjs = require("../../../../../dist/interop/chordContext.mjs");
 //#region src/systems/child/adapters/headlessChildSessionService.ts
 const THINKING_SUFFIX_PATTERN = /:(off|minimal|low|medium|high|xhigh|max)$/;
 /**
@@ -35,37 +28,103 @@ function parseChildModelReference(value) {
 		...suffix === null ? {} : { thinking: suffix[1] }
 	};
 }
-/** Resolve the provider set for one spawn, tolerating both a fixed array and a thunk. */
-function resolveChildProviders(providers) {
-	const resolved = typeof providers === "function" ? providers() : providers;
-	return resolved === void 0 || resolved.length === 0 ? void 0 : resolved;
+/**
+* An attributed input rides a displayed custom message whose details carry the
+* sender. The model reads its text once, as a user turn, exactly like a string.
+*/
+function childInputMessage(input) {
+	if (typeof input === "string") return input;
+	return {
+		role: "custom",
+		customType: require_childSession.PO_CHILD_INPUT_CUSTOM_TYPE,
+		content: input.text,
+		display: true,
+		details: { sender: input.sender },
+		timestamp: Date.now()
+	};
 }
-function sessionFile(runtime) {
-	return runtime.sessionFile;
+/** The runtime's own model and effort, read once and then followed through its config changes. */
+function observeChildConfig(runtime, listener) {
+	const changed = /* @__PURE__ */ new Set();
+	let open = true;
+	const off = runtime.onEvent((event) => {
+		if (event.type !== "config_update") return;
+		changed.add(event.property);
+		listener(event.property === "model" ? { model: `${event.value.provider}/${event.value.modelId}` } : { thinking: event.value });
+	});
+	runtime.readState().then((state) => {
+		const model = state.model;
+		if (!open) return;
+		listener({
+			...!changed.has("model") && typeof model?.provider === "string" && typeof model.id === "string" ? { model: `${model.provider}/${model.id}` } : {},
+			...!changed.has("thinkingLevel") && typeof state.thinkingLevel === "string" ? { thinking: state.thinkingLevel } : {}
+		});
+	}, () => void 0);
+	return () => {
+		open = false;
+		off();
+	};
 }
-function childRuntime(runtime, intercom, release) {
-	const file = sessionFile(runtime);
+/** Input, usage and observation methods of a child lane. */
+function childRuntimeMethods(runtime, inputRequestId, hold) {
 	return {
-		sessionId: runtime.sessionId,
-		...file === void 0 ? {} : { sessionFile: file },
-		...file === void 0 ? {} : { readTranscriptPage: (request, signal) => require_nativeChildTranscriptReader.readNativeChildTranscript(file, request, signal) },
-		prompt: (task) => require_directHarnessRuntime.promptForAssistantText(runtime, task, intercom?.hold?.bind(intercom)),
+		prompt: (task) => require_directHarnessRuntime.promptForAssistantText(runtime, childInputMessage(task), hold, inputRequestId),
 		async steer(message) {
-			await runtime.submitInternalMessage(message, "steer");
+			await runtime.submitInternalMessage(childInputMessage(message), "steer");
 		},
 		async followUp(message) {
-			await runtime.submitInternalMessage(message, "followUp");
-		},
-		onUsage(listener) {
-			return runtime.onEvent((event) => {
-				if (event.type !== "usage") return;
-				listener({
-					rowId: event.row.id,
-					cost: event.row.usage.cost.total
-				});
-			});
+			await runtime.submitInternalMessage(childInputMessage(message), "followUp");
 		},
 		abort: () => runtime.abort(),
+		onUsage: (listener) => runtime.onEvent((event) => {
+			if (event.type !== "usage") return;
+			listener({
+				rowId: event.row.id,
+				cost: event.row.usage.cost.total,
+				tokens: event.row.usage.totalTokens
+			});
+		}),
+		onConfig: (listener) => observeChildConfig(runtime, listener),
+		onToolStart: (listener) => runtime.onEvent((event) => {
+			if (event.type === "tool_execution_start") listener(event.toolCallId);
+		})
+	};
+}
+/** Pages of a child conversation through its parent's Harness, also after the child's lane closed. */
+function childTranscriptReader(harness, conversation, sessionId) {
+	return async (request, signal) => {
+		const context = signal ? (0, dist_interop_chordContext_mjs.withAbortSignal)(signal, dist_interop_chordContext_mjs.BACKGROUND_CONTEXT) : dist_interop_chordContext_mjs.BACKGROUND_CONTEXT;
+		return {
+			...await require_index$1.readTranscriptPage({
+				sessionId,
+				laneName: "main",
+				lane: require_index$1.durableTranscriptLane((query, limit, cursor, scanContext) => conversation.entries(query, limit, cursor, scanContext), (readContext) => harness.snapshot(require_docs.IdentityHistoryDoc, conversation.id, readContext))
+			}, request, 0, context),
+			revision: 0
+		};
+	};
+}
+/** Pages of a stored run's conversation, opened on first read: what a thread view reads once the run's lane is gone. */
+function storedTranscriptReader(harness, conversationId, sessionId) {
+	let opening;
+	return async (request, signal) => {
+		opening ??= harness.conversation(conversationId, dist_interop_chordContext_mjs.BACKGROUND_CONTEXT).then((conversation) => {
+			if (!conversation) throw new Error(`Child conversation ${conversationId} is unavailable.`);
+			return childTranscriptReader(harness, conversation, sessionId);
+		});
+		try {
+			return await (await opening)(request, signal);
+		} catch (error) {
+			opening = void 0;
+			throw error;
+		}
+	};
+}
+function childRuntime(runtime, inputRequestId, readPage, intercom, release) {
+	return {
+		sessionId: runtime.sessionId,
+		...readPage ? { readTranscriptPage: readPage } : {},
+		...childRuntimeMethods(runtime, inputRequestId, intercom?.hold?.bind(intercom)),
 		dispose: async () => {
 			try {
 				await release?.();
@@ -130,9 +189,96 @@ function bindChildHooks(request, hooks, readRuntime, signal) {
 		})()
 	};
 }
-async function installIntercom(runtime, intercom, tools) {
+function createPoChildSessionHookRegistry() {
+	const entries = /* @__PURE__ */ new Set();
+	return {
+		register(hooks) {
+			entries.add(hooks);
+			return { dispose: () => void entries.delete(hooks) };
+		},
+		list: () => [...entries]
+	};
+}
+/**
+* Chains child hooks into one provider. The first is the legacy single provider: its errors
+* propagate as before. Later hooks see the patched result, and their errors are reported and skipped,
+* so an observer can never break a child tool call.
+*/
+function composeChildSessionHooks(list, onError) {
+	const hooks = list.filter((entry) => entry !== void 0);
+	if (hooks.length <= 1) return hooks[0];
+	const report = (error) => onError?.(`Child session hook failed: ${error instanceof Error ? error.message : String(error)}`);
+	return { bind(scope) {
+		const bindings = [];
+		try {
+			for (const entry of hooks) bindings.push(entry.bind(scope));
+		} catch (error) {
+			Promise.allSettled(bindings.map((binding) => binding.dispose()));
+			throw error;
+		}
+		return {
+			async beforeTool(event, context) {
+				let args = event.args;
+				let changed = false;
+				for (const [index, binding] of bindings.entries()) {
+					let result;
+					try {
+						result = await binding.beforeTool({
+							...event,
+							args
+						}, context);
+					} catch (error) {
+						if (index === 0) throw error;
+						report(error);
+						continue;
+					}
+					if (result?.block) return result;
+					if (result?.args) {
+						args = result.args;
+						changed = true;
+					}
+				}
+				return changed ? { args } : void 0;
+			},
+			async afterTool(event, context) {
+				let current = event;
+				let patch;
+				for (const [index, binding] of bindings.entries()) {
+					let result;
+					try {
+						result = await binding.afterTool(current, context);
+					} catch (error) {
+						if (index === 0) throw error;
+						report(error);
+						continue;
+					}
+					if (!result) continue;
+					const terminate = patch?.terminate === true || result.terminate === true;
+					patch = {
+						...patch,
+						...result,
+						...terminate ? { terminate } : {}
+					};
+					current = {
+						...current,
+						...result.content === void 0 ? {} : { content: result.content },
+						...result.details === void 0 ? {} : { details: result.details },
+						...result.isError === void 0 ? {} : { isError: result.isError },
+						...result.usage === void 0 ? {} : { usage: result.usage }
+					};
+				}
+				return patch;
+			},
+			async dispose() {
+				const failure = (await Promise.allSettled(bindings.map((binding) => binding.dispose()))).find((result) => result.status === "rejected");
+				if (failure) throw failure.reason;
+			}
+		};
+	} };
+}
+async function installIntercom(runtime, intercom, tools, inputRequestId) {
 	if (!intercom) return;
-	const tool = intercom.bindRuntime(childRuntime(runtime));
+	const tool = intercom.bindRuntime(childRuntime(runtime, inputRequestId, void 0));
 	const adapted = {
 		name: tool.name,
 		description: tool.description,
@@ -155,15 +301,6 @@ async function installIntercom(runtime, intercom, tools) {
 function hasConfiguredValues(value) {
 	return value !== void 0 && value.length > 0;
 }
-const NATIVE_TOOL_FACTORIES = {
-	read: _earendil_works_pi_coding_agent.createReadTool,
-	bash: _earendil_works_pi_coding_agent.createBashTool,
-	edit: _earendil_works_pi_coding_agent.createEditTool,
-	write: _earendil_works_pi_coding_agent.createWriteTool,
-	grep: _earendil_works_pi_coding_agent.createGrepTool,
-	find: _earendil_works_pi_coding_agent.createFindTool,
-	ls: _earendil_works_pi_coding_agent.createLsTool
-};
 function adaptNativeTool(tool) {
 	const prompt = tool;
 	return {
@@ -190,7 +327,7 @@ function adaptNativeTool(tool) {
 		}
 	};
 }
-/** Validate and project native fields before a source fork can publish a child journal. */
+/** Validate and project native fields before the child conversation is created. */
 function composeDirectHarnessRequestOptions(request, resolveMcpTool, validateRequired = true) {
 	const unsupported = [
 		...hasConfiguredValues(request.extensions) ? ["extensions"] : [],
@@ -198,13 +335,13 @@ function composeDirectHarnessRequestOptions(request, resolveMcpTool, validateReq
 		...hasConfiguredValues(request.capabilityCeiling?.allowedExternalProfiles) ? ["allowedExternalProfiles"] : []
 	];
 	if (unsupported.length > 0) throw new Error(`Native child session configuration is unsupported by the direct harness: ${unsupported.join(", ")}`);
-	const requested = [...new Set(request.tools ?? Object.keys(NATIVE_TOOL_FACTORIES))];
+	const requested = [...new Set(request.tools ?? Object.keys(require_index$3.NATIVE_TOOL_FACTORIES))];
 	const excluded = new Set(request.excludeTools ?? []);
 	const ceiling = request.capabilityCeiling;
 	const allowed = ceiling?.allowedTools;
 	const isMcp = (name) => name === "mcp" || name === "mcp_use";
-	const mcpDenied = ceiling !== void 0 && ceiling.allowMcpTools !== true || allowed !== void 0 && allowed.every((name) => Object.hasOwn(NATIVE_TOOL_FACTORIES, name)) || [...excluded].some(isMcp);
-	const wantsMcp = !mcpDenied && (requested.some(isMcp) || hasConfiguredValues(request.mcpDirectTools) || requested.some((name) => !Object.hasOwn(NATIVE_TOOL_FACTORIES, name)));
+	const mcpDenied = ceiling !== void 0 && ceiling.allowMcpTools !== true || allowed !== void 0 && allowed.every((name) => Object.hasOwn(require_index$3.NATIVE_TOOL_FACTORIES, name)) || [...excluded].some(isMcp);
+	const wantsMcp = !mcpDenied && (requested.some(isMcp) || hasConfiguredValues(request.mcpDirectTools) || requested.some((name) => !Object.hasOwn(require_index$3.NATIVE_TOOL_FACTORIES, name)));
 	const provider = wantsMcp ? resolveMcpTool?.() : void 0;
 	const catalog = provider?.catalog;
 	const snapshot = catalog?.snapshot() ?? [];
@@ -217,16 +354,16 @@ function composeDirectHarnessRequestOptions(request, resolveMcpTool, validateReq
 		for (const tool of snapshot) if (!selectors.has(tool.name)) selected.delete(tool.name);
 		else if (request.tools === void 0) selected.add(tool.name);
 	}
-	const nativeNames = requested.filter((name) => Object.hasOwn(NATIVE_TOOL_FACTORIES, name) && !denied.has(name) && (grants === void 0 || grants.has(name)));
+	const nativeNames = requested.filter((name) => Object.hasOwn(require_index$3.NATIVE_TOOL_FACTORIES, name) && !denied.has(name) && (grants === void 0 || grants.has(name)));
 	const direct = mcpDenied ? [] : snapshot.filter((tool) => selected.has(tool.name) && !denied.has(tool.name) && (grants === void 0 || grants.has(tool.name)));
-	const unknown = requested.filter((name) => !Object.hasOwn(NATIVE_TOOL_FACTORIES, name) && !isMcp(name) && !snapshot.some((tool) => tool.name === name) && !denied.has(name) && (grants === void 0 || grants.has(name)));
+	const unknown = requested.filter((name) => !Object.hasOwn(require_index$3.NATIVE_TOOL_FACTORIES, name) && !isMcp(name) && !snapshot.some((tool) => tool.name === name) && !denied.has(name) && (grants === void 0 || grants.has(name)));
 	if (unknown.length > 0 && validateRequired) throw new Error(`Native child session requested unknown direct harness tools: ${unknown.join(", ")}`);
 	const names = [...nativeNames, ...direct.map((tool) => tool.name)];
 	const missing = (ceiling?.requiredTools ?? []).filter((name) => isMcp(name) ? direct.length === 0 : !names.includes(name));
 	if (validateRequired && missing.length > 0) throw new Error(`Native child session capability ceiling requires unavailable tools: ${missing.join(", ")}`);
 	if (validateRequired && wantsMcp && !catalog) throw new Error("Native child session MCP tools are unavailable. Enable MCP in the parent session.");
 	return {
-		tools: [...nativeNames.map((name) => adaptNativeTool(NATIVE_TOOL_FACTORIES[name](request.cwd))), ...direct.map((tool) => adaptNativeTool({
+		tools: [...nativeNames.map((name) => adaptNativeTool(require_index$3.NATIVE_TOOL_FACTORIES[name](request.cwd))), ...direct.map((tool) => adaptNativeTool({
 			...tool,
 			execute(toolCallId, parameters, signal, onUpdate) {
 				signal?.throwIfAborted();
@@ -241,10 +378,10 @@ function composeDirectHarnessRequestOptions(request, resolveMcpTool, validateReq
 /** Refresh borrowed declarations without replacing native tools or rebinding intercom. */
 function bindChildMcpCatalog(runtime, request, options, initialTools) {
 	if (request.capabilityCeiling !== void 0 && request.capabilityCeiling.allowMcpTools !== true) return () => void 0;
-	if (request.capabilityCeiling?.allowedTools?.every((name) => Object.hasOwn(NATIVE_TOOL_FACTORIES, name))) return () => void 0;
+	if (request.capabilityCeiling?.allowedTools?.every((name) => Object.hasOwn(require_index$3.NATIVE_TOOL_FACTORIES, name))) return () => void 0;
 	if (request.excludeTools?.some((name) => name === "mcp" || name === "mcp_use")) return () => void 0;
-	if (!request.tools?.some((name) => name === "mcp" || name === "mcp_use" || !Object.hasOwn(NATIVE_TOOL_FACTORIES, name)) && !request.mcpDirectTools?.length) return () => void 0;
-	const retained = initialTools.filter((tool, index) => Object.hasOwn(NATIVE_TOOL_FACTORIES, tool.name) || request.intercom !== void 0 && index === initialTools.length - 1);
+	if (!request.tools?.some((name) => name === "mcp" || name === "mcp_use" || !Object.hasOwn(require_index$3.NATIVE_TOOL_FACTORIES, name)) && !request.mcpDirectTools?.length) return () => void 0;
+	const retained = initialTools.filter((tool, index) => Object.hasOwn(require_index$3.NATIVE_TOOL_FACTORIES, tool.name) || request.intercom !== void 0 && index === initialTools.length - 1);
 	let disposed = false;
 	let provider;
 	let unsubscribeCatalog;
@@ -263,7 +400,7 @@ function bindChildMcpCatalog(runtime, request, options, initialTools) {
 		const snapshot = provider?.catalog?.snapshot() ?? [];
 		if (!changed && snapshot.length === previous.length && snapshot.every((tool, index) => tool === previous[index])) return;
 		previous = snapshot;
-		const direct = (composeDirectHarnessRequestOptions(request, options.mcpTool, false).tools ?? []).filter((tool) => !Object.hasOwn(NATIVE_TOOL_FACTORIES, tool.name));
+		const direct = (composeDirectHarnessRequestOptions(request, options.mcpTool, false).tools ?? []).filter((tool) => !Object.hasOwn(require_index$3.NATIVE_TOOL_FACTORIES, tool.name));
 		pending = pending.then(async () => {
 			if (!disposed) await runtime.replaceTools([...retained, ...direct]);
 		}).catch((error) => {
@@ -279,134 +416,97 @@ function bindChildMcpCatalog(runtime, request, options, initialTools) {
 		if (failure !== void 0) throw new Error("Child MCP catalog refresh failed.", { cause: failure });
 	};
 }
-async function forkChildJournal(sourcePath, branch, entryId, ownership, parentSessionId) {
-	const source = await require_sqliteSessionStorage.openReadOnlyDurableStorage(sourcePath);
-	const read = (0, _earendil_works_pi_durable.createSession)(source);
-	let destination;
-	const failures = [];
-	try {
-		const selected = (await read.snapshot(require_index$1.DurableNavigationDoc, _earendil_works_chord_context.BACKGROUND_CONTEXT))?.activeConversationId;
-		if (selected === null || selected === void 0) throw new Error("Child source has no active conversation");
-		if (branch !== ((await read.snapshot(require_sqliteSessionStorage.SessionMetadataDoc, _earendil_works_chord_context.BACKGROUND_CONTEXT))?.laneName ?? "main")) throw new Error("Child source lane does not exist");
-		const cutoff = entryId === void 0 ? void 0 : Number(entryId);
-		if (entryId !== void 0 && (!Number.isSafeInteger(cutoff) || !await source.entry(selected, cutoff, _earendil_works_chord_context.BACKGROUND_CONTEXT))) throw new Error("Child fork entry is not visible in its source conversation");
-		const records = [];
-		let cursor;
-		do {
-			const page = await source.scanEntries({
-				conversationId: selected,
-				...cutoff === void 0 ? {} : { maxEntryId: cutoff }
-			}, 256, cursor, _earendil_works_chord_context.BACKGROUND_CONTEXT);
-			records.push(...page.items);
-			cursor = page.next;
-		} while (cursor);
-		records.reverse();
-		const agent = cutoff === void 0 ? await read.snapshot(_earendil_works_pi_durable.AgentDoc, selected, _earendil_works_chord_context.BACKGROUND_CONTEXT) : await read.snapshotAsOf(_earendil_works_pi_durable.AgentDoc, selected, cutoff, _earendil_works_chord_context.BACKGROUND_CONTEXT);
-		destination = await require_sqliteSessionStorage.openSqliteSessionStorage({
-			sessionsRoot: node_path.default.dirname(node_path.default.dirname(node_path.default.resolve(sourcePath))),
-			sessionId: (0, node_crypto.randomUUID)(),
-			parentSessionId: parentSessionId ?? (await read.snapshot(require_sqliteSessionStorage.SessionIdentityDoc, _earendil_works_chord_context.BACKGROUND_CONTEXT))?.id,
-			historyOwnership: ownership
-		}, _earendil_works_chord_context.BACKGROUND_CONTEXT);
-		await destination.session.commit(async (tx) => {
-			const conversation = await tx.createConversation({ ownership: { kind: "ownerless" } });
-			if (agent) Object.assign(await tx.doc(_earendil_works_pi_durable.AgentDoc, conversation.id), agent);
-			(await tx.doc(require_sqliteSessionStorage.SessionMetadataDoc)).laneName = branch;
-			const ids = /* @__PURE__ */ new Map();
-			for (const entry of records) {
-				const { id: _id, conversationId: _conversation, byTaskId: _task, head, edits, ...draft } = entry;
-				const appended = await tx.appendEntry(conversation.id, {
-					...draft,
-					...head === void 0 ? {} : { head: head === entry.id ? "self" : ids.get(head) },
-					...edits === void 0 ? {} : { edits: edits.map((edit) => {
-						const target = ids.get(edit.target);
-						if (target === void 0) throw new Error("Invalid fork context edit");
-						return {
-							...edit,
-							target
-						};
-					}) }
-				});
-				ids.set(entry.id, appended.id);
-			}
-			(await tx.doc(require_index$1.DurableNavigationDoc)).activeConversationId = conversation.id;
-		}, _earendil_works_chord_context.BACKGROUND_CONTEXT);
-	} catch (error) {
-		failures.push(error);
-	}
-	try {
-		await read.close(_earendil_works_chord_context.BACKGROUND_CONTEXT);
-	} catch (error) {
-		failures.push(error);
-	}
-	if (destination) try {
-		await destination.session.close(_earendil_works_chord_context.BACKGROUND_CONTEXT);
-		await destination.historyLease.release();
-	} catch (error) {
-		failures.push(error);
-	}
-	if (failures.length === 1) throw failures[0];
-	if (failures.length > 1) throw new AggregateError(failures, "Child fork cleanup failed");
-	if (!destination) throw new Error("Child fork failed");
-	return destination.sessionFile;
+/** The request as stored for a re-attach: data only, without its live intercom, environment or source. */
+function storedRequest(request) {
+	const { intercom: _intercom, environment: _environment, source: _source, ...data } = request;
+	return JSON.parse(JSON.stringify(data));
 }
+/**
+* Children are task-owned conversations of the parent's Harness, each run as one more lane. A run's conversation,
+* anchor and request are stored, so after a restart the child resumes with the Harness and `restore` re-attaches it.
+*/
 function createHeadlessChildSessionService(options) {
-	const runtimeFactory = options.runtimeFactory ?? require_directHarnessRuntime.createDirectHarnessRuntime;
-	const ownership = options.historyOwnership ?? require_historyOwnership.createHistoryOwnership({ sourceFormat: "sqlite" });
-	return require_index.createDoomChildSessionService(async (request, signal) => {
+	const parent = options.runtime;
+	const context = dist_interop_chordContext_mjs.BACKGROUND_CONTEXT;
+	const states = /* @__PURE__ */ new Map();
+	const readers = /* @__PURE__ */ new Map();
+	let closed = false;
+	const storedReader = (runId, conversationId) => {
+		const reader = storedTranscriptReader(parent.harness, conversationId, runId);
+		readers.set(runId, reader);
+		return reader;
+	};
+	require_index$2.readSubagents(parent.harness, context).then((runs) => {
+		if (closed) return;
+		for (const [runId, run] of Object.entries(runs)) if (!readers.has(runId)) storedReader(runId, run.conversationId);
+	}, () => void 0);
+	const readerOf = async (runId) => {
+		const reader = readers.get(runId);
+		if (reader) return reader;
+		const run = (await require_index$2.readSubagents(parent.harness, context))[runId];
+		return run ? readers.get(runId) ?? storedReader(runId, run.conversationId) : void 0;
+	};
+	const report = async (runId, outcome) => {
+		const conversationId = await require_index$2.markSubagentReported(parent.harness, runId, context, outcome);
+		if (conversationId !== void 0) parent.closeLane(conversationId);
+	};
+	const service = require_index.createPoChildSessionService(async (request, signal) => {
 		signal?.throwIfAborted();
-		if (request.source.kind === "terminal-pi-fork") throw new Error("Headless child sessions do not support terminal Pi sources.");
-		const directRequestOptions = composeDirectHarnessRequestOptions(request, options.mcpTool);
-		const fastMode = await options.parentFastMode?.();
-		if (fastMode !== void 0 && typeof fastMode !== "boolean") throw new Error("Parent Fast mode must be a boolean.");
-		let sessionPath;
-		let sessionId;
-		if (request.source.kind === "v4-restore") {
-			sessionPath = node_path.default.resolve(request.source.sessionFile);
-			if (node_path.default.extname(sessionPath) !== ".sqlite") throw new Error("Server child restore requires SQLite; import JSONL offline first.");
-		} else if (request.source.kind === "v4-fork") sessionPath = await forkChildJournal(request.source.sessionFile, request.source.branch, request.source.entryId, ownership, request.parentSessionId || options.parentSessionId);
-		else sessionId = (0, node_crypto.randomUUID)();
+		const existing = (await require_index$2.readSubagents(parent.harness, context))[request.runId];
+		if (existing?.reported) throw new Error(`Child run '${request.runId}' has already finished.`);
+		const restoring = existing !== void 0;
+		const directRequestOptions = composeDirectHarnessRequestOptions(request, options.mcpTool, !restoring);
 		const requestedModel = parseChildModelReference(request.model);
-		const model = requestedModel?.model ?? options.defaultModel?.();
 		const thinking = request.thinking ?? requestedModel?.thinking;
-		const providers = resolveChildProviders(options.providers);
-		const runtimeOptions = {
-			storage: "sqlite",
-			...request.source.kind === "v4-fork" ? { lane: request.source.branch } : {},
-			cwd: request.cwd || options.cwd,
-			...sessionId === void 0 ? {} : { sessionId },
-			parentSessionId: request.parentSessionId || options.parentSessionId,
-			...sessionPath === void 0 ? {} : { sessionPath },
-			...options.sessionsRoot === void 0 ? {} : { sessionsRoot: options.sessionsRoot },
-			...options.models === void 0 ? {} : { models: options.models },
-			...providers === void 0 ? {} : { providers },
-			...model === void 0 ? {} : { model },
-			...thinking === void 0 ? {} : { thinkingLevel: thinking },
-			...directRequestOptions,
-			...fastMode === void 0 ? {} : { initialFastMode: fastMode },
-			historyOwnership: ownership
-		};
+		let forkAt;
+		if (!restoring && request.source.kind === "fork") {
+			const entryId = request.source.entryId ?? (await parent.readEntries()).leafId ?? void 0;
+			const durableId = entryId === void 0 ? NaN : Number(String(entryId).split(":", 1)[0]);
+			if (!Number.isSafeInteger(durableId)) throw new Error("The parent session has no history to fork.");
+			forkAt = durableId;
+		}
+		const { conversation, stored } = existing ? {
+			conversation: await parent.harness.conversation(existing.conversationId, context),
+			stored: existing
+		} : await require_index$2.createSubagentConversation(parent.harness, parent.lane, {
+			runId: request.runId,
+			request: storedRequest(request),
+			...forkAt === void 0 ? {} : { forkAt }
+		}, context);
+		if (!conversation) throw new Error(`Child run '${request.runId}' has no conversation.`);
 		let runtime;
 		let hooks;
+		const boundHooks = () => hooks ??= bindChildHooks(request, options.hooks?.(), () => runtime, signal);
 		try {
-			hooks = bindChildHooks(request, options.hooks?.(), () => runtime, signal);
-			if (hooks.binding) {
-				runtimeOptions.beforeTool = hooks.binding.beforeTool;
-				runtimeOptions.afterTool = hooks.binding.afterTool;
-			}
-			runtime = await runtimeFactory(runtimeOptions);
-			if (requestedModel && model) await runtime.setModel(model);
-			if (thinking !== void 0) await runtime.setThinkingLevel(thinking);
-			await installIntercom(runtime, request.intercom, runtimeOptions.tools ?? []);
-			const releaseMcp = bindChildMcpCatalog(runtime, request, options, runtimeOptions.tools ?? []);
-			const file = sessionFile(runtime);
-			const releaseNative = file ? require_nativeChildRuntimes.registerNativeChild(file, runtime) : void 0;
-			return childRuntime(runtime, request.intercom, async () => {
+			if (!restoring) boundHooks();
+			const laneOptions = {
+				sessionId: request.runId,
+				cwd: request.cwd || options.cwd,
+				...requestedModel ? { model: requestedModel.model } : {},
+				...thinking === void 0 ? {} : { thinkingLevel: thinking },
+				...directRequestOptions,
+				beforeTool: (event, toolContext) => boundHooks().binding?.beforeTool(event, toolContext),
+				afterTool: (event, toolContext) => boundHooks().binding?.afterTool(event, toolContext)
+			};
+			runtime = await parent.openLane(conversation, laneOptions);
+			await installIntercom(runtime, request.intercom, laneOptions.tools ?? [], stored.inputRequestId);
+			const releaseMcp = bindChildMcpCatalog(runtime, request, options, laneOptions.tools ?? []);
+			const state = require_piSessionRuntime.createAgentSessionRuntime({
+				runtime,
+				sessionId: runtime.sessionId,
+				sessionName: runtime.sessionId,
+				cwd: ""
+			});
+			states.set(request.runId, state);
+			const readPage = childTranscriptReader(parent.harness, conversation, runtime.sessionId);
+			readers.set(request.runId, readPage);
+			return childRuntime(runtime, stored.inputRequestId, readPage, request.intercom, async () => {
 				try {
 					releaseMcp();
 				} finally {
 					try {
-						releaseNative?.();
+						if (states.get(request.runId) === state) states.delete(request.runId);
+						await state.dispose();
 					} finally {
 						await hooks?.dispose();
 					}
@@ -414,38 +514,73 @@ function createHeadlessChildSessionService(options) {
 			});
 		} catch (error) {
 			const failures = [error];
-			try {
-				await hooks?.dispose();
-			} catch (cleanupError) {
-				failures.push(cleanupError);
-			}
-			let closed = false;
-			try {
-				if (runtime) {
-					await runtime.dispose();
-					closed = true;
-				}
-			} catch (cleanupError) {
-				failures.push(cleanupError);
-			}
-			try {
-				request.intercom?.dispose?.();
-			} catch (cleanupError) {
-				failures.push(cleanupError);
-			}
-			if (closed && sessionPath !== void 0 && request.source.kind === "v4-fork") try {
-				for (const suffix of [
-					"",
-					"-wal",
-					"-shm"
-				]) node_fs.default.rmSync(sessionPath + suffix, { force: true });
+			for (const cleanup of [
+				() => hooks?.dispose(),
+				() => runtime?.dispose(),
+				() => request.intercom?.dispose?.(),
+				() => restoring ? void 0 : report(request.runId, { state: "failed" })
+			]) try {
+				await cleanup();
 			} catch (cleanupError) {
 				failures.push(cleanupError);
 			}
 			if (failures.length > 1) throw new AggregateError(failures, "Headless child startup cleanup failed");
 			throw error;
 		}
-	}, { now: options.now ?? Date.now });
+	}, {
+		now: options.now ?? Date.now,
+		store: {
+			async stored() {
+				const runs = [];
+				for (const run of Object.values(await require_index$2.readSubagents(parent.harness, context))) {
+					if (run.reported || !run.request) continue;
+					const receipt = await parent.harness.commit((tx) => tx.submissionByRequest(run.conversationId, run.inputRequestId), context);
+					runs.push({
+						request: run.request,
+						settled: receipt?.status === "done" || receipt?.status === "unanswered"
+					});
+				}
+				return runs;
+			},
+			markReported: report
+		}
+	});
+	return {
+		...service,
+		async readTranscriptPage(runId, request, signal) {
+			if (closed) throw new Error("The Po child-session service is closed.");
+			signal?.throwIfAborted();
+			const reader = await readerOf(runId);
+			if (!reader) throw new Error(`Child run '${runId}' has no readable transcript.`);
+			const page = await reader(request, signal);
+			signal?.throwIfAborted();
+			return page;
+		},
+		async reported(runId) {
+			const run = (await require_index$2.readSubagents(parent.harness, context))[runId];
+			if (!run?.reported) return void 0;
+			return {
+				...run.agent === void 0 ? {} : { agent: run.agent },
+				...run.task === void 0 ? {} : { task: run.task },
+				...run.state === void 0 ? {} : { state: run.state }
+			};
+		},
+		thread(runId) {
+			const reader = readers.get(runId);
+			if (!reader) return void 0;
+			const state = states.get(runId)?.state;
+			return {
+				...state ? { state } : {},
+				readTranscriptPage: reader
+			};
+		},
+		async close() {
+			closed = true;
+			await service.close();
+			states.clear();
+			readers.clear();
+		}
+	};
 }
 function createHeadlessChildSessionServiceProvider(options) {
 	const service = createHeadlessChildSessionService(options);
@@ -457,10 +592,12 @@ function createHeadlessChildSessionServiceProvider(options) {
 //#endregion
 exports.bindChildHooks = bindChildHooks;
 exports.bindChildMcpCatalog = bindChildMcpCatalog;
+exports.childInputMessage = childInputMessage;
+exports.composeChildSessionHooks = composeChildSessionHooks;
 exports.composeDirectHarnessRequestOptions = composeDirectHarnessRequestOptions;
 exports.createHeadlessChildSessionService = createHeadlessChildSessionService;
 exports.createHeadlessChildSessionServiceProvider = createHeadlessChildSessionServiceProvider;
+exports.createPoChildSessionHookRegistry = createPoChildSessionHookRegistry;
 exports.parseChildModelReference = parseChildModelReference;
-exports.resolveChildProviders = resolveChildProviders;
 
 //# sourceMappingURL=headlessChildSessionService.cjs.map