@lamplitisles/dsh-nanocodex 0.1.0-beta.0

package/dist/index.js

@@ -0,0 +1,3405 @@
+import { createHash, randomUUID } from "node:crypto";
+import { CompactionEngine, CompactionId, ManualCompactionError, compactCheckpointSource, isCompactCheckpointSource, toolPairingBalancedAfter, toolPairingBalancedBefore } from "@deepseek-ai/dsh-compaction";
+import { LlmAdapter, ReasoningEffortId, ToolCallId, createAssistantMessage, createToolResultMessage, createUserMessage } from "@deepseek-ai/dsh-llm";
+import { SessionPreparation, canonicalHeader, headerEquals } from "@deepseek-ai/dsh-session";
+import { isDeepStrictEqual } from "node:util";
+import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
+import { z } from "zod";
+import { joinContextSections, renderContextSections, renderPrompt } from "@deepseek-ai/dsh-system-prompt";
+import { Agent, Transport, createQuickJsEvaluator } from "../vendor/nanocodex/node/index.mjs";
+import { newQuickJSAsyncWASMModuleFromVariant } from "quickjs-emscripten-core";
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import z$1 from "@deepseek-ai/schemastery";
+import { createScope, scopeOf, scopeTarget } from "@deepseek-ai/dsh-scope";
+import { admitPromptContent } from "@deepseek-ai/dsh-attachment";
+import { Inbox, agentEvents, assembleContextFor, emitAgentEvent } from "@deepseek-ai/dsh-agent";
+import { apply as apply$1 } from "@deepseek-ai/dsh-command-compact";
+import { FsError } from "@deepseek-ai/dsh-fs";
+import "@deepseek-ai/dsh-tools";
+//#region src/constants.ts
+const INTERRUPTED_TOOL_OUTPUT = "Tool execution was interrupted before a complete result was recorded. It may have had side effects; inspect the current state before retrying.";
+const PLUGIN_NAME = "dsh-nanocodex";
+const APPLY_PATCH_NAME = "apply_patch";
+const APPLY_PATCH_DESCRIPTION = "Apply a raw Codex patch to text files in the active workspace. Call apply_patch(input: string) with a complete Add File/Update File patch. Supports Add File and Update File with contextual hunks; Delete File and Move to are not supported.";
+const APPLY_PATCH_GRAMMAR = String.raw`start: begin_patch hunk+ end_patch
+begin_patch: "*** Begin Patch" LF
+end_patch: "*** End Patch" LF?
+hunk: add_hunk | update_hunk
+add_hunk: "*** Add File: " filename LF add_line+
+update_hunk: "*** Update File: " filename LF change+
+filename: /(.+)/
+add_line: "+" /(.*)/ LF
+change: (change_context | change_line)+ eof_line?
+change_context: ("@@" | "@@ " /(.+)/) LF
+change_line: ("+" | "-" | " ") /(.*)/ LF
+eof_line: "*** End of File" LF
+%import common.LF`;
+const DEFAULT_MAX_PATCH_CHARS = 4e6;
+const DEFAULT_MAX_PATCH_FILES = 64;
+const DEFAULT_MAX_PATCH_FILE_BYTES = 4e6;
+const MODEL_CONTEXT_WINDOW = 2e5;
+const SUPPORTED_MODELS = [
+	"gpt-5.6-sol",
+	"gpt-5.6-terra",
+	"gpt-5.6-luna",
+	"gpt-6-astra"
+];
+function isSupportedModel(value) {
+	return value !== void 0 && SUPPORTED_MODELS.includes(value);
+}
+function isSupportedRoute(provider, api) {
+	return (provider === "openai" || provider === "openai-codex-responses") && (api === "openai-responses" || api === "openai");
+}
+//#endregion
+//#region src/history.ts
+function imageDataUrl(ref, bytes) {
+	return `data:${ref.mediaType};base64,${Buffer.from(bytes).toString("base64")}`;
+}
+async function imageItem(ctx, ref, signal) {
+	const stored = await ctx.attachments.readImage(ref, signal);
+	return {
+		type: "input_image",
+		image_url: imageDataUrl(stored.ref, stored.data),
+		detail: "auto"
+	};
+}
+function outputText(block) {
+	if (block.type !== "text") throw new Error(`Nanocodex cannot hydrate assistant content block ${JSON.stringify(block.type)}`);
+	return {
+		type: "output_text",
+		text: block.text
+	};
+}
+function inputText(block) {
+	if (block.type !== "text") throw new Error(`Nanocodex cannot hydrate user content block ${JSON.stringify(block.type)}`);
+	return {
+		type: "input_text",
+		text: block.text
+	};
+}
+async function toolOutput(ctx, blocks, signal) {
+	if (blocks.length === 1 && blocks[0]?.type === "text") return blocks[0].text;
+	const output = [];
+	for (const block of blocks) {
+		if (block.type !== "text") {
+			if (block.type === "image") {
+				output.push(await imageItem(ctx, block.attachment, signal));
+				continue;
+			}
+			throw new Error(`Nanocodex cannot hydrate tool-result content block ${JSON.stringify(block.type)}`);
+		}
+		output.push({
+			type: "input_text",
+			text: block.text
+		});
+	}
+	return output;
+}
+function textOfCheckpoint(message) {
+	return message.content.map((block) => {
+		if (block.type !== "text") throw new Error(`Nanocodex cannot hydrate compaction checkpoint block ${JSON.stringify(block.type)}`);
+		return block.text;
+	}).join("\n");
+}
+/** Pi Responses IDs store call_id|item_id; only the call part pairs results. */
+function historyToolCallId(value) {
+	return value.split("|", 1)[0].replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64).replace(/_+$/u, "");
+}
+function rawCustomInput(name, argumentsText) {
+	const key = name === "apply_patch" ? "patch" : "code";
+	let value;
+	try {
+		value = JSON.parse(argumentsText);
+	} catch (error) {
+		throw new Error(`Nanocodex cannot hydrate an invalid ${name} call`, { cause: error });
+	}
+	if (value === null || typeof value !== "object" || Array.isArray(value) || typeof value[key] !== "string" || Object.keys(value).length !== 1) throw new Error(`Nanocodex cannot hydrate ${name} without canonical {${key}} arguments`);
+	return value[key];
+}
+function validateToolPairs(messages) {
+	const toolNames = /* @__PURE__ */ new Map();
+	for (const message of messages) {
+		if (message.role !== "assistant") continue;
+		for (const block of message.content) {
+			if (block.type !== "tool-call") continue;
+			const id = historyToolCallId(block.id);
+			if (toolNames.has(id)) throw new Error(`Nanocodex cannot hydrate duplicate tool call ${JSON.stringify(id)}`);
+			toolNames.set(id, block.name);
+		}
+	}
+	const seenCalls = /* @__PURE__ */ new Set();
+	const resultIds = /* @__PURE__ */ new Set();
+	for (const message of messages) for (const block of message.content) {
+		if (message.role === "assistant" && block.type === "tool-call") {
+			seenCalls.add(historyToolCallId(block.id));
+			continue;
+		}
+		if (block.type !== "tool-result") continue;
+		const id = historyToolCallId(block.toolCallId);
+		const name = toolNames.get(id);
+		if (name === void 0) throw new Error(`Nanocodex cannot hydrate a tool result for foreign call ${JSON.stringify(id)}`);
+		if (name !== "apply_patch" && name !== "exec") continue;
+		if (!seenCalls.has(id)) throw new Error(`Nanocodex cannot hydrate ${name} output before call ${JSON.stringify(id)}`);
+		if (resultIds.has(id)) throw new Error(`Nanocodex cannot hydrate duplicate ${name} output ${JSON.stringify(id)}`);
+		resultIds.add(id);
+	}
+	for (const [id, name] of toolNames) if ((name === "apply_patch" || name === "exec") && !resultIds.has(id)) throw new Error(`Nanocodex cannot hydrate ${name} call without a result ${JSON.stringify(id)}`);
+	return toolNames;
+}
+/**
+* Convert the authoritative active DSH surface to Nanocodex's typed history.
+* Tool calls are represented as history items only; no handler is invoked while
+* hydrating a session.
+*/
+async function buildHistoryProjection(messages, ctx, signal) {
+	const history = [];
+	const items = [];
+	let continuitySummary;
+	const toolNames = validateToolPairs(messages);
+	const push = (message, item) => {
+		history.push(item);
+		items.push({
+			message,
+			item
+		});
+	};
+	for (const message of messages) {
+		signal?.throwIfAborted();
+		if (message.role === "user" && isCompactCheckpointSource(message.source)) {
+			continuitySummary = textOfCheckpoint(message);
+			continue;
+		}
+		const toolResult = message.content[0];
+		if (message.role === "user" && message.content.length === 1 && toolResult?.type === "tool-result") {
+			const id = historyToolCallId(toolResult.toolCallId);
+			const name = toolNames.get(id);
+			const output = await toolOutput(ctx, toolResult.content, signal);
+			push(message, name === "apply_patch" || name === "exec" ? {
+				type: "custom_tool_call_output",
+				call_id: id,
+				output
+			} : {
+				type: "function_call_output",
+				call_id: id,
+				output
+			});
+			continue;
+		}
+		if (message.role === "assistant") {
+			const output = [];
+			for (const block of message.content) {
+				if (block.type === "reasoning") continue;
+				if (block.type === "tool-call") {
+					if (output.length > 0) push(message, {
+						type: "message",
+						role: "assistant",
+						content: output.splice(0),
+						id: String(message.id),
+						status: "completed"
+					});
+					const id = historyToolCallId(block.id);
+					if (block.name === "apply_patch" || block.name === "exec") push(message, {
+						type: "custom_tool_call",
+						name: block.name,
+						input: rawCustomInput(block.name, block.arguments),
+						call_id: id
+					});
+					else push(message, {
+						type: "function_call",
+						name: block.name,
+						arguments: block.arguments,
+						call_id: id
+					});
+					continue;
+				}
+				output.push(outputText(block));
+			}
+			if (output.length > 0) push(message, {
+				type: "message",
+				role: "assistant",
+				content: output,
+				id: String(message.id),
+				status: "completed"
+			});
+			continue;
+		}
+		const content = [];
+		for (const block of message.content) if (block.type === "image") content.push(await imageItem(ctx, block.attachment, signal));
+		else if (block.type === "text") content.push(inputText(block));
+		else throw new Error(`Nanocodex cannot hydrate user content block ${JSON.stringify(block.type)}`);
+		if (content.length === 0) throw new Error(`Nanocodex cannot hydrate empty DSH message ${String(message.id)}`);
+		push(message, {
+			type: "message",
+			role: message.role === "system" ? "developer" : "user",
+			content,
+			id: String(message.id),
+			status: "completed"
+		});
+	}
+	return {
+		history,
+		items,
+		...continuitySummary !== void 0 ? { continuitySummary } : {}
+	};
+}
+async function buildHistorySeed(messages, ctx, signal) {
+	const { items: _items, ...seed } = await buildHistoryProjection(messages, ctx, signal);
+	return seed;
+}
+/** Convert newly admitted DSH user content into one Nanocodex prompt. */
+async function buildPromptInput(messages, ctx, signal) {
+	const items = [];
+	for (const message of messages) {
+		signal?.throwIfAborted();
+		for (const block of message.content) if (block.type === "text") items.push({
+			type: "text",
+			text: block.text
+		});
+		else if (block.type === "image") {
+			const stored = await ctx.attachments.readImage(block.attachment, signal);
+			items.push({
+				type: "image",
+				image_url: imageDataUrl(stored.ref, stored.data),
+				detail: "auto"
+			});
+		} else if (block.type === "tool-result") continue;
+		else throw new Error(`Nanocodex cannot use admitted DSH content block ${JSON.stringify(block.type)} as prompt input`);
+	}
+	if (items.length === 0) return "Continue from the current conversation.";
+	if (items.length === 1 && items[0]?.type === "text") return items[0].text;
+	return items;
+}
+function plainText(messages) {
+	return messages.flatMap((message) => message.content.flatMap((block) => block.type === "text" ? [block.text] : [])).join("\n");
+}
+//#endregion
+//#region src/session-id.ts
+const DSH_SESSION_ID = /^session-([0-9a-f]{8}-[0-9a-f]{4}-[47][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})$/iu;
+/** Convert the DSH `session-<UUID>` identity to Nanocodex's UUID identity. */
+function normalizeNanocodexSessionId(value) {
+	const match = DSH_SESSION_ID.exec(value);
+	if (match?.[1] === void 0) throw new Error(`Nanocodex requires a DSH session ID in the form session-<UUIDv4|UUIDv7>, got ${JSON.stringify(value)}`);
+	return match[1].toLowerCase();
+}
+//#endregion
+//#region src/settings.ts
+const SETTINGS_NAMESPACE = "llm-pi-ai";
+const SUPPORTED_PROVIDERS = ["openai", "openai-codex-responses"];
+const DEFAULT_NATIVE_API = "openai-responses";
+const profile = z$1.object({
+	apiKeyEnv: z$1.string(),
+	api: z$1.string(),
+	baseURL: z$1.string(),
+	websocketURL: z$1.string(),
+	reasoning: z$1.string()
+}).loose(true);
+/**
+* Keep the existing settings namespace and profile shape readable by DSH
+* configuration surfaces while accepting fields owned by older pi-ai
+* profiles. Nanocodex intentionally validates only the route fields it can
+* act on at request admission.
+*/
+const NanocodexSettingsSchema = z$1.object({ providers: z$1.dict(profile).default({}) });
+function normalizedApi(provider, api) {
+	if (api !== void 0) return api;
+	return SUPPORTED_PROVIDERS.includes(provider) ? DEFAULT_NATIVE_API : void 0;
+}
+function configuredNanocodexProviders(value) {
+	return SUPPORTED_PROVIDERS.filter((provider) => {
+		const configured = value.providers[provider];
+		return configured !== void 0 && isSupportedRoute(provider, normalizedApi(provider, configured.api));
+	});
+}
+function settingsValue(ctx) {
+	const value = ctx.settings.get(SETTINGS_NAMESPACE);
+	if (!value || typeof value !== "object") throw new Error(`Nanocodex route settings are unavailable: register ${SETTINGS_NAMESPACE} before creating an agent`);
+	const providers = value.providers;
+	if (!providers || typeof providers !== "object" || Array.isArray(providers)) throw new Error(`Nanocodex route settings ${SETTINGS_NAMESPACE}.providers is invalid`);
+	return { providers };
+}
+function thinking(value) {
+	if (value === "none" || value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max") return value;
+}
+function supportedThinking(value) {
+	if (value === "pro") return value;
+	return thinking(value);
+}
+/** Resolve one explicit DSH route without provider or credential fallbacks. */
+async function resolveNanocodexRoute(ctx, options) {
+	const provider = options.provider;
+	const model = options.model;
+	if (!provider || !model) throw new Error("Nanocodex requires an explicit AgentOptions.provider and AgentOptions.model");
+	if (!isSupportedModel(model)) throw new Error(`Nanocodex does not support model ${JSON.stringify(model)}`);
+	const configured = settingsValue(ctx).providers[provider];
+	if (!configured) throw new Error(`Nanocodex route ${JSON.stringify(provider)} is not configured`);
+	if (!isSupportedRoute(provider, normalizedApi(provider, configured.api))) throw new Error(`Nanocodex does not support route ${JSON.stringify(provider)} with api ${JSON.stringify(configured.api)}`);
+	if (!configured.apiKeyEnv) throw new Error(`Nanocodex route ${JSON.stringify(provider)} must declare apiKeyEnv in ${SETTINGS_NAMESPACE}`);
+	let ref;
+	try {
+		ref = credentialRef(configured.apiKeyEnv);
+	} catch (error) {
+		throw new Error(`Nanocodex route ${JSON.stringify(provider)} has an invalid credential reference`, { cause: error });
+	}
+	const resolved = await ctx.credentials.resolve(ref);
+	if (!resolved?.value) throw new Error(`Nanocodex credential ${JSON.stringify(configured.apiKeyEnv)} is not configured for route ${JSON.stringify(provider)}`);
+	const selectedThinking = thinking(options.reasoningEffort ?? configured.reasoning);
+	return {
+		provider,
+		model,
+		apiKey: resolved.value,
+		...configured.baseURL ? { apiBaseUrl: configured.baseURL } : {},
+		...configured.websocketURL ? { websocketUrl: configured.websocketURL } : {},
+		...selectedThinking === void 0 ? {} : { thinking: selectedThinking }
+	};
+}
+//#endregion
+//#region src/tool-bridge.ts
+function jsonArguments(input) {
+	try {
+		return JSON.stringify(input ?? {}) ?? "{}";
+	} catch (error) {
+		throw new Error("Nanocodex produced non-serializable tool arguments", { cause: error });
+	}
+}
+function normalizedArguments(input) {
+	const text = jsonArguments(input);
+	return {
+		text,
+		value: JSON.parse(text)
+	};
+}
+function contentText(content) {
+	return content.flatMap((block) => block.type === "text" ? [block.text] : []).join("\n") || "The DSH tool returned no text content.";
+}
+function modelValue(result, custom) {
+	if (custom) return contentText(result.content);
+	if (!result.isError) return result.value;
+	return {
+		error: result.error.message,
+		content: contentText(result.content)
+	};
+}
+function executionFailure(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return {
+		isError: true,
+		error: { message },
+		content: [{
+			type: "text",
+			text: message
+		}]
+	};
+}
+function makeTool(definition, context, customDefinition) {
+	const custom = customDefinition?.type === "custom";
+	let outputSchema = structuredClone(definition.output.schema);
+	let description = definition.description;
+	if (definition.name === "read_image") {
+		description += "\nIn Code Mode, display the loaded image with image(await tools.read_image({file_path: \"picture.png\"})). The result contains path and image_url (a data URL); image(result) emits the image to the model. A bare return does not emit output.";
+		outputSchema = {
+			type: "object",
+			properties: {
+				path: {
+					type: "string",
+					description: "Resolved image file path."
+				},
+				image_url: {
+					type: "string",
+					description: "Loaded image data URL."
+				}
+			},
+			required: ["path", "image_url"],
+			additionalProperties: false
+		};
+	}
+	return {
+		name: definition.name,
+		description,
+		parameters: structuredClone(definition.parameters),
+		outputSchema,
+		...customDefinition === void 0 ? {} : { definition: structuredClone(customDefinition) },
+		async handler(input, call) {
+			const id = call.callId;
+			const argumentsValue = normalizedArguments(custom && definition.name === "apply_patch" ? (() => {
+				if (typeof input !== "string" || input.length === 0) throw new TypeError("apply_patch expects one non-empty raw patch string");
+				return { patch: input };
+			})() : input);
+			const callSeq = await context.callbacks.onCall({
+				id,
+				name: definition.name,
+				arguments: argumentsValue.text,
+				...call.parentCallId ? { parentCallId: call.parentCallId } : {}
+			});
+			const parentCallId = call.parentCallId;
+			if (parentCallId) context.agent.session.append("tool/code-dispatch-start", {
+				rootCallId: ToolCallId(parentCallId),
+				parentCallId: ToolCallId(parentCallId),
+				subCallId: ToolCallId(id),
+				name: definition.name,
+				arguments: argumentsValue.value
+			});
+			let result;
+			try {
+				result = await context.tools.execute({
+					callId: ToolCallId(id),
+					...call.parentCallId ? { rootCallId: ToolCallId(call.parentCallId) } : {},
+					name: definition.name,
+					arguments: argumentsValue.value,
+					agent: context.agent,
+					signal: call.signal
+				});
+			} catch (error) {
+				result = executionFailure(error);
+			}
+			try {
+				await context.callbacks.onResult({
+					id,
+					callSeq,
+					result,
+					...parentCallId ? { parentCallId } : {}
+				});
+			} finally {
+				if (parentCallId) context.agent.session.append("tool/code-dispatch", {
+					rootCallId: ToolCallId(parentCallId),
+					parentCallId: ToolCallId(parentCallId),
+					subCallId: ToolCallId(id),
+					name: definition.name,
+					arguments: argumentsValue.value,
+					isError: result.isError,
+					content: result.content
+				});
+			}
+			if (!result.isError && definition.name === "read_image") {
+				const image = result.content.find((block) => block.type === "image");
+				if (image?.type !== "image") throw new Error("read_image returned no image attachment");
+				const stored = await context.agent.ctx.attachments.readImage(image.attachment, call.signal);
+				return {
+					path: result.value.path,
+					image_url: `data:${stored.ref.mediaType};base64,${Buffer.from(stored.data).toString("base64")}`
+				};
+			}
+			return modelValue(result, custom);
+		}
+	};
+}
+/** Build one model-facing tool set from the active DSH scope. */
+function createToolBridge(context) {
+	const scope = scopeOf(context.agent.ctx);
+	return context.tools.schemas(scope).map((schema) => context.tools.get(schema.name, scope)).filter((definition) => definition !== void 0).map((definition) => makeTool(definition, context, context.customDefinitions?.get(definition.name)));
+}
+//#endregion
+//#region src/interrupted-tools.ts
+/** Close admitted calls at a stopped driver boundary without replaying them. */
+function closeInterruptedToolCalls(session, failure) {
+	const calls = /* @__PURE__ */ new Map();
+	const results = /* @__PURE__ */ new Set();
+	for (const seq of session.surface.nodes) {
+		const event = session.eventAt(seq);
+		if (event?.type === "assistant/message") for (const block of event.data.message.content) {
+			if (block.type !== "tool-call") continue;
+			const id = String(block.id);
+			if (calls.has(id)) throw new Error(`Cannot recover duplicate tool call ${JSON.stringify(id)}`);
+			calls.set(id, {
+				block,
+				turn: event.data.turn,
+				step: event.data.step
+			});
+		}
+		else if (event?.type === "tool/result") results.add(String(event.data.message.source.callId));
+	}
+	for (const id of results) calls.delete(id);
+	if (calls.size === 0) return;
+	const callSeqs = /* @__PURE__ */ new Map();
+	for (const event of session.snapshotEvents()) {
+		if (event.type !== "tool/call") continue;
+		const pending = calls.get(String(event.data.callId));
+		if (pending?.turn === event.data.turn && pending.step === event.data.step) callSeqs.set(String(event.data.callId), event.seq);
+	}
+	const cause = failure instanceof Error ? failure.message : String(failure);
+	const text = failure === void 0 ? INTERRUPTED_TOOL_OUTPUT : `${INTERRUPTED_TOOL_OUTPUT}\nCause: ${cause.slice(0, 1024)}`;
+	for (const [id, { block, turn, step }] of calls) {
+		const callSeq = callSeqs.get(id) ?? session.append("tool/call", {
+			turn,
+			step,
+			callId: block.id,
+			name: block.name,
+			arguments: block.arguments
+		}).seq;
+		session.append("tool/result", {
+			turn,
+			step,
+			message: createToolResultMessage({
+				callId: block.id,
+				content: [{
+					type: "text",
+					text
+				}],
+				isError: true
+			})
+		}, {
+			surfaceOp: "append",
+			sourceEventSeqs: [callSeq]
+		});
+	}
+}
+//#endregion
+//#region src/output.ts
+function record$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function count(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+}
+/** Responses input includes cache buckets; DSH input excludes them. */
+function modelCallUsage(event) {
+	if (event.type !== "model.call.completed") return void 0;
+	const value = record$1(event.payload.usage);
+	const input = count(value?.input_tokens);
+	const output = count(value?.output_tokens);
+	if (value === void 0 || input === void 0 || output === void 0) return void 0;
+	const details = record$1(value.input_tokens_details);
+	const cacheReadTokens = count(details?.cached_tokens);
+	const cacheWriteTokens = count(details?.cache_write_tokens);
+	const reasoningTokens = count(record$1(value.output_tokens_details)?.reasoning_tokens);
+	const totalTokens = count(value.total_tokens);
+	return {
+		inputTokens: Math.max(0, input - (cacheReadTokens ?? 0) - (cacheWriteTokens ?? 0)),
+		outputTokens: output,
+		...totalTokens === void 0 ? {} : { totalTokens },
+		...cacheReadTokens === void 0 ? {} : { cacheReadTokens },
+		...cacheWriteTokens === void 0 ? {} : { cacheWriteTokens },
+		...reasoningTokens === void 0 ? {} : { reasoningTokens }
+	};
+}
+function outputBlock(item) {
+	if (item.type === "message" && item.role === "assistant" && Array.isArray(item.content)) {
+		const text = item.content.map(record$1).flatMap((part) => part?.type === "output_text" && typeof part.text === "string" ? [part.text] : []).join("");
+		return text ? {
+			type: "text",
+			text
+		} : void 0;
+	}
+	if ((item.type === "custom_tool_call" || item.type === "function_call") && typeof item.call_id === "string" && typeof item.name === "string") {
+		let args;
+		if (item.type === "custom_tool_call") {
+			if (typeof item.input !== "string") throw new Error("Nanocodex custom call has no raw input");
+			if (item.name === "exec") args = JSON.stringify({ code: item.input });
+			else if (item.name === "apply_patch") args = JSON.stringify({ patch: item.input });
+			else throw new Error(`Nanocodex cannot project custom tool ${JSON.stringify(item.name)}`);
+		} else {
+			if (typeof item.arguments !== "string") throw new Error("Nanocodex function call has no arguments");
+			args = item.arguments;
+		}
+		return {
+			type: "tool-call",
+			id: ToolCallId(item.call_id),
+			name: item.name,
+			arguments: args
+		};
+	}
+}
+async function resultContent(agent, value) {
+	if (typeof value === "string") return [{
+		type: "text",
+		text: value
+	}];
+	if (!Array.isArray(value)) throw new Error("Nanocodex tool result has no supported output body");
+	const content = value.map((value) => {
+		const part = record$1(value);
+		if (part?.type === "input_text" && typeof part.text === "string") return {
+			type: "text",
+			text: part.text
+		};
+		if (part?.type === "input_image" && typeof part.image_url === "string") {
+			const match = /^data:(image\/(?:png|jpeg|webp|gif));base64,([A-Za-z0-9+/=]+)$/u.exec(part.image_url);
+			if (match) return {
+				type: "image",
+				mediaType: match[1],
+				data: match[2]
+			};
+		}
+		throw new Error("Nanocodex tool result contains an unsupported content part");
+	});
+	if (content.every((part) => part.type === "text")) return content;
+	return admitPromptContent(agent.ctx.attachments, content);
+}
+/** One DSH step and one durable Assistant per Nanocodex model request. */
+var NanocodexOutput = class {
+	agent;
+	provider;
+	model;
+	turn;
+	advanceStep;
+	step;
+	started = false;
+	committed = false;
+	blocks = [];
+	chunkSeqs = [];
+	textIndices = /* @__PURE__ */ new Map();
+	openText;
+	outputItems = /* @__PURE__ */ new Map();
+	parents = /* @__PURE__ */ new Map();
+	constructor(agent, provider, model, turn, step, advanceStep) {
+		this.agent = agent;
+		this.provider = provider;
+		this.model = model;
+		this.turn = turn;
+		this.advanceStep = advanceStep;
+		this.step = step;
+	}
+	get coordinates() {
+		return {
+			turn: this.turn,
+			step: this.step
+		};
+	}
+	chunk(chunk) {
+		this.chunkSeqs.push(this.agent.session.append("assistant/chunk", {
+			...this.coordinates,
+			chunk
+		}).seq);
+	}
+	text(text, id, complete) {
+		if (!text) return;
+		let index = typeof id === "string" ? this.textIndices.get(id) : this.openText;
+		if (index === void 0) {
+			index = this.blocks.length;
+			this.blocks.push({
+				type: "text",
+				text: ""
+			});
+			if (typeof id === "string") this.textIndices.set(id, index);
+			this.chunk({
+				type: "block-start",
+				index,
+				blockType: "text"
+			});
+		}
+		const previous = this.blocks[index];
+		if (previous?.type !== "text") throw new Error("Nanocodex text stream lost its block");
+		if (complete) {
+			this.blocks[index] = {
+				type: "text",
+				text
+			};
+			this.chunk({
+				type: "block-end",
+				index,
+				block: this.blocks[index]
+			});
+			this.openText = void 0;
+		} else {
+			this.blocks[index] = {
+				type: "text",
+				text: previous.text + text
+			};
+			this.openText = index;
+			this.chunk({
+				type: "text-delta",
+				index,
+				text
+			});
+		}
+	}
+	installOutput(items) {
+		this.blocks = items.flatMap((item) => {
+			const block = outputBlock(item);
+			return block === void 0 ? [] : [block];
+		});
+		for (const [index, block] of this.blocks.entries()) this.chunk({
+			type: "block-end",
+			index,
+			block
+		});
+	}
+	commit(usage, interrupted = false) {
+		if (this.committed) return;
+		if (usage !== void 0) this.chunk({
+			type: "usage",
+			usage
+		});
+		for (const block of this.blocks) if (block.type === "tool-call") this.parents.set(String(block.id), {
+			block,
+			step: this.step
+		});
+		this.agent.session.append("assistant/message", {
+			...this.coordinates,
+			message: createAssistantMessage({
+				content: this.blocks,
+				source: {
+					provider: this.provider,
+					model: this.model
+				}
+			}),
+			...usage === void 0 ? {} : { usage },
+			...interrupted ? { interrupted: true } : {}
+		}, {
+			surfaceOp: "append",
+			sourceEventSeqs: this.chunkSeqs
+		});
+		this.committed = true;
+	}
+	async accept(event) {
+		const payload = event.payload;
+		if (event.type === "model.call.started") {
+			if (this.started) {
+				if (!this.committed && this.blocks.length > 0) this.commit(void 0, true);
+				this.step = this.advanceStep();
+			}
+			this.started = true;
+			this.committed = false;
+			this.blocks = [];
+			this.chunkSeqs = [];
+			this.textIndices.clear();
+			this.outputItems.clear();
+			this.openText = void 0;
+		} else if (event.type === "assistant.delta" && typeof payload.text === "string") this.text(payload.text, payload.item_id, false);
+		else if (event.type === "assistant.message" && typeof payload.text === "string") this.text(payload.text, payload.item_id, true);
+		else if (event.type === "api.event" && payload.phase === "generation") {
+			const api = record$1(payload.event);
+			if (api?.type === "response.output_item.done") {
+				const item = record$1(api.item);
+				if (item !== void 0) this.outputItems.set(String(item.id ?? api.output_index), item);
+			} else if (api?.type === "response.completed") {
+				const output = record$1(api.response)?.output;
+				if (Array.isArray(output) && output.length > 0) this.installOutput(output.flatMap((value) => {
+					const item = record$1(value);
+					return item === void 0 ? [] : [item];
+				}));
+				else if (this.outputItems.size > 0) this.installOutput([...this.outputItems.values()]);
+			}
+		} else if (event.type === "model.call.completed") this.commit(modelCallUsage(event));
+		else if (event.type === "tool.call" || event.type === "tool.result") {
+			if (typeof payload.call_id !== "string") return;
+			const parent = this.parents.get(payload.call_id);
+			if (parent === void 0 || parent.block.name !== "exec" && parent.block.name !== "wait") return;
+			if (event.type === "tool.call") parent.callSeq = this.agent.session.append("tool/call", {
+				turn: this.turn,
+				step: parent.step,
+				callId: parent.block.id,
+				name: parent.block.name,
+				arguments: parent.block.arguments
+			}).seq;
+			else {
+				if (parent.callSeq === void 0) throw new Error("Nanocodex parent result has no durable call");
+				this.agent.session.append("tool/result", {
+					turn: this.turn,
+					step: parent.step,
+					message: createToolResultMessage({
+						callId: parent.block.id,
+						content: await resultContent(this.agent, payload.result),
+						isError: payload.status !== "completed"
+					})
+				}, {
+					surfaceOp: "append",
+					sourceEventSeqs: [parent.callSeq]
+				});
+				this.parents.delete(payload.call_id);
+			}
+		}
+	}
+	finish(finalText) {
+		if (this.committed) return;
+		if (this.blocks.length === 0 && finalText) this.text(finalText, void 0, true);
+		if (this.blocks.length > 0) this.commit();
+	}
+	interrupt(error) {
+		if (!this.committed && this.blocks.length > 0) this.commit(void 0, true);
+		closeInterruptedToolCalls(this.agent.session, error);
+	}
+};
+//#endregion
+//#region src/transport-diagnostic.ts
+const FALLBACK_EVENT = "model.attempt.retrying";
+const FALLBACK_ERROR_CLASS = "websocket_fallback";
+const PREVIOUS_TRANSPORT = "responses_websocket_v2";
+const NEXT_TRANSPORT = "responses_https_sse";
+const REASONS = /* @__PURE__ */ new Set([
+	"upgrade_required",
+	"transport_unavailable",
+	"retry_exhausted"
+]);
+const MAX_CORRELATION_LENGTH = 128;
+function boundedCorrelation(value) {
+	if (typeof value !== "string" || value.length === 0) return void 0;
+	return value.slice(0, MAX_CORRELATION_LENGTH);
+}
+function transportFallbackDiagnostic(sessionId, event) {
+	if (event.type !== FALLBACK_EVENT) return void 0;
+	const payload = event.payload;
+	if (payload.error_class !== FALLBACK_ERROR_CLASS || payload.previous_transport !== PREVIOUS_TRANSPORT || payload.next_transport !== NEXT_TRANSPORT || typeof payload.reason !== "string" || !REASONS.has(payload.reason)) return;
+	const reason = payload.reason;
+	const requestId = boundedCorrelation(event.request_id);
+	return {
+		kind: "nanocodex.transport_fallback",
+		session_id: boundedCorrelation(sessionId) ?? "unknown",
+		...requestId === void 0 ? {} : { request_id: requestId },
+		error_class: FALLBACK_ERROR_CLASS,
+		previous_transport: PREVIOUS_TRANSPORT,
+		next_transport: NEXT_TRANSPORT,
+		reason
+	};
+}
+/** Observe public Nanocodex fallback events and project only safe fields. */
+function observeTransportFallback(ctx, sessionId, source) {
+	const watcher = source.events.watch();
+	const removeListener = watcher.onEvent((event) => {
+		const diagnostic = transportFallbackDiagnostic(sessionId, event);
+		if (diagnostic === void 0) return;
+		try {
+			ctx.logger("dsh-nanocodex.transport").info(diagnostic);
+		} catch {}
+	});
+	return () => {
+		removeListener();
+		watcher.off();
+	};
+}
+//#endregion
+//#region src/engine.ts
+const nanocodexCheckpointDomain = defineDomain({
+	name: "nanocodex_checkpoints",
+	version: 1,
+	layout: "per-record",
+	tables: { sessions: domainTable(z.custom((value) => checkpoint(value) !== void 0)) }
+});
+const RAW_APPLICATION_DEFINITIONS = /* @__PURE__ */ new Map([[APPLY_PATCH_NAME, {
+	type: "custom",
+	description: APPLY_PATCH_DESCRIPTION,
+	format: {
+		type: "grammar",
+		syntax: "lark",
+		definition: APPLY_PATCH_GRAMMAR
+	}
+}]]);
+function runtimeKey(agent) {
+	return String(agent.session.id);
+}
+function messageText(message) {
+	return plainText([message]);
+}
+function supplementaryContext(messages) {
+	return messages.filter((message) => message.source.kind === "plugin").map(messageText).filter(Boolean).join("\n\n") || void 0;
+}
+function routeKey(route, agent) {
+	return JSON.stringify({
+		provider: route.provider,
+		model: route.model,
+		apiKeyDigest: createHash("sha256").update(route.apiKey).digest("hex"),
+		apiBaseUrl: route.apiBaseUrl,
+		websocketUrl: route.websocketUrl,
+		thinking: route.thinking,
+		reasoningEffort: agent.options.reasoningEffort
+	});
+}
+function fingerprint(messages) {
+	return createHash("sha256").update(JSON.stringify(messages)).digest("hex");
+}
+function makeBoundary(session, messages) {
+	return {
+		replaceGeneration: session.surface.replaceGeneration,
+		surfaceSeqs: [...session.surface.nodes],
+		messageCount: messages.length,
+		fingerprint: fingerprint(messages)
+	};
+}
+function boundaryMatches(boundary, session, messages) {
+	const nodes = session.surface.nodes;
+	return boundary.replaceGeneration === session.surface.replaceGeneration && boundary.messageCount === messages.length && boundary.surfaceSeqs.length <= nodes.length && boundary.surfaceSeqs.every((seq, index) => nodes[index] === seq) && boundary.fingerprint === fingerprint(messages);
+}
+function surfacePrefix(session, messageCount) {
+	const nodes = [...session.surface.nodes];
+	if (messageCount > nodes.length) throw new Error("Nanocodex compaction cannot capture a DSH admission boundary");
+	return nodes.slice(0, messageCount);
+}
+function record(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function supportedModel(value) {
+	return typeof value === "string" && isSupportedModel(value) ? value : void 0;
+}
+function sessionSnapshot(value) {
+	const candidate = record(value);
+	if (!candidate || !Array.isArray(candidate.history)) return void 0;
+	if (supportedModel(candidate.model) === void 0) return void 0;
+	return candidate;
+}
+function checkpoint(value) {
+	const candidate = record(value);
+	const boundary = record(candidate?.boundary);
+	const snapshot = sessionSnapshot(candidate?.snapshot);
+	if (candidate?.version !== 1 || typeof candidate.provider !== "string" || supportedModel(candidate.model) === void 0 || !boundary || snapshot === void 0 || snapshot.model !== candidate.model || !Array.isArray(boundary.surfaceSeqs) || !boundary.surfaceSeqs.every((seq) => typeof seq === "number" && Number.isSafeInteger(seq) && seq >= 0) || typeof boundary.replaceGeneration !== "number" || !Number.isSafeInteger(boundary.replaceGeneration) || boundary.replaceGeneration < 0 || typeof boundary.messageCount !== "number" || !Number.isSafeInteger(boundary.messageCount) || boundary.messageCount < 0 || typeof boundary.fingerprint !== "string") return;
+	return {
+		version: 1,
+		provider: candidate.provider,
+		model: supportedModel(candidate.model),
+		boundary: {
+			replaceGeneration: boundary.replaceGeneration,
+			surfaceSeqs: boundary.surfaceSeqs,
+			messageCount: boundary.messageCount,
+			fingerprint: boundary.fingerprint
+		},
+		snapshot
+	};
+}
+function findMatchingCheckpoint(store, session, messages, provider, model) {
+	const candidate = checkpoint(store.get(session.id));
+	if (candidate !== void 0 && candidate.provider === provider && candidate.model === model && boundaryMatches(candidate.boundary, session, messages)) return candidate;
+}
+const DEFAULT_COMPACTION_INSTRUCTION = [
+	"Create a concise private continuity summary of the conversation above.",
+	"Preserve important facts, preferences, commitments, unresolved questions, and the immediate context.",
+	"Return summary text only. Do not mention this instruction or compaction."
+].join("\n");
+async function* emptyLlmStream() {}
+function integer(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function nullableString(value) {
+	return value === null || typeof value === "string";
+}
+function parseCompactionIdentity(value) {
+	const candidate = record(value);
+	if (!candidate || !integer(candidate.index) || typeof candidate.kind !== "string" || candidate.kind.length === 0 || !nullableString(candidate.id) || !nullableString(candidate.call_id)) return;
+	return candidate;
+}
+function parseCompactionOutcome(value) {
+	const candidate = record(value);
+	const range = record(candidate?.replaced_history);
+	const context = record(candidate?.context);
+	const retained = Array.isArray(candidate?.retained_tail) ? candidate.retained_tail.map(parseCompactionIdentity) : void 0;
+	if (!candidate || typeof candidate.revision !== "string" || candidate.revision.length === 0 || candidate.trigger !== "manual" && candidate.trigger !== "automatic" || !nullableString(candidate.summary) || !range || !integer(range.start) || !integer(range.end) || range.start > range.end || !retained || retained.some((item) => item === void 0) || !context || typeof context.workspace !== "string" || !Array.isArray(context.history) || !context.history.every((item) => record(item) !== void 0)) return;
+	return candidate;
+}
+function parseCompactionReplacedEvent(event) {
+	if (event.type !== "model.compaction.replaced") return void 0;
+	if (parseCompactionOutcome(event.payload) === void 0 || !integer(event.payload.after_model_call_index) || event.payload.phase !== "pre_turn" && event.payload.phase !== "mid_turn") return;
+	return event.payload;
+}
+function projectedIdentityMatches(identity, item) {
+	const identityKind = identity.kind === "custom_tool_call" ? "function_call" : identity.kind === "custom_tool_call_output" ? "function_call_output" : identity.kind;
+	if (identityKind !== (item.type === "custom_tool_call" ? "function_call" : item.type === "custom_tool_call_output" ? "function_call_output" : item.type)) return false;
+	const callId = "call_id" in item ? item.call_id : null;
+	if (identity.call_id !== callId) return false;
+	return identityKind === "message" || identityKind === "function_call" || identityKind === "function_call_output" || identity.id === (item.id ?? null);
+}
+function historyImageDetail(value) {
+	return value === void 0 || value === "auto" || value === "low" || value === "high" || value === "original";
+}
+function historyInputItemMatches(left, right) {
+	const leftObject = record(left);
+	const rightObject = record(right);
+	if (leftObject === void 0 || rightObject === void 0) return false;
+	if (leftObject.type !== rightObject.type) return false;
+	switch (leftObject.type) {
+		case "input_text": return typeof leftObject.text === "string" && leftObject.text === rightObject.text;
+		case "input_image": return typeof leftObject.image_url === "string" && leftObject.image_url === rightObject.image_url && historyImageDetail(leftObject.detail) && historyImageDetail(rightObject.detail) && leftObject.detail === rightObject.detail;
+		case "input_audio": return typeof leftObject.audio_url === "string" && leftObject.audio_url === rightObject.audio_url;
+		case "encrypted_content": return typeof leftObject.encrypted_content === "string" && leftObject.encrypted_content === rightObject.encrypted_content;
+		default: return false;
+	}
+}
+function historyContentItemMatches(left, right) {
+	const leftObject = record(left);
+	const rightObject = record(right);
+	if (leftObject === void 0 || rightObject === void 0) return false;
+	if (leftObject.type !== rightObject.type) return false;
+	if (leftObject.type === "output_text") return typeof leftObject.text === "string" && leftObject.text === rightObject.text;
+	if (leftObject.type === "input_text" || leftObject.type === "input_image" || leftObject.type === "input_audio") return historyInputItemMatches(left, right);
+	return false;
+}
+function historyContentMatches(left, right) {
+	return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((item, index) => historyContentItemMatches(item, right[index]));
+}
+function historyToolOutputMatches(left, right) {
+	if (typeof left === "string" || typeof right === "string") return typeof left === "string" && left === right;
+	return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((item, index) => historyInputItemMatches(item, right[index]));
+}
+function historyMessageMatches(left, right) {
+	return left?.type === "message" && right.type === "message" && left.role === right.role && historyContentMatches(left.content, right.content);
+}
+function historyItemsMatch(left, right) {
+	if (left === void 0) return false;
+	const leftType = historyKind(left);
+	if (leftType !== historyKind(right)) return false;
+	switch (leftType) {
+		case "message": return left.type === "message" && right.type === "message" && left.role === right.role && historyContentMatches(left.content, right.content);
+		case "function_call": {
+			const leftCall = functionCallFields(left);
+			const rightCall = functionCallFields(right);
+			return leftCall !== void 0 && rightCall !== void 0 && leftCall.name === rightCall.name && leftCall.input === rightCall.input && leftCall.call_id === rightCall.call_id;
+		}
+		case "function_call_output": {
+			const leftOutput = functionCallOutputFields(left);
+			const rightOutput = functionCallOutputFields(right);
+			return leftOutput !== void 0 && rightOutput !== void 0 && leftOutput.call_id === rightOutput.call_id && historyToolOutputMatches(leftOutput.output, rightOutput.output);
+		}
+		case "compaction": return left.type === "compaction" && right.type === "compaction" && left.encrypted_content === right.encrypted_content;
+		default: return false;
+	}
+}
+function historyKind(item) {
+	if (item.type === "custom_tool_call") return "function_call";
+	if (item.type === "custom_tool_call_output") return "function_call_output";
+	return item.type;
+}
+function functionCallFields(item) {
+	if (item.type === "function_call") return {
+		name: item.name,
+		input: item.arguments,
+		call_id: item.call_id
+	};
+	if (item.type === "custom_tool_call") return {
+		name: item.name,
+		input: item.input,
+		call_id: item.call_id
+	};
+}
+function functionCallOutputFields(item) {
+	if (item.type === "function_call_output" || item.type === "custom_tool_call_output") return {
+		call_id: item.call_id,
+		output: item.output
+	};
+}
+function validateRetainedApplyPatchPairs(items) {
+	const callIds = /* @__PURE__ */ new Set();
+	const resultIds = /* @__PURE__ */ new Set();
+	for (const item of items) {
+		if (item.type === "custom_tool_call" && item.name === "apply_patch") {
+			if (callIds.has(item.call_id)) throw new Error(`Nanocodex compaction retained duplicate apply_patch call ${JSON.stringify(item.call_id)}`);
+			callIds.add(item.call_id);
+			continue;
+		}
+		if (item.type !== "custom_tool_call_output") continue;
+		const namedPatch = item.name === APPLY_PATCH_NAME;
+		const matchesPatchCall = callIds.has(item.call_id);
+		if (!namedPatch && !matchesPatchCall) continue;
+		if (!matchesPatchCall) throw new Error(`Nanocodex compaction retained apply_patch output has no matching call ${JSON.stringify(item.call_id)}`);
+		if (item.name !== void 0 && item.name !== "apply_patch") throw new Error(`Nanocodex compaction retained apply_patch output has a mismatched name ${JSON.stringify(item.call_id)}`);
+		if (resultIds.has(item.call_id)) throw new Error(`Nanocodex compaction retained duplicate apply_patch output ${JSON.stringify(item.call_id)}`);
+		resultIds.add(item.call_id);
+	}
+	for (const callId of callIds) if (!resultIds.has(callId)) throw new Error(`Nanocodex compaction retained apply_patch call without a result ${JSON.stringify(callId)}`);
+	return callIds;
+}
+function codeDispatchAssociations(session) {
+	const bySubCallId = /* @__PURE__ */ new Map();
+	for (const event of session.snapshotEvents()) {
+		if (event.type !== "tool/code-dispatch-start" && event.type !== "tool/code-dispatch") continue;
+		const subCallId = String(event.data.subCallId);
+		const state = bySubCallId.get(subCallId) ?? {
+			starts: [],
+			settles: []
+		};
+		if (event.type === "tool/code-dispatch-start") state.starts.push({
+			seq: event.seq,
+			data: event.data
+		});
+		else state.settles.push({
+			seq: event.seq,
+			data: event.data
+		});
+		bySubCallId.set(subCallId, state);
+	}
+	const associations = /* @__PURE__ */ new Map();
+	const associationFor = (parentCallId) => {
+		const existing = associations.get(parentCallId);
+		if (existing !== void 0) return existing;
+		const created = {
+			children: [],
+			invalid: false
+		};
+		associations.set(parentCallId, created);
+		return created;
+	};
+	for (const state of bySubCallId.values()) {
+		const parentCallIds = /* @__PURE__ */ new Set([...state.starts.map((event) => String(event.data.parentCallId)), ...state.settles.map((event) => String(event.data.parentCallId))]);
+		for (const parentCallId of parentCallIds) {
+			const association = associationFor(parentCallId);
+			const start = state.starts[0];
+			const settle = state.settles[0];
+			if (state.starts.length !== 1 || state.settles.length !== 1 || start === void 0 || settle === void 0 || String(start.data.parentCallId) !== parentCallId || String(settle.data.parentCallId) !== parentCallId || String(start.data.rootCallId) !== String(settle.data.rootCallId) || settle.seq <= start.seq || start.data.name !== settle.data.name || !isDeepStrictEqual(start.data.arguments, settle.data.arguments)) {
+				association.invalid = true;
+				continue;
+			}
+			association.children.push({
+				startSeq: start.seq,
+				settleSeq: settle.seq,
+				subCallId: String(settle.data.subCallId),
+				name: settle.data.name,
+				arguments: settle.data.arguments,
+				isError: settle.data.isError,
+				content: settle.data.content
+			});
+		}
+	}
+	for (const association of associations.values()) association.children.sort((left, right) => left.startSeq - right.startSeq);
+	return associations;
+}
+function dshToolEvidence(session) {
+	const evidence = /* @__PURE__ */ new Map();
+	const forCall = (callId) => {
+		const existing = evidence.get(callId);
+		if (existing !== void 0) return existing;
+		const created = {
+			calls: [],
+			results: []
+		};
+		evidence.set(callId, created);
+		return created;
+	};
+	for (const event of session.snapshotEvents()) if (event.type === "tool/call") forCall(String(event.data.callId)).calls.push({
+		name: event.data.name,
+		arguments: event.data.arguments
+	});
+	else if (event.type === "tool/result") {
+		const block = event.data.message.content[0];
+		forCall(String(event.data.message.source.callId)).results.push({
+			isError: block?.isError === true,
+			content: block?.content ?? []
+		});
+	}
+	return evidence;
+}
+function serializedToolArguments(value) {
+	try {
+		return JSON.stringify(value ?? {}) ?? "{}";
+	} catch {
+		return;
+	}
+}
+function codeDispatchCallMatches(projected, projectedIndex, child, evidence) {
+	const call = projected[projectedIndex]?.item;
+	const callFields = call === void 0 ? void 0 : functionCallFields(call);
+	const tool = evidence.get(child.subCallId);
+	const expectedArguments = serializedToolArguments(child.arguments);
+	const expectedInput = child.name === "apply_patch" ? (() => {
+		try {
+			const value = JSON.parse(serializedToolArguments(child.arguments));
+			return value !== null && typeof value === "object" && !Array.isArray(value) && typeof value.patch === "string" && Object.keys(value).length === 1 ? value.patch : void 0;
+		} catch {
+			return;
+		}
+	})() : serializedToolArguments(child.arguments);
+	return (call?.type === "function_call" || call?.type === "custom_tool_call") && callFields !== void 0 && callFields.call_id === historyToolCallId(child.subCallId) && callFields.name === child.name && expectedInput !== void 0 && callFields.input === expectedInput && expectedArguments !== void 0 && tool !== void 0 && tool.calls.length === 1 && tool.results.length === 1 && tool.calls[0].name === child.name && tool.calls[0].arguments === expectedArguments;
+}
+function codeDispatchResultMatches(projected, projectedIndex, child, evidence) {
+	const output = projected[projectedIndex]?.item;
+	const outputFields = output === void 0 ? void 0 : functionCallOutputFields(output);
+	const tool = evidence.get(child.subCallId);
+	return (output?.type === "function_call_output" || output?.type === "custom_tool_call_output") && outputFields !== void 0 && outputFields.call_id === historyToolCallId(child.subCallId) && tool !== void 0 && tool.calls.length === 1 && tool.results.length === 1 && tool.results[0].isError === child.isError && isDeepStrictEqual(tool.results[0].content, child.content);
+}
+function codeDispatchProjectedCount(projected, projectedIndex, association, evidence) {
+	if (association.invalid || association.children.length === 0) throw new Error("Nanocodex compaction retained Code Mode child tool association is incomplete");
+	const expectations = association.children.flatMap((child) => [{
+		seq: child.startSeq,
+		kind: "call",
+		child
+	}, {
+		seq: child.settleSeq,
+		kind: "result",
+		child
+	}]).sort((left, right) => left.seq - right.seq);
+	let index = projectedIndex;
+	for (const expectation of expectations) {
+		if (!(expectation.kind === "call" ? codeDispatchCallMatches(projected, index, expectation.child, evidence) : codeDispatchResultMatches(projected, index, expectation.child, evidence))) throw new Error("Nanocodex compaction retained Code Mode child tool does not match the DSH pair");
+		index += 1;
+	}
+	return index - projectedIndex;
+}
+function mergeSupplementaryContext(entries) {
+	const first = entries[0];
+	if (first === void 0 || first.item.type !== "message" || first.item.role !== "user" || first.message.role !== "user" || first.message.source.kind !== "user") return;
+	const pluginMessages = entries.slice(1).map((entry) => entry.message);
+	if (pluginMessages.some((message) => message.role !== "user" || message.source.kind !== "plugin")) return;
+	const text = pluginMessages.map((message) => plainText([message])).filter(Boolean).join("\n\n");
+	if (!text) return void 0;
+	return {
+		...first.item,
+		content: [...first.item.content, {
+			type: "input_text",
+			text
+		}]
+	};
+}
+function isRealUserHistoryItem(entry) {
+	return entry !== void 0 && entry.item.type === "message" && entry.item.role === "user" && entry.message.role === "user" && entry.message.source.kind === "user";
+}
+function isPluginUserHistoryItem(entry) {
+	return entry !== void 0 && entry.item.type === "message" && entry.item.role === "user" && entry.message.role === "user" && entry.message.source.kind === "plugin";
+}
+function supplementaryGroupEnd(projected, start) {
+	let end = start + 1;
+	while (isPluginUserHistoryItem(projected[end])) end += 1;
+	return end;
+}
+function projectedCountForContext(projected, projectedIndex, contextItem) {
+	const candidate = projected[projectedIndex];
+	if (candidate === void 0 || contextItem === void 0) return void 0;
+	if (!isRealUserHistoryItem(candidate)) return historyItemsMatch(contextItem, candidate.item) ? 1 : void 0;
+	const groupEnd = supplementaryGroupEnd(projected, projectedIndex);
+	const merged = mergeSupplementaryContext(projected.slice(projectedIndex, groupEnd));
+	if (merged !== void 0 && historyMessageMatches(contextItem, merged)) return groupEnd - projectedIndex;
+	return historyItemsMatch(contextItem, candidate.item) ? 1 : void 0;
+}
+/** The only provider-facing owner in the DSH Nanocodex package. */
+var NanocodexEngine = class {
+	ctx;
+	checkpoints;
+	quickJsPromise;
+	requestSurfaceGeneration = /* @__PURE__ */ new WeakMap();
+	runtimes = /* @__PURE__ */ new Map();
+	constructor(ctx, checkpoints) {
+		this.ctx = ctx;
+		this.checkpoints = checkpoints;
+	}
+	quickJs() {
+		this.quickJsPromise ??= (async () => {
+			const asyncQuickJsVariant = (await import("@jitl/quickjs-wasmfile-release-asyncify")).default;
+			const quickJs = await newQuickJSAsyncWASMModuleFromVariant(asyncQuickJsVariant);
+			return createQuickJsEvaluator(quickJs);
+		})();
+		return this.quickJsPromise;
+	}
+	async run(agent, previousMessages, messages, assembly, turn, step, signal, advanceStep) {
+		signal.throwIfAborted();
+		const route = await resolveNanocodexRoute(this.ctx, agent.options);
+		signal.throwIfAborted();
+		const historySeed = await buildHistorySeed(previousMessages, this.ctx, signal);
+		const preTurnSurfaceSeqs = surfacePrefix(agent.session, previousMessages.length);
+		const input = await buildPromptInput(messages.filter((message) => message.source.kind !== "plugin"), this.ctx, signal);
+		const system = renderPrompt(assembly);
+		const quickJs = await this.quickJs();
+		signal.throwIfAborted();
+		const output = new NanocodexOutput(agent, route.provider, route.model, turn, step, advanceStep);
+		let projection = Promise.resolve();
+		const active = {
+			output,
+			drain: () => projection
+		};
+		const visibleToolNames = new Set(assembly.tools.map((tool) => tool.name));
+		const toolKey = JSON.stringify(assembly.tools);
+		const key = runtimeKey(agent);
+		let runtime = this.runtimes.get(key);
+		if (runtime !== void 0 && (runtime.agent !== agent || runtime.routeKey !== routeKey(route, agent) || runtime.system !== system || runtime.toolKey !== toolKey || runtime.boundary === void 0 || !boundaryMatches(runtime.boundary, agent.session, previousMessages))) {
+			await this.closeRuntime(runtime);
+			this.runtimes.delete(key);
+			runtime = void 0;
+		}
+		if (runtime === void 0) {
+			const bridge = createToolBridge({
+				tools: this.ctx.tools,
+				agent,
+				signal,
+				customDefinitions: RAW_APPLICATION_DEFINITIONS,
+				callbacks: {
+					onCall: async ({ id, name, arguments: argumentsText, parentCallId }) => {
+						const current = runtime?.active;
+						if (current === void 0) throw new Error("Nanocodex tool call has no active DSH step");
+						await current.drain();
+						if (parentCallId !== void 0) return void 0;
+						return agent.session.append("tool/call", {
+							...current.output.coordinates,
+							callId: ToolCallId(id),
+							name,
+							arguments: argumentsText
+						}).seq;
+					},
+					onResult: async ({ id, callSeq, result }) => {
+						const current = runtime?.active;
+						if (current !== void 0) await current.drain();
+						if (callSeq !== void 0) {
+							const call = agent.session.eventAt(callSeq);
+							if (call?.type !== "tool/call") throw new Error("Nanocodex tool result has no durable call");
+							this.appendToolResult(agent, call.data.turn, call.data.step, id, callSeq, result);
+						}
+						for (const context of result.additionalContexts ?? []) agent.inject(context);
+					}
+				}
+			}).filter((tool) => visibleToolNames.has(tool.name));
+			const checkpoint = findMatchingCheckpoint(this.checkpoints, agent.session, previousMessages, route.provider, route.model);
+			runtime = {
+				agent,
+				nodeAgent: await this.createNodeAgent(agent, route, historySeed, system, bridge, quickJs, checkpoint?.snapshot),
+				provider: route.provider,
+				model: route.model,
+				routeKey: routeKey(route, agent),
+				system,
+				toolKey,
+				bridge,
+				consumedCompactionRevisions: /* @__PURE__ */ new Set()
+			};
+			this.runtimes.set(key, runtime);
+		}
+		runtime.active = active;
+		const automaticCompactions = [];
+		this.appendRequestFacts(agent, route.provider, route.model, agent.options.reasoningEffort, system, runtime.bridge);
+		const nodeAgent = runtime.nodeAgent;
+		const watcher = nodeAgent.events.watch();
+		const removeListener = watcher.onEvent((event) => {
+			projection = projection.then(async () => {
+				await output.accept(event);
+				const replaced = parseCompactionReplacedEvent(event);
+				if (replaced !== void 0 && replaced.trigger === "automatic" && this.consumeCompactionOutcome(runtime, replaced)) automaticCompactions.push({
+					outcome: replaced,
+					phase: replaced.phase,
+					afterModelCallIndex: replaced.after_model_call_index,
+					admittedSurfaceSeqs: replaced.phase === "pre_turn" ? preTurnSurfaceSeqs : [...agent.session.surface.nodes]
+				});
+			});
+			projection.catch(() => modelTurn.cancel().catch(() => void 0));
+		});
+		const removeTransportFallback = observeTransportFallback(this.ctx, String(agent.id), nodeAgent);
+		const modelTurn = nodeAgent.turn.prompt({
+			input,
+			...supplementaryContext(messages) ? { supplementaryContext: supplementaryContext(messages) } : {}
+		});
+		const abort = () => {
+			modelTurn.cancel().catch(() => void 0);
+		};
+		signal.addEventListener("abort", abort, { once: true });
+		let discardRuntime = false;
+		try {
+			await modelTurn.accepted();
+			const result = await modelTurn.result();
+			try {
+				await projection;
+				signal.throwIfAborted();
+				output.finish(result.finalMessage);
+				const snapshot = await result.snapshot();
+				return {
+					provider: route.provider,
+					model: route.model,
+					snapshot,
+					automaticCompactions
+				};
+			} finally {
+				result.dispose();
+			}
+		} catch (error) {
+			discardRuntime = true;
+			let failure = error;
+			try {
+				await projection;
+			} catch (projectionError) {
+				failure = projectionError;
+			}
+			output.interrupt(failure);
+			throw failure;
+		} finally {
+			signal.removeEventListener("abort", abort);
+			removeListener();
+			watcher.off();
+			removeTransportFallback();
+			modelTurn.dispose();
+			runtime.active = void 0;
+			if (discardRuntime) {
+				this.runtimes.delete(key);
+				await this.closeRuntime(runtime).catch(() => void 0);
+			}
+		}
+	}
+	/** Release the retained Nanocodex host after DSH has drained the Agent. */
+	async dispose(agent) {
+		const key = runtimeKey(agent);
+		const runtime = this.runtimes.get(key);
+		if (runtime === void 0) return;
+		this.runtimes.delete(key);
+		await this.closeRuntime(runtime);
+	}
+	/** Invalidate a runtime whose private context no longer matches DSH. */
+	async invalidate(agent) {
+		await this.dispose(agent);
+	}
+	/** Mark the retained runtime at the current authoritative DSH surface. */
+	markSurfaceBoundary(agent) {
+		const runtime = this.runtimes.get(runtimeKey(agent));
+		if (runtime !== void 0) runtime.boundary = makeBoundary(agent.session, agent.session.deriveMessages());
+	}
+	consumeCompactionOutcome(runtime, outcome) {
+		if (runtime.consumedCompactionRevisions.has(outcome.revision)) return false;
+		runtime.consumedCompactionRevisions.add(outcome.revision);
+		return true;
+	}
+	runtimeFor(agent) {
+		const runtime = this.runtimes.get(runtimeKey(agent));
+		if (runtime === void 0 || runtime.agent !== agent) throw new Error("Nanocodex compaction requires the agent's current live runtime");
+		return runtime;
+	}
+	/**
+	* Map Nanocodex's exact retained-tail identities to the current DSH surface.
+	* The engine owns the selection; DSH never guesses from a fixed message count.
+	*/
+	async mapCompactionOutcome(agent, outcome, signal, mapping) {
+		signal.throwIfAborted();
+		const range = outcome.replaced_history;
+		const retained = outcome.retained_tail;
+		if (range.start !== 0 || range.end <= 0 || retained.length === 0 || retained[0]?.index !== range.end || retained.some((item, index) => item.index !== range.end + index)) throw new Error("Nanocodex compaction returned a non-contiguous retained history boundary");
+		const nodes = [...agent.session.surface.nodes];
+		const messages = agent.session.deriveMessages();
+		if (nodes.length !== messages.length) throw new Error("Nanocodex compaction cannot map a DSH surface with mismatched messages");
+		const admittedSurfaceSeqs = mapping === void 0 ? void 0 : new Set(mapping.admittedSurfaceSeqs);
+		const historyProjection = await buildHistoryProjection(messages, this.ctx, signal);
+		const surfaceIndexByMessageId = new Map(messages.map((message, index) => [String(message.id), index]));
+		const projected = [];
+		for (const projectedItem of historyProjection.items) {
+			signal.throwIfAborted();
+			const surfaceIndex = surfaceIndexByMessageId.get(String(projectedItem.message.id));
+			if (surfaceIndex === void 0) continue;
+			const surfaceSeq = nodes[surfaceIndex];
+			if (surfaceSeq === void 0 || admittedSurfaceSeqs !== void 0 && !admittedSurfaceSeqs.has(surfaceSeq)) continue;
+			projected.push({
+				surfaceIndex,
+				message: projectedItem.message,
+				item: projectedItem.item
+			});
+		}
+		const contextHistory = outcome.context.history;
+		const retainedContextStart = contextHistory.length - retained.length;
+		if (retainedContextStart < 0) throw new Error("Nanocodex compaction context does not contain the retained tail");
+		const retainedContext = contextHistory.slice(retainedContextStart);
+		if (retainedContext.length !== retained.length) throw new Error("Nanocodex compaction context does not contain the retained tail");
+		const directPatchCallIds = validateRetainedApplyPatchPairs(retainedContext);
+		const surfaceCustomCallIds = new Set(projected.flatMap(({ item }) => item.type === "custom_tool_call" ? [item.call_id] : []));
+		let firstIndex = -1;
+		const firstIdentityPosition = retained.findIndex((identity, index) => {
+			const contextItem = retainedContext[index];
+			return identity.kind === "message" && contextItem?.type === "message" && contextItem.role === "user";
+		});
+		const firstIdentity = firstIdentityPosition < 0 ? void 0 : retained[firstIdentityPosition];
+		const firstContext = firstIdentityPosition < 0 ? void 0 : retainedContext[firstIdentityPosition];
+		if (firstIdentity === void 0 || firstContext === void 0 || !projectedIdentityMatches(firstIdentity, firstContext)) throw new Error("Nanocodex compaction retained tail does not begin at a real DSH user message");
+		for (let index = projected.length - 1; index >= 0; index -= 1) {
+			const candidate = projected[index];
+			if (!isRealUserHistoryItem(candidate) || !projectedIdentityMatches(firstIdentity, candidate.item)) continue;
+			if (projectedCountForContext(projected, index, firstContext) !== void 0) {
+				firstIndex = index;
+				break;
+			}
+		}
+		const first = firstIndex < 0 ? void 0 : projected[firstIndex];
+		if (first === void 0 || !projectedIdentityMatches(firstIdentity, first.item) || first.surfaceIndex === 0 || !isRealUserHistoryItem(first)) throw new Error("Nanocodex compaction retained tail does not begin at a real DSH user message");
+		const codeDispatches = codeDispatchAssociations(agent.session);
+		const toolEvidence = dshToolEvidence(agent.session);
+		let projectedIndex = firstIndex;
+		let pendingCustomCallId;
+		for (let retainedPosition = 0; retainedPosition < retained.length; retainedPosition += 1) {
+			const identity = retained[retainedPosition];
+			const contextItem = retainedContext[retainedPosition];
+			const contextCallId = "call_id" in contextItem ? contextItem.call_id : void 0;
+			const surfaceCustom = contextCallId !== void 0 && (directPatchCallIds.has(contextCallId) || surfaceCustomCallIds.has(contextCallId));
+			const dshBacked = identity.kind === "message" || identity.kind === "function_call" || identity.kind === "function_call_output" || surfaceCustom;
+			const engineTool = !surfaceCustom && (identity.kind === "custom_tool_call" || identity.kind === "custom_tool_call_output");
+			if (!dshBacked && !engineTool) {
+				if (pendingCustomCallId !== void 0) throw new Error("Nanocodex compaction retained Code Mode tool pair is incomplete");
+				continue;
+			}
+			if (!projectedIdentityMatches(identity, retainedContext[retainedPosition])) throw new Error("Nanocodex compaction retained history does not match its public context");
+			if (engineTool) {
+				if (identity.kind === "custom_tool_call") {
+					if (pendingCustomCallId !== void 0) throw new Error("Nanocodex compaction retained Code Mode tool pair is incomplete");
+					if (typeof identity.call_id === "string") {
+						const association = codeDispatches.get(identity.call_id);
+						if (association !== void 0) projectedIndex += codeDispatchProjectedCount(projected, projectedIndex, association, toolEvidence);
+					}
+					pendingCustomCallId = identity.call_id;
+					continue;
+				}
+				if (pendingCustomCallId !== identity.call_id) throw new Error("Nanocodex compaction retained Code Mode tool pair is incomplete");
+				pendingCustomCallId = void 0;
+				continue;
+			}
+			if (pendingCustomCallId !== void 0) throw new Error("Nanocodex compaction retained Code Mode tool pair is incomplete");
+			const candidate = projected[projectedIndex];
+			const projectedCount = candidate === void 0 ? void 0 : projectedCountForContext(projected, projectedIndex, retainedContext[retainedPosition]);
+			if (candidate === void 0 || !projectedIdentityMatches(identity, candidate.item)) throw new Error("Nanocodex compaction retained history order does not match the active DSH surface");
+			if (candidate.surfaceIndex < first.surfaceIndex) throw new Error("Nanocodex compaction retained tail reaches before its DSH user boundary");
+			if (projectedCount === void 0) throw new Error("Nanocodex compaction retained history order does not match the active DSH surface");
+			projectedIndex += projectedCount;
+		}
+		if (pendingCustomCallId !== void 0) throw new Error("Nanocodex compaction retained Code Mode tool pair is incomplete");
+		if (projectedIndex !== projected.length) throw new Error("Nanocodex compaction retained tail omits an active DSH history item");
+		const start = nodes[0];
+		const end = nodes[first.surfaceIndex - 1];
+		if (start === void 0 || end === void 0 || !toolPairingBalancedBefore(agent.session, start) || !toolPairingBalancedAfter(agent.session, end)) throw new Error("Nanocodex compaction retained boundary splits a DSH tool exchange");
+		return {
+			shadowedRange: {
+				start,
+				end
+			},
+			shadowedSeqs: nodes.slice(0, first.surfaceIndex)
+		};
+	}
+	async resolveCompactionInstruction(agent, route, _context, signal) {
+		signal.throwIfAborted();
+		const sessionId = String(agent.session.id);
+		const options = {
+			provider: route.provider,
+			model: route.model,
+			messages: [createUserMessage({
+				content: [{
+					type: "text",
+					text: DEFAULT_COMPACTION_INSTRUCTION
+				}],
+				source: {
+					kind: "plugin",
+					plugin: "dsh-compaction-basic"
+				}
+			})],
+			...agent.options.reasoningEffort === void 0 ? {} : { reasoningEffort: agent.options.reasoningEffort },
+			sessionId,
+			purpose: "compaction",
+			signal
+		};
+		const stream = agent.ctx.waterfall(agent.ctx.llm, "llm/stream", options, emptyLlmStream);
+		for await (const _chunk of stream) signal.throwIfAborted();
+		signal.throwIfAborted();
+		const instruction = plainText(options.messages).trim();
+		if (!instruction) throw new Error("Nanocodex compaction instruction is empty");
+		return instruction;
+	}
+	/** Persist the exact successful engine snapshot at the current DSH surface. */
+	async persistCheckpoint(agent, provider, model, snapshot, signal) {
+		signal.throwIfAborted();
+		const session = agent.session;
+		const boundary = makeBoundary(session, session.deriveMessages());
+		const checkpoint = {
+			version: 1,
+			provider,
+			model,
+			boundary,
+			snapshot
+		};
+		await this.checkpoints.put(session.id, checkpoint);
+		const context = {
+			provider,
+			model,
+			contextWindow: MODEL_CONTEXT_WINDOW
+		};
+		session.append("request/context", context);
+		await this.ctx.sessions.flush(session);
+		const runtime = this.runtimes.get(runtimeKey(agent));
+		if (runtime !== void 0) runtime.boundary = boundary;
+	}
+	async createNodeAgent(agent, route, historySeed, system, bridge, quickJs, resume) {
+		const base = {
+			transport: Transport.openAi({
+				apiKey: route.apiKey,
+				...route.apiBaseUrl ? { apiBaseUrl: route.apiBaseUrl } : {},
+				...route.websocketUrl ? { websocketUrl: route.websocketUrl } : {},
+				websocketWarmup: true
+			}),
+			model: route.model,
+			...route.thinking ? { thinking: route.thinking } : {},
+			...agent.options.reasoningEffort === "pro" ? { reasoningMode: "pro" } : {},
+			sessionId: normalizeNanocodexSessionId(String(agent.id)),
+			...system ? { additionalInstructions: system } : {},
+			resolveCompactionInstruction: (context, signal) => this.resolveCompactionInstruction(agent, route, context, signal),
+			codeEvaluator: quickJs,
+			tools: bridge,
+			subagents: false,
+			toolMode: "code"
+		};
+		if (resume !== void 0) try {
+			return await Agent.create({
+				...base,
+				resume
+			});
+		} catch {}
+		return Agent.create({
+			...base,
+			...historySeed.history.length > 0 || historySeed.continuitySummary !== void 0 ? { historySeed } : {}
+		});
+	}
+	async closeRuntime(runtime) {
+		await runtime.nodeAgent.session.shutdown().catch(() => void 0);
+		runtime.nodeAgent.dispose();
+	}
+	/** Run custom compaction on the already-live Nanocodex runtime. */
+	async compact(agent, signal) {
+		signal.throwIfAborted();
+		const runtime = this.runtimeFor(agent);
+		const watcher = runtime.nodeAgent.events.watch();
+		let eventOutcome;
+		let installed = false;
+		let succeeded = false;
+		const removeListener = watcher.onEvent((event) => {
+			const replaced = parseCompactionReplacedEvent(event);
+			if (replaced === void 0 || replaced.trigger !== "manual") return;
+			installed = true;
+			if (this.consumeCompactionOutcome(runtime, replaced)) eventOutcome = replaced;
+		});
+		const removeTransportFallback = observeTransportFallback(this.ctx, String(agent.id), runtime.nodeAgent);
+		let shutdownRequested = false;
+		const abort = () => {
+			shutdownRequested = true;
+			runtime.nodeAgent.session.shutdown().catch(() => void 0);
+		};
+		signal.addEventListener("abort", abort, { once: true });
+		try {
+			signal.throwIfAborted();
+			const returned = await runtime.nodeAgent.session.compact();
+			signal.throwIfAborted();
+			if (returned === null) throw new Error("Nanocodex manual compaction did not produce one matching replacement event");
+			const snapshot = await runtime.nodeAgent.session.snapshot();
+			signal.throwIfAborted();
+			if (eventOutcome === void 0 || returned.revision !== eventOutcome.revision) throw new Error("Nanocodex manual compaction did not produce one matching replacement event");
+			const summary = returned.summary?.trim();
+			if (!summary) throw new Error("Nanocodex compaction returned no summary text");
+			const selection = await this.mapCompactionOutcome(agent, returned, signal);
+			succeeded = true;
+			return {
+				summary,
+				outcome: returned,
+				selection,
+				snapshot,
+				provider: runtime.provider,
+				model: runtime.model
+			};
+		} finally {
+			signal.removeEventListener("abort", abort);
+			removeListener();
+			watcher.off();
+			removeTransportFallback();
+			if (shutdownRequested || installed && !succeeded) await this.invalidate(agent).catch(() => void 0);
+		}
+	}
+	appendRequestFacts(agent, provider, model, reasoningEffort, system, bridge) {
+		const tools = bridge.map((tool) => ({
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.parameters ?? {
+				type: "object",
+				properties: {},
+				additionalProperties: false
+			}
+		}));
+		const header = canonicalHeader({
+			config: {
+				provider,
+				model,
+				...reasoningEffort === void 0 ? {} : { reasoningEffort }
+			},
+			...system ? { system } : {},
+			...tools.length > 0 ? { tools } : {}
+		});
+		const session = agent.session;
+		const baseline = session.requestHeader();
+		const hasLiveHeader = session.snapshotEvents(session.firstLiveSeq).some((event) => event.type === "request/header");
+		const previousGeneration = this.requestSurfaceGeneration.get(session);
+		const startsSeries = previousGeneration !== void 0 && previousGeneration !== session.surface.replaceGeneration;
+		if (!hasLiveHeader) session.append("request/header", {
+			header,
+			reason: baseline === void 0 ? "initial" : "resume"
+		});
+		else if (baseline === void 0 || !headerEquals(baseline, header)) session.append("request/header", {
+			header,
+			reason: "change",
+			...startsSeries ? { startsSeries: true } : {}
+		});
+		else if (startsSeries) session.append("request/header", {
+			header,
+			reason: "series"
+		});
+		this.requestSurfaceGeneration.set(session, session.surface.replaceGeneration);
+		const requestContext = {
+			provider,
+			model,
+			contextWindow: MODEL_CONTEXT_WINDOW
+		};
+		const previousContext = session.requestContext();
+		if (previousContext?.provider !== requestContext.provider || previousContext.model !== requestContext.model || previousContext.contextWindow !== requestContext.contextWindow) session.append("request/context", requestContext);
+	}
+	appendToolResult(agent, turn, step, id, callSeq, result) {
+		const message = createToolResultMessage({
+			callId: ToolCallId(id),
+			content: result.content,
+			isError: result.isError
+		});
+		agent.session.append("tool/result", {
+			turn,
+			step,
+			message,
+			...result.error?.info ? { error: result.error.info } : {},
+			...result.meta !== void 0 ? { meta: result.meta } : {}
+		}, {
+			surfaceOp: "append",
+			sourceEventSeqs: [callSeq]
+		});
+	}
+};
+//#endregion
+//#region src/compaction-engine.ts
+function errorText(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function supportedPrefix(session) {
+	const nodes = [...session.surface.nodes];
+	const messages = session.deriveMessages();
+	if (nodes.length !== messages.length) throw new Error("Nanocodex compaction cannot select a mismatched DSH surface");
+	let retainedIndex = -1;
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const message = messages[index];
+		if (message?.role === "user" && message.source.kind === "user") {
+			retainedIndex = index;
+			break;
+		}
+	}
+	if (retainedIndex <= 0) return null;
+	const start = nodes[0];
+	const end = nodes[retainedIndex - 1];
+	if (start === void 0 || end === void 0 || !toolPairingBalancedBefore(session, start) || !toolPairingBalancedAfter(session, end)) throw new Error("Nanocodex compaction prefix would split a DSH tool exchange");
+	return {
+		start,
+		end,
+		shadowedSeqs: nodes.slice(0, retainedIndex)
+	};
+}
+function sameSelection(left, right) {
+	return left.start === right.shadowedRange.start && left.end === right.shadowedRange.end && left.shadowedSeqs.length === right.shadowedSeqs.length && left.shadowedSeqs.every((seq, index) => right.shadowedSeqs[index] === seq);
+}
+function openTurn(session) {
+	let turn = null;
+	for (const event of session.snapshotEvents()) {
+		if (event.type === "turn/start") turn = event.data.turn;
+		if (event.type === "turn/end" && turn === event.data.turn) turn = null;
+	}
+	return turn;
+}
+/**
+* Minimal DSH compaction owner. The checkpoint is model-private and lands only
+* as the normal non-expandable compact checkpoint message. The selected range
+* and all transaction markers remain fully durable in DSH's event log.
+*/
+var NanocodexCompactionEngine = class extends CompactionEngine {
+	engine;
+	constructor(ctx, engine) {
+		super(ctx);
+		this.engine = engine;
+	}
+	async compactIfNeeded(agent, _trigger, signal) {
+		signal.throwIfAborted();
+		return null;
+	}
+	async compactNow(agent, signal, sourceCommandId) {
+		signal.throwIfAborted();
+		let cancelled = false;
+		let cancellationReason;
+		try {
+			return await agent.runMaintenance(async (agentSignal) => {
+				const operationSignal = AbortSignal.any([agentSignal, signal]);
+				operationSignal.throwIfAborted();
+				const selection = supportedPrefix(agent.session);
+				if (selection === null) return null;
+				let committed = false;
+				try {
+					const result = await this.compactSelection(agent, selection, operationSignal, sourceCommandId);
+					committed = true;
+					await this.ctx.sessions.flush(agent.session);
+					return result;
+				} catch (error) {
+					if (committed) await this.engine.invalidate(agent).catch(() => void 0);
+					if (operationSignal.aborted) {
+						cancelled = true;
+						cancellationReason = operationSignal.reason;
+						throw operationSignal.reason;
+					}
+					throw new ManualCompactionError("summary", "Nanocodex could not create a continuity checkpoint", { cause: error });
+				}
+			});
+		} catch (error) {
+			if (cancelled || signal.aborted) throw cancellationReason ?? signal.reason;
+			if (error instanceof ManualCompactionError) throw error;
+			throw new ManualCompactionError("busy", "manual compaction requires an idle agent", { cause: error });
+		}
+	}
+	async compactRegion(start, end, agent, signal = new AbortController().signal) {
+		const maintenanceAgent = agent;
+		if (typeof maintenanceAgent.runMaintenance !== "function") throw new ManualCompactionError("busy", "region compaction requires an idle agent maintenance boundary");
+		const initialNodes = [...agent.session.surface.nodes];
+		const initialStartIndex = initialNodes.indexOf(start);
+		const initialEndIndex = initialNodes.indexOf(end);
+		const initialSupported = supportedPrefix(agent.session);
+		if (initialStartIndex < 0 || initialEndIndex < initialStartIndex || initialSupported === null || initialSupported.start !== start || initialSupported.end !== end || initialSupported.shadowedSeqs.length !== initialEndIndex - initialStartIndex + 1 || initialSupported.shadowedSeqs.some((seq, index) => initialNodes[initialStartIndex + index] !== seq)) throw new ManualCompactionError("changed", "Nanocodex compactRegion only supports the current prefix before the latest real user tail");
+		let cancelled = false;
+		let cancellationReason;
+		try {
+			return await maintenanceAgent.runMaintenance(async (agentSignal) => {
+				const operationSignal = AbortSignal.any([agentSignal, signal]);
+				operationSignal.throwIfAborted();
+				const nodes = [...agent.session.surface.nodes];
+				const startIndex = nodes.indexOf(start);
+				const endIndex = nodes.indexOf(end);
+				if (startIndex < 0 || endIndex < 0 || startIndex > endIndex) throw new Error("Nanocodex compaction range is not a current surface span");
+				const supported = supportedPrefix(agent.session);
+				if (supported === null || supported.start !== start || supported.end !== end || supported.shadowedSeqs.length !== endIndex - startIndex + 1 || supported.shadowedSeqs.some((seq, index) => nodes[startIndex + index] !== seq)) throw new ManualCompactionError("changed", "Nanocodex compactRegion only supports the current prefix before the latest real user tail");
+				let committed = false;
+				try {
+					const result = await this.compactSelection(agent, {
+						start,
+						end,
+						shadowedSeqs: nodes.slice(startIndex, endIndex + 1)
+					}, operationSignal);
+					committed = true;
+					await this.ctx.sessions.flush(agent.session);
+					return result;
+				} catch (error) {
+					if (committed) await this.engine.invalidate(agent).catch(() => void 0);
+					if (operationSignal.aborted) {
+						cancelled = true;
+						cancellationReason = operationSignal.reason;
+						throw operationSignal.reason;
+					}
+					throw error;
+				}
+			});
+		} catch (error) {
+			if (cancelled || signal.aborted) throw cancellationReason ?? signal.reason;
+			if (error instanceof ManualCompactionError) throw error;
+			throw new ManualCompactionError("summary", "Nanocodex could not create a continuity checkpoint", { cause: error });
+		}
+	}
+	/**
+	* Commit a summary produced by Nanocodex's automatic private compaction.
+	* Nanocodex owns the model call; DSH still owns the durable surface and the
+	* non-expandable checkpoint visible to Companion.
+	*/
+	async commitAutomaticSummary(agent, automatic, signal) {
+		signal.throwIfAborted();
+		const summary = automatic.outcome.summary?.trim() ?? "";
+		if (!summary) {
+			await this.engine.invalidate(agent).catch(() => void 0);
+			throw new Error("Nanocodex automatic compaction returned an empty summary");
+		}
+		let selection;
+		try {
+			selection = await this.engine.mapCompactionOutcome(agent, automatic.outcome, signal, automatic);
+		} catch (error) {
+			await this.engine.invalidate(agent).catch(() => void 0);
+			throw error;
+		}
+		const attempt = this.beginCompaction(agent);
+		let committed = false;
+		try {
+			const result = this.commitSummary(agent, {
+				start: selection.shadowedRange.start,
+				end: selection.shadowedRange.end,
+				shadowedSeqs: [...selection.shadowedSeqs]
+			}, [{
+				type: "text",
+				text: summary
+			}], signal, attempt);
+			committed = true;
+			return result;
+		} catch (error) {
+			this.endFailedCompaction(agent, attempt, error);
+			await this.engine.invalidate(agent).catch(() => void 0);
+			throw error;
+		} finally {
+			if (committed) this.engine.markSurfaceBoundary(agent);
+		}
+	}
+	async compactSelection(agent, selection, signal, sourceCommandId) {
+		signal.throwIfAborted();
+		const attempt = this.beginCompaction(agent, sourceCommandId);
+		let generated = false;
+		try {
+			const result = await this.engine.compact(agent, signal);
+			generated = true;
+			if (!sameSelection(selection, result.selection)) throw new ManualCompactionError("changed", "Nanocodex compacted a different DSH prefix than the requested range");
+			const committed = this.commitSummary(agent, selection, [{
+				type: "text",
+				text: result.summary
+			}], signal, attempt);
+			this.engine.markSurfaceBoundary(agent);
+			await this.engine.persistCheckpoint(agent, result.provider, result.model, result.snapshot, signal);
+			return committed;
+		} catch (error) {
+			this.endFailedCompaction(agent, attempt, error);
+			if (generated) await this.engine.invalidate(agent).catch(() => void 0);
+			throw error;
+		}
+	}
+	beginCompaction(agent, sourceCommandId) {
+		const lifecycle = {
+			compactionId: CompactionId(randomUUID()),
+			...sourceCommandId === void 0 ? {} : { sourceCommandId },
+			turn: openTurn(agent.session)
+		};
+		const startEvent = agent.session.append("compaction/start", lifecycle);
+		return {
+			...lifecycle,
+			startSeq: startEvent.seq,
+			ended: false
+		};
+	}
+	endFailedCompaction(agent, attempt, error) {
+		if (attempt.ended) return;
+		try {
+			agent.session.append("compaction/end", {
+				compactionId: attempt.compactionId,
+				...attempt.sourceCommandId === void 0 ? {} : { sourceCommandId: attempt.sourceCommandId },
+				turn: attempt.turn,
+				error: errorText(error)
+			});
+		} catch {} finally {
+			attempt.ended = true;
+		}
+	}
+	commitSummary(agent, selection, summary, signal, attempt) {
+		signal.throwIfAborted();
+		const provider = agent.options.provider;
+		const model = agent.options.model;
+		if (!provider || !model) throw new Error("Nanocodex compaction requires an explicit provider/model");
+		signal.throwIfAborted();
+		const summaryEvent = agent.session.append("compaction/summary", {
+			compactionId: attempt.compactionId,
+			...attempt.sourceCommandId === void 0 ? {} : { sourceCommandId: attempt.sourceCommandId },
+			summary,
+			rawOutput: summary,
+			shadowedRange: {
+				start: selection.start,
+				end: selection.end
+			},
+			shadowedSeqs: selection.shadowedSeqs,
+			shadowedTokenCount: Math.max(1, Math.ceil(textOfBlocks(summary).length / 4)),
+			provider,
+			model
+		});
+		const checkpoint = createUserMessage({
+			content: summary,
+			source: compactCheckpointSource(attempt.compactionId, attempt.sourceCommandId)
+		});
+		agent.session.append("user/message", checkpoint, {
+			surfaceOp: {
+				op: "replace",
+				start: selection.start,
+				end: selection.end
+			},
+			sourceEventSeqs: [
+				attempt.startSeq,
+				summaryEvent.seq,
+				...selection.shadowedSeqs
+			]
+		});
+		const endEvent = agent.session.append("compaction/end", {
+			compactionId: attempt.compactionId,
+			...attempt.sourceCommandId === void 0 ? {} : { sourceCommandId: attempt.sourceCommandId },
+			turn: attempt.turn
+		});
+		attempt.ended = true;
+		const shadowedTokenCount = Math.max(1, Math.ceil(textOfBlocks(summary).length / 4));
+		return {
+			compactionId: attempt.compactionId,
+			...attempt.sourceCommandId === void 0 ? {} : { sourceCommandId: attempt.sourceCommandId },
+			startSeq: attempt.startSeq,
+			summarySeq: summaryEvent.seq,
+			endSeq: endEvent.seq,
+			summary,
+			shadowedRange: {
+				start: selection.start,
+				end: selection.end
+			},
+			shadowedSeqs: [...selection.shadowedSeqs],
+			shadowedTokenCount
+		};
+	}
+};
+function textOfBlocks(blocks) {
+	return blocks.flatMap((block) => block.type === "text" ? [block.text] : []).join("\n");
+}
+//#endregion
+//#region src/agent.ts
+const RUNTIME_CONTEXT_SOURCE = "@deepseek-ai/dsh-system-prompt";
+const CLEARED_RUNTIME_CONTEXT = "Current runtime context: none. Earlier runtime-context snapshots no longer apply.";
+function deferred() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((resolvePromise, rejectPromise) => {
+			resolve = resolvePromise;
+			reject = rejectPromise;
+		}),
+		resolve,
+		reject
+	};
+}
+function lastTurn(session) {
+	let result = 0;
+	for (const event of session.snapshotEvents()) if (event.type === "turn/start") result = Math.max(result, event.data.turn);
+	return result;
+}
+function cancelCause(signal) {
+	const reason = signal.reason;
+	if (reason && typeof reason === "object" && "kind" in reason && (reason.kind === "user" || reason.kind === "parent" || reason.kind === "disposed" || reason.kind === "hook")) return reason;
+	return {
+		kind: "hook",
+		reason: reason instanceof Error ? reason.message : String(reason ?? "aborted")
+	};
+}
+function errorInfo(error) {
+	return {
+		message: error instanceof Error ? error.message : String(error),
+		code: "UNKNOWN"
+	};
+}
+/**
+* DSH's public Agent handle backed by Nanocodex turns. DSH owns the queue and
+* durable log; each model step is hydrated from the active surface.
+*/
+var NanocodexAgent = class {
+	id;
+	options;
+	session;
+	inbox;
+	ctx;
+	loopCtx;
+	engine;
+	scope;
+	dispatch;
+	phase;
+	activityDone = Promise.resolve();
+	runtimeContextText;
+	constructor(loopCtx, id, options, session, engine) {
+		this.loopCtx = loopCtx;
+		this.id = id;
+		this.options = options;
+		this.session = session;
+		closeInterruptedToolCalls(session);
+		this.engine = engine;
+		this.dispatch = agentEvents(loopCtx, this);
+		this.inbox = new Inbox(session, {
+			inserted: (message) => this.dispatch.emit("agent/inbox/inserted", { message }),
+			discarded: (message) => this.dispatch.emit("agent/inbox/discarded", { message }),
+			claimed: (message, turn) => this.dispatch.emit("agent/inbox/claimed", {
+				message,
+				turn
+			})
+		});
+		this.scope = createScope(loopCtx, this);
+		this.ctx = this.scope.ctx.extend({ agent: this });
+		this.phase = {
+			kind: "idle",
+			lastTurn: lastTurn(session)
+		};
+		this.runtimeContextText = this.findRuntimeContext();
+	}
+	get status() {
+		return this.phase.kind === "running" ? "running" : "idle";
+	}
+	send(message, target, wakeup) {
+		const wakingAfterAbort = wakeup && this.phase.kind !== "idle" && this.phase.abort.signal.aborted;
+		this.inbox.splice(wakingAfterAbort ? "next-turn" : target, Infinity, 0, [message]);
+		if (wakeup) this.wakeDriver(wakingAfterAbort);
+	}
+	followup(message) {
+		this.send(message, "next-turn", true);
+	}
+	steer(message) {
+		this.send(message, "next-step", true);
+	}
+	inject(message) {
+		this.send(message, "next-step", false);
+	}
+	cancel(cause, options = {}) {
+		if (!options.keepInbox) {
+			this.inbox.clear();
+			if (this.phase.kind !== "idle") this.phase.wakeRequested = false;
+		} else if (this.phase.kind !== "idle" && this.inbox.hasPending) this.phase.wakeRequested = true;
+		if (this.phase.kind !== "idle") this.phase.abort.abort(cause);
+	}
+	whenIdle() {
+		return this.waitForIdle();
+	}
+	async waitForIdle() {
+		let observed;
+		do {
+			observed = this.activityDone;
+			await observed;
+		} while (observed !== this.activityDone);
+	}
+	runMaintenance(task) {
+		if (this.phase.kind !== "idle") throw new Error(`agent "${String(this.id)}" already has active work`);
+		const done = deferred();
+		const maintenance = {
+			kind: "maintenance",
+			abort: new AbortController(),
+			lastTurn: this.phase.lastTurn,
+			wakeRequested: false
+		};
+		this.phase = maintenance;
+		this.activityDone = done.promise;
+		return (async () => {
+			try {
+				return await task(maintenance.abort.signal);
+			} finally {
+				this.phase = {
+					kind: "idle",
+					lastTurn: maintenance.lastTurn
+				};
+				if (maintenance.wakeRequested && this.inbox.hasPending) this.wakeDriver();
+				done.resolve();
+			}
+		})();
+	}
+	wakeDriver(wakeAfterAbort = false) {
+		if (this.phase.kind !== "idle") {
+			if (this.phase.abort.signal.reason?.kind !== "disposed" && (this.phase.kind === "maintenance" || wakeAfterAbort)) this.phase.wakeRequested = true;
+			return;
+		}
+		const done = deferred();
+		const running = {
+			kind: "running",
+			abort: new AbortController(),
+			turn: this.phase.lastTurn,
+			step: 0,
+			wakeRequested: false
+		};
+		this.phase = running;
+		this.activityDone = done.promise;
+		this.dispatch.emit("agent/status", { status: "running" });
+		this.loopCtx.agents.withInitiator(this, () => this.kick()).then(() => done.resolve(), (error) => {
+			this.dispatch.emit("agent/error", {
+				turn: running.turn,
+				step: running.step,
+				error
+			});
+			done.resolve();
+		});
+	}
+	async dispose() {
+		this.cancel({ kind: "disposed" });
+		await this.waitForIdle();
+		await this.engine.dispose(this);
+		await this.scope.dispose();
+	}
+	async kick() {
+		try {
+			while (await this.turn());
+		} catch (error) {
+			const phase = this.phase;
+			this.dispatch.emit("agent/error", {
+				turn: phase.kind === "running" ? phase.turn : phase.lastTurn,
+				step: phase.kind === "running" ? phase.step : 0,
+				error
+			});
+		} finally {
+			if (this.phase.kind === "running") {
+				const { turn, wakeRequested } = this.phase;
+				this.phase = {
+					kind: "idle",
+					lastTurn: turn
+				};
+				this.dispatch.emit("agent/status", { status: "idle" });
+				if (wakeRequested && this.inbox.hasPending) this.wakeDriver();
+			}
+		}
+	}
+	async preStep(target, turn, step) {
+		if (this.phase.kind !== "running") throw new Error("pre-step outside running phase");
+		const signal = this.phase.abort.signal;
+		const claimed = this.inbox.claim(target, turn);
+		const assembly = await this.loopCtx.systemPrompt.assemble(assembleContextFor(this, signal));
+		signal.throwIfAborted();
+		const sections = renderContextSections(assembly);
+		this.runtimeContextText = this.findRuntimeContext();
+		const runtime = this.projectRuntimeContext(joinContextSections(sections), sections);
+		const decision = await this.dispatch.waterfall("agent/pre-step", {
+			messages: claimed,
+			turn,
+			step,
+			signal
+		}, () => Promise.resolve({
+			kind: "enter",
+			messages: runtime === void 0 ? claimed : [...claimed, runtime]
+		}));
+		signal.throwIfAborted();
+		return decision.kind === "reject" ? { decision } : {
+			decision,
+			assembly
+		};
+	}
+	async turn() {
+		if (this.phase.kind !== "running") throw new Error("turn without driver reservation");
+		const phase = this.phase;
+		const signal = phase.abort.signal;
+		signal.throwIfAborted();
+		const turn = phase.turn + 1;
+		phase.turn = turn;
+		this.session.append("turn/start", { turn });
+		let reason = { kind: "completed" };
+		let target = "next-turn";
+		try {
+			while (true) {
+				signal.throwIfAborted();
+				const step = phase.step + 1;
+				const prepared = await this.preStep(target, turn, step);
+				if (prepared.decision.kind === "reject") {
+					reason = { kind: "blocked" };
+					break;
+				}
+				const messages = prepared.decision.messages;
+				if (phase.step === 0 && messages.length === 0) break;
+				signal.throwIfAborted();
+				const previousMessages = this.session.deriveMessages();
+				this.session.append("step/start", {
+					turn,
+					step
+				});
+				phase.step = step;
+				try {
+					for (const message of messages) this.session.append("user/message", message, { surfaceOp: "append" });
+					const engineResult = await this.engine.run(this, previousMessages, messages, prepared.assembly, turn, step, signal, () => {
+						this.session.append("step/end", {
+							turn,
+							step: phase.step
+						});
+						phase.step += 1;
+						this.session.append("step/start", {
+							turn,
+							step: phase.step
+						});
+						return phase.step;
+					});
+					if (engineResult.automaticCompactions.length > 0) {
+						const compaction = this.loopCtx.compaction;
+						if (compaction === void 0 || typeof compaction.commitAutomaticSummary !== "function") throw new Error("Nanocodex automatic compaction has no DSH compaction owner");
+						for (const automatic of engineResult.automaticCompactions) await compaction.commitAutomaticSummary(this, automatic, signal);
+					}
+					try {
+						await this.engine.persistCheckpoint(this, engineResult.provider, engineResult.model, engineResult.snapshot, signal);
+					} catch (error) {
+						await this.engine.invalidate(this).catch(() => void 0);
+						throw error;
+					}
+				} finally {
+					this.session.append("step/end", {
+						turn,
+						step: phase.step
+					});
+				}
+				reason = { kind: "completed" };
+				signal.throwIfAborted();
+				if (this.inbox.nextStep.length === 0) {
+					await this.dispatch.serial("agent/turn-stopping", {
+						turn,
+						signal
+					});
+					signal.throwIfAborted();
+				}
+				if (this.inbox.nextStep.length === 0) break;
+				target = "next-step";
+			}
+		} catch (error) {
+			if (signal.aborted) reason = {
+				kind: "aborted",
+				reason: cancelCause(signal)
+			};
+			else {
+				reason = {
+					kind: "error",
+					error: errorInfo(error)
+				};
+				this.dispatch.emit("agent/error", {
+					turn,
+					step: phase.step,
+					error
+				});
+			}
+		} finally {
+			this.session.append("turn/end", {
+				turn,
+				reason
+			});
+		}
+		if (!signal.aborted && reason.kind === "completed" && this.inbox.hasPending) {
+			phase.abort = new AbortController();
+			phase.step = 0;
+			phase.wakeRequested = false;
+			return true;
+		}
+		return false;
+	}
+	findRuntimeContext() {
+		for (const message of this.session.deriveMessages().reverse()) if (message.source.kind === "plugin" && message.source.plugin === RUNTIME_CONTEXT_SOURCE && message.content.length === 1 && message.content[0]?.type === "text") return message.content[0].text;
+	}
+	projectRuntimeContext(current, sections) {
+		if (this.runtimeContextText === void 0 && current.length === 0) return void 0;
+		const next = current.length === 0 ? CLEARED_RUNTIME_CONTEXT : current;
+		if (this.runtimeContextText === next) return void 0;
+		this.runtimeContextText = next;
+		return createUserMessage({
+			content: [{
+				type: "text",
+				text: next
+			}],
+			source: sections.length === 0 ? {
+				kind: "plugin",
+				plugin: RUNTIME_CONTEXT_SOURCE
+			} : {
+				kind: "plugin",
+				plugin: RUNTIME_CONTEXT_SOURCE,
+				form: "snapshot",
+				sections
+			}
+		});
+	}
+};
+//#endregion
+//#region src/factory.ts
+/** AgentFactory implementation installed by the selected Cordis row. */
+var NanocodexFactory = class {
+	ctx;
+	engine;
+	live = /* @__PURE__ */ new Set();
+	closed = false;
+	constructor(ctx, engine) {
+		this.ctx = ctx;
+		this.engine = engine;
+	}
+	async createAgent(ownerCtx, options) {
+		const preparation = SessionPreparation.create(this.ctx.sessions.prepare(options.sessionId, {
+			...options.seed === void 0 ? {} : { seed: options.seed },
+			...options.meta === void 0 ? {} : { meta: options.meta },
+			...options.inheritedEventCount === void 0 ? {} : { inheritedEventCount: options.inheritedEventCount }
+		}));
+		try {
+			return await this.publish(ownerCtx, preparation, options.agentOptions ?? {}, options.setup, options.signal, "startup");
+		} finally {
+			preparation[Symbol.dispose]();
+		}
+	}
+	async resume(ownerCtx, options) {
+		const persistence = this.ctx.get("sessionPersistence");
+		if (persistence === void 0) throw new Error("cannot resume Nanocodex: dsh-session-persistence is not configured");
+		const preparation = await persistence.prepare(options.resumeSessionId, options.signal);
+		try {
+			return await this.publish(ownerCtx, preparation, options.agentOptions ?? {}, options.setup, options.signal, "resume");
+		} finally {
+			preparation[Symbol.dispose]();
+		}
+	}
+	async disposeAll() {
+		this.closed = true;
+		await Promise.all([...this.live].map((entry) => entry.dispose()));
+	}
+	async publish(ownerCtx, preparation, options, setup, callerSignal, source) {
+		if (this.closed) throw new Error("Nanocodex factory is no longer active");
+		const agent = new NanocodexAgent(this.ctx, preparation.session.id, options ?? {}, preparation.session, this.engine);
+		let detachSession;
+		let detachAgent;
+		let disposed;
+		const dispose = () => {
+			disposed ??= (async () => {
+				agent.cancel({ kind: "disposed" });
+				await agent.whenIdle();
+				detachAgent?.();
+				detachSession?.();
+				await agent.dispose();
+				this.live.delete(entry);
+			})();
+			return disposed;
+		};
+		const entry = {
+			agent,
+			dispose
+		};
+		this.live.add(entry);
+		ownerCtx.effect(() => () => dispose(), `dsh-nanocodex.lifecycle(${String(agent.id)})`);
+		try {
+			if (callerSignal?.aborted) throw callerSignal.reason;
+			const commit = await setup?.(agent.ctx);
+			apply$1(agent.ctx);
+			if (commit) commit.commit();
+			if (callerSignal?.aborted) throw callerSignal.reason;
+			detachSession = agent.ctx.sessions.enter(preparation.session);
+			detachAgent = this.ctx.agents.enter(agent, ownerCtx.agent);
+			agent.ctx.sessions.announce(preparation.session);
+			this.ctx.agents.announce(agent);
+			emitAgentEvent(this.ctx, agent, "agent/session-start", { source });
+			return {
+				agent,
+				dispose
+			};
+		} catch (error) {
+			await dispose();
+			throw error;
+		}
+	}
+};
+//#endregion
+//#region src/llm-adapter.ts
+const REASONING_EFFORTS = [
+	["none", "None"],
+	["low", "Low"],
+	["medium", "Medium"],
+	["high", "High"],
+	["xhigh", "Extra high"],
+	["max", "Maximum"],
+	["pro", "Pro"]
+];
+function usage(value) {
+	return {
+		inputTokens: value.input_tokens,
+		outputTokens: value.output_tokens,
+		...Number.isFinite(value.total_tokens) ? { totalTokens: value.total_tokens } : {},
+		...Number.isFinite(value.cached_input_tokens) && value.cached_input_tokens > 0 ? { cacheReadTokens: value.cached_input_tokens } : {},
+		...Number.isFinite(value.cache_write_input_tokens) && value.cache_write_input_tokens > 0 ? { cacheWriteTokens: value.cache_write_input_tokens } : {},
+		...Number.isFinite(value.reasoning_output_tokens) && value.reasoning_output_tokens > 0 ? { reasoningTokens: value.reasoning_output_tokens } : {}
+	};
+}
+function providerName(provider) {
+	return provider === "openai-codex-responses" ? "OpenAI Codex Responses" : "OpenAI Responses";
+}
+function modelName(model) {
+	return model.replaceAll("-", " ").replace(/(^| )([a-z])/gu, (_, p, c) => `${p}${c.toUpperCase()}`);
+}
+function isProvider(value) {
+	return value === "openai" || value === "openai-codex-responses";
+}
+function defaultReasoning(ctx, provider) {
+	const settings = ctx.settings.get(SETTINGS_NAMESPACE);
+	if (!settings || typeof settings !== "object") return void 0;
+	const providers = settings.providers;
+	if (!providers || typeof providers !== "object" || Array.isArray(providers)) return void 0;
+	const profile = providers[provider];
+	if (!profile || typeof profile !== "object" || Array.isArray(profile)) return void 0;
+	return supportedThinking(profile.reasoning);
+}
+/** Native DSH model-catalog adapter for the Nanocodex-owned routes. */
+var NanocodexLlmAdapter = class extends LlmAdapter {
+	ctx;
+	constructor(ctx) {
+		super();
+		this.ctx = ctx;
+	}
+	providerInfo(provider) {
+		if (!isProvider(provider)) throw new Error(`Nanocodex does not own provider ${JSON.stringify(provider)}`);
+		return {
+			id: provider,
+			name: providerName(provider)
+		};
+	}
+	async listModels(provider) {
+		this.providerInfo(provider);
+		return SUPPORTED_MODELS.map((id) => ({
+			provider,
+			id,
+			name: modelName(id),
+			inputModalities: ["text", "image"]
+		}));
+	}
+	async resolveModel(provider, model, signal) {
+		signal?.throwIfAborted();
+		this.providerInfo(provider);
+		if (!isSupportedModel(model)) throw new Error(`Nanocodex does not support model ${JSON.stringify(model)}`);
+		const configured = defaultReasoning(this.ctx, provider);
+		const efforts = REASONING_EFFORTS.map(([id, name]) => ({
+			id: ReasoningEffortId(id),
+			name
+		}));
+		return {
+			provider,
+			id: model,
+			name: modelName(model),
+			inputModalities: ["text", "image"],
+			context: { contextWindow: MODEL_CONTEXT_WINDOW },
+			reasoning: {
+				efforts,
+				...configured === void 0 ? {} : { defaultEffort: ReasoningEffortId(configured) }
+			}
+		};
+	}
+	/**
+	* The retained session-title consumer uses this one-shot path. Ordinary
+	* conversation turns remain owned by NanocodexAgent/NanocodexEngine and do
+	* not recurse through DSH's LLM runtime.
+	*/
+	stream(options) {
+		return this.streamOneShot(options);
+	}
+	async *streamOneShot(options) {
+		const signal = options.signal;
+		signal?.throwIfAborted();
+		if (!isSupportedModel(options.model)) throw new Error(`Nanocodex does not support model ${JSON.stringify(options.model)}`);
+		const route = await resolveNanocodexRoute(this.ctx, {
+			provider: options.provider,
+			model: options.model,
+			...options.reasoningEffort === void 0 ? {} : { reasoningEffort: options.reasoningEffort }
+		});
+		const last = options.messages.at(-1);
+		const historySeed = await buildHistorySeed(last?.role === "user" ? options.messages.slice(0, -1) : options.messages, this.ctx, signal);
+		const input = last?.role === "user" ? await buildPromptInput([last], this.ctx, signal) : "Continue from the current conversation.";
+		const runtimeSessionId = randomUUID();
+		const nodeAgent = await Agent.create({
+			transport: Transport.openAi({
+				apiKey: route.apiKey,
+				...route.apiBaseUrl ? { apiBaseUrl: route.apiBaseUrl } : {},
+				...route.websocketUrl ? { websocketUrl: route.websocketUrl } : {},
+				websocketWarmup: false
+			}),
+			model: options.model,
+			...route.thinking ? { thinking: route.thinking } : {},
+			...options.reasoningEffort === "pro" ? { reasoningMode: "pro" } : {},
+			sessionId: runtimeSessionId,
+			subagents: false,
+			historySeed,
+			...options.system ? { additionalInstructions: options.system } : {}
+		});
+		const removeTransportFallback = observeTransportFallback(this.ctx, options.sessionId === void 0 ? nodeAgent.sessionId : String(options.sessionId), nodeAgent);
+		const turn = nodeAgent.turn.prompt({ input });
+		const abort = () => void turn.cancel().catch(() => void 0);
+		signal?.addEventListener("abort", abort, { once: true });
+		try {
+			await turn.accepted();
+			const result = await turn.result();
+			try {
+				signal?.throwIfAborted();
+				if (result.finalMessage) {
+					yield {
+						type: "block-start",
+						index: 0,
+						blockType: "text"
+					};
+					yield {
+						type: "text-delta",
+						index: 0,
+						text: result.finalMessage
+					};
+					yield {
+						type: "block-end",
+						index: 0,
+						block: {
+							type: "text",
+							text: result.finalMessage
+						}
+					};
+				}
+				yield {
+					type: "usage",
+					usage: usage(await result.usage())
+				};
+				yield {
+					type: "finish",
+					reason: { kind: "stop" }
+				};
+			} finally {
+				result.dispose();
+			}
+		} finally {
+			signal?.removeEventListener("abort", abort);
+			removeTransportFallback();
+			turn.dispose();
+			nodeAgent.dispose();
+		}
+	}
+};
+//#endregion
+//#region src/apply-patch/codex-whitespace.ts
+function isRustWhitespace(character) {
+	const codePoint = character?.codePointAt(0);
+	return codePoint !== void 0 && (codePoint >= 9 && codePoint <= 13 || codePoint === 32 || codePoint === 133 || codePoint === 160 || codePoint === 5760 || codePoint >= 8192 && codePoint <= 8202 || codePoint === 8232 || codePoint === 8233 || codePoint === 8239 || codePoint === 8287 || codePoint === 12288);
+}
+function rustTrimStart(value) {
+	let start = 0;
+	while (start < value.length && isRustWhitespace(value[start])) start += 1;
+	return value.slice(start);
+}
+function rustTrimEnd(value) {
+	let end = value.length;
+	while (end > 0 && isRustWhitespace(value[end - 1])) end -= 1;
+	return value.slice(0, end);
+}
+function rustTrim(value) {
+	return rustTrimEnd(rustTrimStart(value));
+}
+//#endregion
+//#region src/apply-patch/errors.ts
+var PatchError = class extends Error {
+	code;
+	line;
+	constructor(message, code, options = {}) {
+		super(message, options);
+		this.name = "PatchError";
+		this.code = code;
+		if (options.line !== void 0) this.line = options.line;
+	}
+};
+function patchErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/apply-patch/source-file.ts
+/** Preserve the first observed line ending, as the Codex patcher does. */
+var SourceFile = class SourceFile {
+	lines;
+	preferredEnding;
+	constructor(lines, preferredEnding) {
+		this.lines = lines;
+		this.preferredEnding = preferredEnding;
+	}
+	static parse(content) {
+		const lines = [];
+		let preferredEnding;
+		let lineStart = 0;
+		let cursor = 0;
+		while (cursor < content.length) {
+			const current = content[cursor];
+			let ending;
+			let endingLength = 0;
+			if (current === "\r" && content[cursor + 1] === "\n") {
+				ending = "\r\n";
+				endingLength = 2;
+			} else if (current === "\r" || current === "\n") {
+				ending = current;
+				endingLength = 1;
+			}
+			if (ending === void 0) {
+				cursor += 1;
+				continue;
+			}
+			preferredEnding ??= ending;
+			lines.push({
+				text: content.slice(lineStart, cursor),
+				ending
+			});
+			cursor += endingLength;
+			lineStart = cursor;
+		}
+		if (lineStart < content.length) lines.push({ text: content.slice(lineStart) });
+		return new SourceFile(lines, preferredEnding ?? "\n");
+	}
+	lineTexts() {
+		return this.lines.map((line) => line.text);
+	}
+	applyReplacements(replacements) {
+		const result = [];
+		let sourceIndex = 0;
+		for (const [start, oldLength, newLines] of replacements) {
+			if (start < sourceIndex) throw new Error("overlapping replacements");
+			result.push(...this.lines.slice(sourceIndex, start));
+			result.push(...newLines.map((text) => ({
+				text,
+				ending: this.preferredEnding
+			})));
+			sourceIndex = start + oldLength;
+		}
+		result.push(...this.lines.slice(sourceIndex));
+		for (const line of result) line.ending ??= this.preferredEnding;
+		this.lines = result;
+	}
+	contents() {
+		return this.lines.map((line) => `${line.text}${line.ending ?? ""}`).join("");
+	}
+};
+//#endregion
+//#region src/apply-patch/matcher.ts
+const UNICODE_ASCII = /* @__PURE__ */ new Map([
+	["‐", "-"],
+	["‑", "-"],
+	["‒", "-"],
+	["–", "-"],
+	["—", "-"],
+	["―", "-"],
+	["−", "-"],
+	["‘", "'"],
+	["’", "'"],
+	["‚", "'"],
+	["‛", "'"],
+	["“", "\""],
+	["”", "\""],
+	["„", "\""],
+	["‟", "\""],
+	["\xA0", " "],
+	[" ", " "],
+	[" ", " "],
+	[" ", " "],
+	[" ", " "],
+	[" ", " "],
+	[" ", " "],
+	[" ", " "],
+	[" ", " "],
+	[" ", " "],
+	[" ", " "],
+	[" ", " "],
+	["　", " "]
+]);
+function normalizeUnicode(line) {
+	return Array.from(rustTrim(line)).map((character) => UNICODE_ASCII.get(character) ?? character).join("");
+}
+function findWith(lines, pattern, start, compare) {
+	const last = lines.length - pattern.length;
+	for (let index = start; index <= last; index += 1) if (pattern.every((line, offset) => compare(lines[index + offset], line))) return index;
+}
+/** Codex's exact, trimmed, and Unicode-normalized context matching order. */
+function seekSequence(lines, pattern, start, atEnd) {
+	if (pattern.length === 0) return start;
+	if (pattern.length > lines.length) return void 0;
+	const searchStart = atEnd ? Math.max(start, lines.length - pattern.length) : start;
+	return findWith(lines, pattern, searchStart, (left, right) => left === right) ?? findWith(lines, pattern, searchStart, (left, right) => rustTrimEnd(left) === rustTrimEnd(right)) ?? findWith(lines, pattern, searchStart, (left, right) => rustTrim(left) === rustTrim(right)) ?? findWith(lines, pattern, searchStart, (left, right) => normalizeUnicode(left) === normalizeUnicode(right));
+}
+function computeReplacements(lines, path, chunks) {
+	const replacements = [];
+	let lineIndex = 0;
+	for (const chunk of chunks) {
+		if (chunk.changeContext !== void 0) {
+			const contextIndex = seekSequence(lines, [chunk.changeContext], lineIndex, false);
+			if (contextIndex === void 0) throw new PatchError(`apply_patch: Failed to find context '${chunk.changeContext}' in ${path}`, "PATCH_CONTEXT_NOT_FOUND", { line: chunk.line });
+			lineIndex = contextIndex + 1;
+		}
+		if (chunk.oldLines.length === 0) {
+			replacements.push([
+				lines.length,
+				0,
+				chunk.newLines
+			]);
+			continue;
+		}
+		let pattern = chunk.oldLines;
+		let newLines = chunk.newLines;
+		let matchIndex = seekSequence(lines, pattern, lineIndex, chunk.isEndOfFile);
+		if (matchIndex === void 0 && pattern.at(-1) === "") {
+			pattern = pattern.slice(0, -1);
+			if (newLines.at(-1) === "") newLines = newLines.slice(0, -1);
+			matchIndex = seekSequence(lines, pattern, lineIndex, chunk.isEndOfFile);
+		}
+		if (matchIndex === void 0) throw new PatchError(`apply_patch: Failed to find expected lines in ${path}:\n${chunk.oldLines.join("\n")}`, "PATCH_CONTEXT_NOT_FOUND", { line: chunk.line });
+		let oldStart = 0;
+		let newStart = 0;
+		for (const [oldContext, newContext] of chunk.contextLineIndices) {
+			if (oldContext >= pattern.length || newContext >= newLines.length) break;
+			if (oldStart !== oldContext || newStart !== newContext) replacements.push([
+				matchIndex + oldStart,
+				oldContext - oldStart,
+				newLines.slice(newStart, newContext)
+			]);
+			oldStart = oldContext + 1;
+			newStart = newContext + 1;
+		}
+		if (oldStart !== pattern.length || newStart !== newLines.length) replacements.push([
+			matchIndex + oldStart,
+			pattern.length - oldStart,
+			newLines.slice(newStart)
+		]);
+		lineIndex = matchIndex + pattern.length;
+	}
+	replacements.sort((left, right) => left[0] - right[0]);
+	return replacements;
+}
+/** Apply update chunks entirely in memory before a filesystem write. */
+function applyChunks(content, path, chunks) {
+	const source = SourceFile.parse(content);
+	source.applyReplacements(computeReplacements(source.lineTexts(), path, chunks));
+	return source.contents();
+}
+//#endregion
+//#region src/apply-patch/parser.ts
+const BEGIN_PATCH = "*** Begin Patch";
+const END_PATCH = "*** End Patch";
+const ADD_FILE = "*** Add File: ";
+const UPDATE_FILE = "*** Update File: ";
+const DELETE_FILE = "*** Delete File: ";
+const MOVE_TO = "*** Move to: ";
+const END_OF_FILE = "*** End of File";
+const CHANGE_CONTEXT = "@@ ";
+const EMPTY_CHANGE_CONTEXT = "@@";
+function invalidPatch(message) {
+	throw new PatchError(`apply_patch: invalid patch: ${message}`, "PATCH_INVALID");
+}
+function invalidHunk(message, line) {
+	throw new PatchError(`apply_patch: invalid hunk at line ${line}: ${message}`, "PATCH_INVALID", { line });
+}
+function unsupported(message, line) {
+	throw new PatchError(`apply_patch: unsupported operation: ${message}`, "PATCH_UNSUPPORTED", line === void 0 ? {} : { line });
+}
+function splitPatchLines(input) {
+	const trimmed = rustTrim(input);
+	const original = trimmed.length === 0 ? [] : trimmed.split("\n").map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
+	const first = original[0] === void 0 ? void 0 : rustTrim(original[0]);
+	const finalLine = original.at(-1);
+	const last = finalLine === void 0 ? void 0 : rustTrim(finalLine);
+	if (first === "*** Begin Patch" && last === "*** End Patch") return original;
+	if (original.length >= 4 && (original[0] === "<<EOF" || original[0] === "<<'EOF'" || original[0] === "<<\"EOF\"") && original.at(-1)?.endsWith("EOF")) {
+		const inner = original.slice(1, -1);
+		if (rustTrim(inner[0]) === "*** Begin Patch" && rustTrim(inner.at(-1)) === "*** End Patch") return inner;
+		if (rustTrim(inner[0]) !== "*** Begin Patch") invalidPatch(`The first line of the patch must be '${BEGIN_PATCH}'`);
+		invalidPatch(`The last line of the patch must be '${END_PATCH}'`);
+	}
+	if (first !== void 0 && first !== "*** Begin Patch") invalidPatch(`The first line of the patch must be '${BEGIN_PATCH}'`);
+	invalidPatch(`The last line of the patch must be '${END_PATCH}'`);
+}
+function newChunk(line, changeContext) {
+	return {
+		...changeContext === void 0 ? {} : { changeContext },
+		oldLines: [],
+		newLines: [],
+		contextLineIndices: [],
+		isEndOfFile: false,
+		line
+	};
+}
+function ensureUpdateHunkIsNotEmpty(mode, nextLine, lineNumber) {
+	if (mode.kind !== "update") return;
+	const chunks = mode.operation.chunks;
+	if (chunks.length === 0) invalidHunk(`Update file hunk for path '${mode.operation.path}' is empty`, mode.hunkLine);
+	const last = chunks.at(-1);
+	if (last.oldLines.length === 0 && last.newLines.length === 0) {
+		if (nextLine === "*** End Patch") invalidHunk("Update hunk does not contain any lines", lineNumber);
+		invalidHunk(`Unexpected line found in update hunk: '${nextLine}'. Every line should start with ' ' (context line), '+' (added line), or '-' (removed line)`, lineNumber);
+	}
+}
+/** Parse the supported Add File and Update File Codex patch subset. */
+function parsePatch(input) {
+	if (typeof input !== "string") invalidPatch("input must be a string");
+	const lines = splitPatchLines(input);
+	const operations = [];
+	let mode = { kind: "started" };
+	const startOperation = (trimmed, lineNumber) => {
+		if (trimmed.startsWith(DELETE_FILE)) unsupported("Delete File is not supported; remove file content explicitly", lineNumber);
+		if (trimmed.startsWith(MOVE_TO)) unsupported("Move to is not supported; use an explicit Add File/Update File patch", lineNumber);
+		if (trimmed.startsWith(ADD_FILE)) {
+			ensureUpdateHunkIsNotEmpty(mode, trimmed, lineNumber);
+			const path = trimmed.slice(14);
+			if (path.length === 0) invalidPatch("Add File path cannot be empty");
+			const operation = {
+				kind: "add",
+				path,
+				content: "",
+				line: lineNumber
+			};
+			operations.push(operation);
+			mode = {
+				kind: "add",
+				operation
+			};
+			return true;
+		}
+		if (trimmed.startsWith(UPDATE_FILE)) {
+			ensureUpdateHunkIsNotEmpty(mode, trimmed, lineNumber);
+			const path = trimmed.slice(17);
+			if (path.length === 0) invalidPatch("Update File path cannot be empty");
+			const operation = {
+				kind: "update",
+				path,
+				chunks: [],
+				line: lineNumber
+			};
+			operations.push(operation);
+			mode = {
+				kind: "update",
+				operation,
+				hunkLine: lineNumber
+			};
+			return true;
+		}
+		return false;
+	};
+	for (let index = 1; index < lines.length - 1; index += 1) {
+		const line = lines[index];
+		const lineNumber = index + 1;
+		const activeMode = mode;
+		if (activeMode.kind !== "update") {
+			const trimmed = rustTrim(line);
+			if (startOperation(trimmed, lineNumber)) continue;
+			if (activeMode.kind === "add" && line.startsWith("+")) {
+				activeMode.operation.content += `${line.slice(1)}\n`;
+				continue;
+			}
+			invalidHunk(`'${trimmed}' is not a valid hunk header. Valid hunk headers: '${ADD_FILE}{path}', '${UPDATE_FILE}{path}'`, lineNumber);
+			continue;
+		}
+		const updateMode = activeMode;
+		const updateLine = rustTrimEnd(line);
+		if (startOperation(updateLine, lineNumber)) continue;
+		const chunks = updateMode.operation.chunks;
+		const last = chunks.at(-1);
+		if (last?.isEndOfFile) {
+			if (updateLine.length === 0) continue;
+			if (updateLine !== EMPTY_CHANGE_CONTEXT && !updateLine.startsWith(CHANGE_CONTEXT)) invalidHunk(`Expected update hunk to start with a @@ context marker, got: '${line}'`, lineNumber);
+		}
+		if (updateLine === EMPTY_CHANGE_CONTEXT) {
+			if (last !== void 0 && last.oldLines.length === 0 && last.newLines.length === 0) invalidHunk(`Unexpected line found in update hunk: '${line}'. Every line should start with ' ' (context line), '+' (added line), or '-' (removed line)`, lineNumber);
+			chunks.push(newChunk(lineNumber));
+			continue;
+		}
+		if (updateLine.startsWith(CHANGE_CONTEXT)) {
+			if (last !== void 0 && last.oldLines.length === 0 && last.newLines.length === 0) invalidHunk(`Unexpected line found in update hunk: '${line}'. Every line should start with ' ' (context line), '+' (added line), or '-' (removed line)`, lineNumber);
+			chunks.push(newChunk(lineNumber, updateLine.slice(3)));
+			continue;
+		}
+		if (updateLine === END_OF_FILE) {
+			if (last !== void 0 && last.oldLines.length === 0 && last.newLines.length === 0) invalidHunk("Update hunk does not contain any lines", lineNumber);
+			if (last === void 0) invalidHunk("End of File requires an update hunk", lineNumber);
+			last.isEndOfFile = true;
+			continue;
+		}
+		if (line.length === 0 || line.startsWith(" ")) {
+			const chunk = chunks.at(-1) ?? newChunk(lineNumber);
+			if (chunks.length === 0) chunks.push(chunk);
+			chunk.contextLineIndices.push([chunk.oldLines.length, chunk.newLines.length]);
+			const context = line.length === 0 ? "" : line.slice(1);
+			chunk.oldLines.push(context);
+			chunk.newLines.push(context);
+			continue;
+		}
+		if (line.startsWith("+")) {
+			const chunk = chunks.at(-1) ?? newChunk(lineNumber);
+			if (chunks.length === 0) chunks.push(chunk);
+			chunk.newLines.push(line.slice(1));
+			continue;
+		}
+		if (line.startsWith("-")) {
+			const chunk = chunks.at(-1) ?? newChunk(lineNumber);
+			if (chunks.length === 0) chunks.push(chunk);
+			chunk.oldLines.push(line.slice(1));
+			continue;
+		}
+		if (last !== void 0 && (last.oldLines.length > 0 || last.newLines.length > 0)) invalidHunk(`Expected update hunk to start with a @@ context marker, got: '${line}'`, lineNumber);
+		invalidHunk(`Unexpected line found in update hunk: '${line}'. Every line should start with ' ' (context line), '+' (added line), or '-' (removed line)`, lineNumber);
+	}
+	ensureUpdateHunkIsNotEmpty(mode, END_PATCH, lines.length);
+	if (operations.length === 0) invalidPatch("patch contains no file operations");
+	return {
+		operations,
+		normalizedPatch: lines.join("\n")
+	};
+}
+//#endregion
+//#region src/apply-patch/tool.ts
+const DEFAULT_APPLY_PATCH_LIMITS = {
+	maxPatchChars: DEFAULT_MAX_PATCH_CHARS,
+	maxPatchFiles: 64,
+	maxPatchFileBytes: DEFAULT_MAX_PATCH_FILE_BYTES
+};
+function workspaceCwd(exec) {
+	const cwd = exec.agent?.session?.header?.cwd;
+	if (typeof cwd !== "string" || cwd.length === 0) throw new PatchError("apply_patch requires an active Agent workspace", "PATCH_PATH_INVALID");
+	return cwd;
+}
+function byteLength(value) {
+	return new TextEncoder().encode(value).byteLength;
+}
+function parseArguments(value, limits) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new PatchError("apply_patch expects an object containing one non-empty patch string", "PATCH_INVALID");
+	const record = value;
+	if (Object.keys(record).some((key) => key !== "patch") || typeof record.patch !== "string" || record.patch.length === 0) throw new PatchError("apply_patch expects an object containing one non-empty patch string", "PATCH_INVALID");
+	if (record.patch.length > limits.maxPatchChars) throw new PatchError(`apply_patch input exceeds the ${limits.maxPatchChars}-character limit`, "PATCH_TOO_LARGE");
+	return record.patch;
+}
+function operationAction(operation) {
+	return operation.kind;
+}
+function errorCode(error) {
+	if (typeof error === "object" && error !== null && "code" in error && typeof error.code === "string") return error.code;
+	return "PATCH_IO";
+}
+function isCancellation(error, signal) {
+	return signal.aborted || errorCode(error) === "FS_ABORTED" || error instanceof Error && error.name === "AbortError";
+}
+function observeVersion(services, target, version, exec) {
+	services.ctx.emit(scopeTarget(services.fs, exec.agent), "fs/observed", target, {
+		kind: "present",
+		version
+	}, exec);
+}
+async function writeIntent(services, target, fallback, exec) {
+	return await services.ctx.waterfall(scopeTarget(services.fs, exec.agent), "fs/write-intent", target, exec, () => Promise.resolve(fallback)) ?? fallback;
+}
+async function editIntent(services, target, fallback, exec) {
+	return await services.ctx.waterfall(scopeTarget(services.fs, exec.agent), "fs/edit-intent", target, exec, () => Promise.resolve(fallback)) ?? fallback;
+}
+function checkFileSize(info, path, limits) {
+	if (info.size !== void 0 && info.size > limits.maxPatchFileBytes) throw new PatchError(`apply_patch target '${path}' exceeds the ${limits.maxPatchFileBytes}-byte limit`, "PATCH_TOO_LARGE");
+}
+async function preflight(patch, services, exec, limits) {
+	if (patch.operations.length > limits.maxPatchFiles) throw new PatchError(`apply_patch contains more than ${limits.maxPatchFiles} file operations`, "PATCH_TOO_LARGE");
+	const cwd = workspaceCwd(exec);
+	const workspace = await services.fs.resolve(cwd, {
+		cwd,
+		signal: exec.signal
+	});
+	const targets = /* @__PURE__ */ new Map();
+	const staged = [];
+	for (const operation of patch.operations) {
+		exec.signal.throwIfAborted();
+		if (operation.path.trim().length === 0) throw new PatchError(`apply_patch ${operation.kind === "add" ? "Add" : "Update"} File path cannot be blank`, "PATCH_PATH_INVALID", { line: operation.line });
+		const target = await services.fs.resolve(operation.path, {
+			cwd,
+			signal: exec.signal
+		});
+		exec.signal.throwIfAborted();
+		if (!services.fs.contains(workspace, target)) throw new PatchError(`apply_patch target '${operation.path}' must stay inside the active workspace`, "PATCH_PATH_INVALID", { line: operation.line });
+		const previousPath = targets.get(target.targetKey);
+		if (previousPath !== void 0) throw new PatchError(`apply_patch contains duplicate target '${operation.path}' (same target as '${previousPath}')`, "PATCH_INVALID", { line: operation.line });
+		targets.set(target.targetKey, operation.path);
+		const info = await services.fs.stat(target, exec.signal);
+		exec.signal.throwIfAborted();
+		if (operation.kind === "add") {
+			if (info !== void 0) throw new PatchError(`apply_patch cannot add '${operation.path}': the target already exists`, "PATCH_INVALID", { line: operation.line });
+			if (byteLength(operation.content) > limits.maxPatchFileBytes) throw new PatchError(`apply_patch added file '${operation.path}' exceeds the ${limits.maxPatchFileBytes}-byte limit`, "PATCH_TOO_LARGE", { line: operation.line });
+			const expected = await writeIntent(services, target, { kind: "createIfAbsent" }, exec);
+			if (expected.kind !== "createIfAbsent") throw new FsError(`cannot add '${operation.path}': the target changed after its absence was observed`, "FS_STALE_VERSION");
+			staged.push({
+				operation,
+				target,
+				before: null,
+				after: operation.content,
+				expected
+			});
+			continue;
+		}
+		if (info === void 0) throw new PatchError(`apply_patch cannot update '${operation.path}': the target does not exist`, "PATCH_INVALID", { line: operation.line });
+		if (info.type !== "file") throw new PatchError(`apply_patch cannot update '${operation.path}': the target is not a regular text file`, "PATCH_INVALID", { line: operation.line });
+		const edit = await editIntent(services, target, { version: info.version }, exec);
+		if (edit.version !== info.version) throw new FsError(`cannot update '${operation.path}': the target changed after preflight stat`, "FS_STALE_VERSION");
+		const expected = await writeIntent(services, target, {
+			kind: "replaceIfVersion",
+			version: edit.version
+		}, exec);
+		if (expected.kind !== "replaceIfVersion" || expected.version !== info.version) throw new FsError(`cannot update '${operation.path}': the target is not observed at its current version`, "FS_STALE_VERSION");
+		checkFileSize(info, operation.path, limits);
+		const before = await services.fs.readText(target, exec.signal);
+		exec.signal.throwIfAborted();
+		if (byteLength(before) > limits.maxPatchFileBytes) throw new PatchError(`apply_patch target '${operation.path}' exceeds the ${limits.maxPatchFileBytes}-byte limit`, "PATCH_TOO_LARGE", { line: operation.line });
+		const after = applyChunks(before, operation.path, operation.chunks);
+		if (byteLength(after) > limits.maxPatchFileBytes) throw new PatchError(`apply_patch updated file '${operation.path}' exceeds the ${limits.maxPatchFileBytes}-byte limit`, "PATCH_TOO_LARGE", { line: operation.line });
+		staged.push({
+			operation,
+			target,
+			before,
+			after,
+			expected
+		});
+		exec.signal.throwIfAborted();
+	}
+	return staged;
+}
+function operationSummary(operations, status) {
+	const committed = operations.filter((operation) => operation.status === "committed").map((operation) => operation.path);
+	const failed = operations.find((operation) => operation.status === "failed");
+	const unattempted = operations.filter((operation) => operation.status === "unattempted").map((operation) => operation.path);
+	if (status === "applied") return `Applied patch to ${committed.length} file${committed.length === 1 ? "" : "s"}: ${committed.join(", ")}.`;
+	const details = [`${status === "cancelled" ? "Patch publication cancelled" : "Patch publication failed"}.`];
+	if (committed.length > 0) details.push(`Committed: ${committed.join(", ")}.`);
+	if (failed !== void 0) details.push(`Failed: ${failed.path}.`);
+	if (unattempted.length > 0) details.push(`Unattempted: ${unattempted.join(", ")}.`);
+	return details.join(" ");
+}
+function unifiedDiff(diff) {
+	const oldLines = diff.oldText === null ? [] : diff.oldText.split("\n");
+	const newLines = diff.newText.split("\n");
+	return [
+		`--- ${diff.oldText === null ? "/dev/null" : `a/${diff.path}`}`,
+		`+++ b/${diff.path}`,
+		...oldLines.map((line) => `-${line}`),
+		...newLines.map((line) => `+${line}`)
+	].join("\n");
+}
+function diffFromWrite(staged, outcome) {
+	return {
+		path: staged.operation.path,
+		oldText: outcome.before ?? staged.before,
+		newText: outcome.after
+	};
+}
+function outputFor(status, operations, diffs, failure) {
+	return {
+		status,
+		summary: operationSummary(operations, status),
+		diff: diffs.map(unifiedDiff).join("\n"),
+		operations,
+		diffs,
+		...failure === void 0 ? {} : { error: failure }
+	};
+}
+/**
+* Preflight and publish a supported Codex patch through the DSH filesystem.
+*
+* Every operation is resolved, observed, read, matched, and calculated before
+* the first guarded atomic write. Publication is ordered and intentionally
+* non-transactional: a later failure leaves committed earlier files in place
+* and returns their diffs with explicit per-operation progress.
+*/
+async function applyPatchToFileSystem(input, services, exec, limits = DEFAULT_APPLY_PATCH_LIMITS) {
+	if (input.length > limits.maxPatchChars) throw new PatchError(`apply_patch input exceeds the ${limits.maxPatchChars}-character limit`, "PATCH_TOO_LARGE");
+	const staged = await preflight(parsePatch(input), services, exec, limits);
+	const operations = staged.map(({ operation }) => ({
+		path: operation.path,
+		action: operationAction(operation),
+		status: "unattempted"
+	}));
+	const diffs = [];
+	for (const [index, candidate] of staged.entries()) {
+		let writeStarted = false;
+		try {
+			exec.signal.throwIfAborted();
+			writeStarted = true;
+			const write = await services.fs.writeText(candidate.target, candidate.after, candidate.expected, exec.signal);
+			const operation = operations[index];
+			if (operation === void 0) throw new Error("patch operation disappeared");
+			operations[index] = {
+				...operation,
+				status: "committed"
+			};
+			diffs.push(diffFromWrite(candidate, write));
+			observeVersion(services, candidate.target, write.version, exec);
+		} catch (error) {
+			const code = isCancellation(error, exec.signal) ? "FS_ABORTED" : errorCode(error);
+			const message = isCancellation(error, exec.signal) ? "patch publication was cancelled" : patchErrorMessage(error);
+			const operation = operations[index];
+			if (operation !== void 0 && writeStarted) operations[index] = {
+				...operation,
+				status: "failed",
+				error: {
+					code,
+					message
+				}
+			};
+			return outputFor(isCancellation(error, exec.signal) ? "cancelled" : diffs.length > 0 ? "partial" : "failed", operations, diffs, {
+				code,
+				message
+			});
+		}
+	}
+	return outputFor("applied", operations, diffs);
+}
+function outcomeText(outcome) {
+	const error = outcome.error;
+	return [
+		outcome.summary,
+		error === void 0 ? "" : `Error (${error.code}): ${error.message}`,
+		outcome.diff.length === 0 ? "" : `\n${outcome.diff}`
+	].filter(Boolean).join("\n");
+}
+function renderOutcome(_args, value) {
+	return [{
+		type: "text",
+		text: outcomeText(value)
+	}];
+}
+function presentationDiffs(value) {
+	return value.diffs.map((diff) => ({
+		path: diff.path,
+		oldText: diff.oldText,
+		newText: diff.newText
+	}));
+}
+function isDiffResultMeta(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const diffs = value.diffs;
+	return Array.isArray(diffs) && diffs.every((diff) => typeof diff === "object" && diff !== null && typeof diff.path === "string" && typeof diff.newText === "string");
+}
+function callView(args, limits) {
+	try {
+		const patch = parseArguments(args, limits);
+		const locations = parsePatch(patch).operations.map((operation) => ({ path: operation.path }));
+		return {
+			card: "generic",
+			title: `Apply patch (${locations.length} file${locations.length === 1 ? "" : "s"})`,
+			kind: "edit",
+			rawInput: patch,
+			locations
+		};
+	} catch {
+		return {
+			card: "generic",
+			title: "Apply patch",
+			kind: "edit",
+			rawInput: args
+		};
+	}
+}
+function resultView(_args, result) {
+	if (!result.isError && isDiffResultMeta(result.meta)) return {
+		card: "diff",
+		diffs: result.meta.diffs
+	};
+}
+const parameters = {
+	type: "object",
+	additionalProperties: false,
+	properties: { patch: {
+		type: "string",
+		description: "Complete raw Codex Add File/Update File patch text."
+	} },
+	required: ["patch"]
+};
+const outputSchema = {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		status: {
+			type: "string",
+			enum: [
+				"applied",
+				"partial",
+				"failed",
+				"cancelled"
+			]
+		},
+		summary: { type: "string" },
+		diff: { type: "string" },
+		operations: {
+			type: "array",
+			items: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					path: { type: "string" },
+					action: {
+						type: "string",
+						enum: ["add", "update"]
+					},
+					status: {
+						type: "string",
+						enum: [
+							"committed",
+							"failed",
+							"unattempted"
+						]
+					},
+					error: {
+						type: "object",
+						additionalProperties: false,
+						properties: {
+							code: { type: "string" },
+							message: { type: "string" }
+						},
+						required: ["code", "message"]
+					}
+				},
+				required: [
+					"path",
+					"action",
+					"status"
+				]
+			}
+		},
+		diffs: {
+			type: "array",
+			items: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					path: { type: "string" },
+					oldText: { oneOf: [{ type: "string" }, { type: "null" }] },
+					newText: { type: "string" }
+				},
+				required: [
+					"path",
+					"oldText",
+					"newText"
+				]
+			}
+		},
+		error: {
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				code: { type: "string" },
+				message: { type: "string" }
+			},
+			required: ["code", "message"]
+		}
+	},
+	required: [
+		"status",
+		"summary",
+		"diff",
+		"operations",
+		"diffs"
+	]
+};
+/** Build the registry definition for the direct raw patch tool. */
+function createApplyPatchTool(services, progressByExecution, limits = DEFAULT_APPLY_PATCH_LIMITS) {
+	return {
+		name: APPLY_PATCH_NAME,
+		description: APPLY_PATCH_DESCRIPTION,
+		parameters,
+		output: {
+			schema: outputSchema,
+			render: renderOutcome,
+			presentationMeta: (_args, value) => ({ diffs: presentationDiffs(value).map((diff) => ({
+				path: diff.path,
+				oldText: diff.oldText,
+				newText: diff.newText
+			})) })
+		},
+		async execute(args, exec) {
+			const outcome = await applyPatchToFileSystem(parseArguments(args, limits), services, exec, limits);
+			progressByExecution.set(exec, { outcome });
+			return outcome;
+		},
+		finalizeContent(exec, result) {
+			const progress = progressByExecution.get(exec);
+			progressByExecution.delete(exec);
+			if (progress === void 0 || !result.isError) return void 0;
+			return renderOutcome(exec.arguments, progress.outcome);
+		},
+		presentCall: (args) => callView(args, limits),
+		presentResult: resultView
+	};
+}
+//#endregion
+//#region src/index.ts
+const name = PLUGIN_NAME;
+const inject = [
+	"agents",
+	"sessions",
+	"settings",
+	"credentials",
+	"llm",
+	"attachments",
+	"commands",
+	"systemPrompt",
+	"tools",
+	"fs",
+	"storageDomain"
+];
+/** Install the selected Nanocodex AgentFactory and private compaction owner. */
+async function apply(ctx) {
+	const checkpoints = await ctx.storageDomain.open(nanocodexCheckpointDomain);
+	ctx.effect(() => () => checkpoints.close(), "dsh-nanocodex.checkpoints");
+	const settings = ctx.settings.register(SETTINGS_NAMESPACE, NanocodexSettingsSchema, { applies: "live" });
+	const adapter = new NanocodexLlmAdapter(ctx);
+	const routes = configuredNanocodexProviders(settings.get());
+	const adapterRegistration = ctx.llm.registerAdapter(routes.length > 0 ? routes : ["openai"], adapter);
+	if (routes.length === 0) adapterRegistration.replace([]);
+	ctx.effect(() => settings.watch((next) => {
+		const nextRoutes = configuredNanocodexProviders(next);
+		adapterRegistration.replace(nextRoutes);
+	}), "dsh-nanocodex.settings");
+	ctx.llm.registerConfigurableProviders([{
+		provider: "openai",
+		displayName: "OpenAI Responses",
+		settingsNs: SETTINGS_NAMESPACE,
+		settingsPath: ["providers", "openai"],
+		declared: false
+	}, {
+		provider: "openai-codex-responses",
+		displayName: "OpenAI Codex Responses",
+		settingsNs: SETTINGS_NAMESPACE,
+		settingsPath: ["providers", "openai-codex-responses"],
+		declared: false
+	}]);
+	ctx.systemPrompt.variable("cwd", (context) => context.agent?.session.header.cwd);
+	const engine = new NanocodexEngine(ctx, checkpoints.table("sessions"));
+	const patchProgress = /* @__PURE__ */ new WeakMap();
+	ctx.effect(() => {
+		return ctx.tools.register(createApplyPatchTool({
+			fs: ctx.fs,
+			ctx
+		}, patchProgress));
+	}, "dsh-nanocodex.apply-patch");
+	new NanocodexCompactionEngine(ctx, engine);
+	const factory = new NanocodexFactory(ctx, engine);
+	ctx.effect(() => {
+		const unregister = ctx.agents.setFactory(factory);
+		return async () => {
+			unregister();
+			await factory.disposeAll();
+		};
+	}, "dsh-nanocodex.factory");
+}
+//#endregion
+export { APPLY_PATCH_DESCRIPTION, APPLY_PATCH_GRAMMAR, APPLY_PATCH_NAME, DEFAULT_MAX_PATCH_CHARS, DEFAULT_MAX_PATCH_FILES, DEFAULT_MAX_PATCH_FILE_BYTES, INTERRUPTED_TOOL_OUTPUT, MODEL_CONTEXT_WINDOW, NanocodexAgent, NanocodexCompactionEngine, NanocodexEngine, NanocodexFactory, NanocodexLlmAdapter, NanocodexSettingsSchema, PLUGIN_NAME, PatchError, SETTINGS_NAMESPACE, SUPPORTED_MODELS, SUPPORTED_PROVIDERS, apply, applyChunks, applyPatchToFileSystem, buildHistoryProjection, buildHistorySeed, buildPromptInput, configuredNanocodexProviders, createApplyPatchTool, createToolBridge, historyToolCallId, inject, isSupportedModel, isSupportedRoute, name, nanocodexCheckpointDomain, normalizeNanocodexSessionId, parsePatch, plainText, resolveNanocodexRoute, seekSequence, supportedThinking };