@pixelzx/genesis 2026.5.5-3 → 2026.5.5-5

package/dist/image-fallbacks-BSxulCpr.js

@@ -0,0 +1,2 @@
+import { i as modelsImageFallbacksRemoveCommand, n as modelsImageFallbacksClearCommand, r as modelsImageFallbacksListCommand, t as modelsImageFallbacksAddCommand } from "./image-fallbacks-BdbQMsja.js";
+export { modelsImageFallbacksAddCommand, modelsImageFallbacksClearCommand, modelsImageFallbacksListCommand, modelsImageFallbacksRemoveCommand };

package/dist/image-fallbacks-BdbQMsja.js

@@ -0,0 +1,31 @@
+import { i as removeFallbackCommand, n as clearFallbacksCommand, r as listFallbacksCommand, t as addFallbackCommand } from "./fallbacks-shared-cZD0oSnX.js";
+//#region src/commands/models/image-fallbacks.ts
+async function modelsImageFallbacksListCommand(opts, runtime) {
+	return await listFallbacksCommand({
+		label: "Image fallbacks",
+		key: "imageModel"
+	}, opts, runtime);
+}
+async function modelsImageFallbacksAddCommand(modelRaw, runtime) {
+	return await addFallbackCommand({
+		label: "Image fallbacks",
+		key: "imageModel",
+		logPrefix: "Image fallbacks"
+	}, modelRaw, runtime);
+}
+async function modelsImageFallbacksRemoveCommand(modelRaw, runtime) {
+	return await removeFallbackCommand({
+		label: "Image fallbacks",
+		key: "imageModel",
+		notFoundLabel: "Image fallback",
+		logPrefix: "Image fallbacks"
+	}, modelRaw, runtime);
+}
+async function modelsImageFallbacksClearCommand(runtime) {
+	return await clearFallbacksCommand({
+		key: "imageModel",
+		clearedMessage: "Image fallback list cleared."
+	}, runtime);
+}
+//#endregion
+export { modelsImageFallbacksRemoveCommand as i, modelsImageFallbacksClearCommand as n, modelsImageFallbacksListCommand as r, modelsImageFallbacksAddCommand as t };

package/dist/images-9cckfaLv.js

@@ -0,0 +1,352 @@
+import { i as formatErrorMessage } from "./errors-Jbvi20TW.js";
+import { a as normalizeLowercaseStringOrEmpty } from "./string-coerce-C1IzJjqi.js";
+import { m as resolveUserPath } from "./utils-DaGfogP-.js";
+import { n as sanitizeImageBlocks } from "./tool-images-1Y5MwBpT.js";
+import { t as log } from "./logger-E_fmQU2g.js";
+import { a as safeFileURLToPath, t as assertNoWindowsNetworkPath } from "./local-file-access-DgmtufHS.js";
+import { t as loadWebMedia } from "./web-media-PnHEx5HT.js";
+import { n as resolveSandboxedBridgeMediaPath, t as createSandboxBridgeReadFile } from "./sandbox-media-paths-Bxw3XwBo.js";
+import path from "node:path";
+//#region src/agents/pi-embedded-runner/run/images.ts
+/**
+* Common image file extensions for detection.
+*/
+const IMAGE_EXTENSION_NAMES = [
+	"png",
+	"jpg",
+	"jpeg",
+	"gif",
+	"webp",
+	"bmp",
+	"tiff",
+	"tif",
+	"heic",
+	"heif"
+];
+const IMAGE_EXTENSIONS = new Set(IMAGE_EXTENSION_NAMES.map((ext) => `.${ext}`));
+const IMAGE_EXTENSION_PATTERN = IMAGE_EXTENSION_NAMES.join("|");
+const MEDIA_ATTACHED_PATH_REGEX_SOURCE = "^\\s*(.+?\\.(?:" + IMAGE_EXTENSION_PATTERN + "))\\s*(?:\\(|$|\\|)";
+const MESSAGE_IMAGE_REGEX_SOURCE = "\\[Image:\\s*source:\\s*([^\\]]+\\.(?:" + IMAGE_EXTENSION_PATTERN + "))\\]";
+const FILE_URL_REGEX_SOURCE = "file://[^\\s<>\"'`\\]]+\\.(?:" + IMAGE_EXTENSION_PATTERN + ")";
+const PATH_REGEX_SOURCE = "(?:^|\\s|[\"'`(])((\\.\\.?/|[~/])[^\\s\"'`()\\[\\]]*\\.(?:" + IMAGE_EXTENSION_PATTERN + "))";
+const MEDIA_ATTACHED_PATTERN = /\[media attached(?:\s+\d+\/\d+)?:\s*([^\]]+)\]/gi;
+const MEDIA_ATTACHED_PATH_PATTERN = new RegExp(MEDIA_ATTACHED_PATH_REGEX_SOURCE, "i");
+const MESSAGE_IMAGE_PATTERN = new RegExp(MESSAGE_IMAGE_REGEX_SOURCE, "gi");
+const FILE_URL_PATTERN = new RegExp(FILE_URL_REGEX_SOURCE, "gi");
+const PATH_PATTERN = new RegExp(PATH_REGEX_SOURCE, "gi");
+/**
+* Matches the opaque media URI written by the Gateway's claim-check offload:
+*   media://inbound/<uuid-or-id>
+*
+* Uses an exclusion-based character class rather than a whitelist so that
+* Unicode filenames (e.g. Chinese characters) preserved by sanitizeFilename
+* in store.ts are matched correctly.
+*
+* Explicitly excluded from the ID segment:
+*   ]      — closes the surrounding [media attached: ...] bracket
+*   \s     — any whitespace (space, newline, tab) — terminates the token
+*   /      — forward slash path separator (traversal prevention)
+*   \      — back slash path separator (traversal prevention)
+*   \x00   — null byte (path injection prevention)
+*
+* resolveMediaBufferPath applies its own guards against these characters, but
+* excluding them here provides defence-in-depth at the parsing layer.
+*
+* Example valid IDs:
+*   "1c77ce17-20b9-4546-be64-6e36a9adcb2c.png"
+*   "photo---1c77ce17-20b9-4546-be64-6e36a9adcb2c.png"
+*   "图片---1c77ce17-20b9-4546-be64-6e36a9adcb2c.png"
+*/
+const MEDIA_URI_REGEX = /\bmedia:\/\/inbound\/([^\]\s/\\\x00]+)/;
+/**
+* Checks if a file extension indicates an image file.
+*/
+function isImageExtension(filePath) {
+	const ext = normalizeLowercaseStringOrEmpty(path.extname(filePath));
+	return IMAGE_EXTENSIONS.has(ext);
+}
+function normalizeRefForDedupe(raw) {
+	return process.platform === "win32" ? normalizeLowercaseStringOrEmpty(raw) : raw;
+}
+function mergePromptAttachmentImages(params) {
+	const promptImages = [];
+	const existingImages = params.existingImages ?? [];
+	const offloadedImages = params.offloadedImages ?? [];
+	if (params.imageOrder && params.imageOrder.length > 0) {
+		let inlineIndex = 0;
+		let offloadedIndex = 0;
+		for (const entry of params.imageOrder) {
+			if (entry === "inline") {
+				const image = existingImages[inlineIndex++];
+				if (image) promptImages.push(image);
+				continue;
+			}
+			const image = offloadedImages[offloadedIndex++];
+			if (image) promptImages.push(image);
+		}
+		while (inlineIndex < existingImages.length) promptImages.push(existingImages[inlineIndex++]);
+		while (offloadedIndex < offloadedImages.length) {
+			const image = offloadedImages[offloadedIndex++];
+			if (image) promptImages.push(image);
+		}
+	} else {
+		promptImages.push(...existingImages);
+		for (const image of offloadedImages) if (image) promptImages.push(image);
+	}
+	promptImages.push(...params.promptRefImages ?? []);
+	return promptImages;
+}
+function extractTrailingAttachmentMediaUris(prompt, count) {
+	if (count <= 0) return [];
+	const lines = prompt.split(/\r?\n/);
+	const uris = [];
+	for (let index = lines.length - 1; index >= 0 && uris.length < count; index--) {
+		const line = lines[index]?.trim();
+		if (!line || line.includes("\0")) break;
+		const match = line.match(/^\[media attached:\s*(media:\/\/inbound\/[^\]\s/\\]+)\]$/);
+		if (!match?.[1]) break;
+		uris.unshift(match[1]);
+	}
+	return uris;
+}
+function splitPromptAndAttachmentRefs(params) {
+	const offloadedCount = params.imageOrder?.filter((entry) => entry === "offloaded").length ?? 0;
+	if (offloadedCount === 0) return {
+		promptRefs: params.refs,
+		attachmentRefs: []
+	};
+	const attachmentUris = new Set(extractTrailingAttachmentMediaUris(params.prompt, offloadedCount));
+	if (attachmentUris.size === 0) return {
+		promptRefs: params.refs,
+		attachmentRefs: []
+	};
+	const promptRefs = [];
+	const attachmentRefs = [];
+	for (const ref of params.refs) {
+		if (ref.type === "media-uri" && attachmentUris.has(ref.resolved)) {
+			attachmentRefs.push(ref);
+			continue;
+		}
+		promptRefs.push(ref);
+	}
+	return {
+		promptRefs,
+		attachmentRefs
+	};
+}
+async function sanitizeImagesWithLog(images, label, imageSanitization) {
+	const { images: sanitized, dropped } = await sanitizeImageBlocks(images, label, imageSanitization);
+	if (dropped > 0) log.warn(`Native image: dropped ${dropped} image(s) after sanitization (${label}).`);
+	return sanitized;
+}
+/**
+* Detects image references in a user prompt.
+*
+* Patterns detected:
+* - Absolute paths: /path/to/image.png
+* - Relative paths: ./image.png, ../images/photo.jpg
+* - Home paths: ~/Pictures/screenshot.png
+* - file:// URLs: file:///path/to/image.png
+* - Message attachments: [Image: source: /path/to/image.jpg]
+* - Gateway claim-check URIs: [media attached: media://inbound/<id>]
+*
+* @param prompt The user prompt text to scan
+* @returns Array of detected image references
+*/
+function detectImageReferences(prompt) {
+	const refs = [];
+	const seen = /* @__PURE__ */ new Set();
+	const addPathRef = (raw) => {
+		const trimmed = raw.trim();
+		const dedupeKey = normalizeRefForDedupe(trimmed);
+		if (!trimmed || seen.has(dedupeKey)) return;
+		if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) return;
+		if (!isImageExtension(trimmed)) return;
+		try {
+			assertNoWindowsNetworkPath(trimmed, "Image path");
+		} catch {
+			return;
+		}
+		seen.add(dedupeKey);
+		const resolved = trimmed.startsWith("~") ? resolveUserPath(trimmed) : trimmed;
+		refs.push({
+			raw: trimmed,
+			type: "path",
+			resolved
+		});
+	};
+	MEDIA_ATTACHED_PATTERN.lastIndex = 0;
+	MESSAGE_IMAGE_PATTERN.lastIndex = 0;
+	FILE_URL_PATTERN.lastIndex = 0;
+	PATH_PATTERN.lastIndex = 0;
+	let match;
+	while ((match = MEDIA_ATTACHED_PATTERN.exec(prompt)) !== null) {
+		const content = match[1];
+		if (/^\d+\s+files?$/i.test(content.trim())) continue;
+		const mediaUriMatch = content.match(MEDIA_URI_REGEX);
+		if (mediaUriMatch) {
+			const uri = `media://inbound/${mediaUriMatch[1]}`;
+			const dedupeKey = normalizeRefForDedupe(uri);
+			if (!seen.has(dedupeKey)) {
+				seen.add(dedupeKey);
+				refs.push({
+					raw: uri,
+					type: "media-uri",
+					resolved: uri
+				});
+			}
+			continue;
+		}
+		const pathMatch = content.match(MEDIA_ATTACHED_PATH_PATTERN);
+		if (pathMatch?.[1]) addPathRef(pathMatch[1].trim());
+	}
+	while ((match = MESSAGE_IMAGE_PATTERN.exec(prompt)) !== null) {
+		const raw = match[1]?.trim();
+		if (raw) addPathRef(raw);
+	}
+	while ((match = FILE_URL_PATTERN.exec(prompt)) !== null) {
+		const raw = match[0];
+		const dedupeKey = normalizeRefForDedupe(raw);
+		if (seen.has(dedupeKey)) continue;
+		seen.add(dedupeKey);
+		try {
+			const resolved = safeFileURLToPath(raw);
+			refs.push({
+				raw,
+				type: "path",
+				resolved
+			});
+		} catch {}
+	}
+	while ((match = PATH_PATTERN.exec(prompt)) !== null) if (match[1]) addPathRef(match[1]);
+	return refs;
+}
+/**
+* Loads an image from a file path and returns it as ImageContent.
+*
+* @param ref The detected image reference
+* @param workspaceDir The current workspace directory for resolving relative paths
+* @param options Optional settings for sandbox and size limits
+* @returns The loaded image content, or null if loading failed
+*/
+async function loadImageFromRef(ref, workspaceDir, options) {
+	try {
+		let targetPath = ref.resolved;
+		if (options?.sandbox) try {
+			targetPath = (await resolveSandboxedBridgeMediaPath({
+				sandbox: {
+					root: options.sandbox.root,
+					bridge: options.sandbox.bridge,
+					workspaceOnly: options.workspaceOnly
+				},
+				mediaPath: targetPath
+			})).resolved;
+		} catch (err) {
+			log.debug(`Native image: sandbox validation failed for ${ref.resolved}: ${formatErrorMessage(err)}`);
+			return null;
+		}
+		else if (!path.isAbsolute(targetPath)) targetPath = path.resolve(workspaceDir, targetPath);
+		const media = options?.sandbox ? await loadWebMedia(targetPath, {
+			maxBytes: options.maxBytes,
+			sandboxValidated: true,
+			readFile: createSandboxBridgeReadFile({ sandbox: options.sandbox })
+		}) : await loadWebMedia(targetPath, options?.workspaceOnly ? {
+			maxBytes: options.maxBytes,
+			localRoots: [workspaceDir]
+		} : options?.maxBytes);
+		if (media.kind !== "image") {
+			log.debug(`Native image: not an image file: ${targetPath} (got ${media.kind})`);
+			return null;
+		}
+		const mimeType = media.contentType ?? "image/jpeg";
+		return {
+			type: "image",
+			data: media.buffer.toString("base64"),
+			mimeType
+		};
+	} catch (err) {
+		log.debug(`Native image: failed to load ${ref.resolved}: ${formatErrorMessage(err)}`);
+		return null;
+	}
+}
+/**
+* Checks if a model supports image input based on its input capabilities.
+*
+* @param model The model object with input capability array
+* @returns True if the model supports image input
+*/
+function modelSupportsImages(model) {
+	return model.input?.includes("image") ?? false;
+}
+/**
+* Detects and loads images referenced in a prompt for models with vision capability.
+*
+* This function scans the prompt for image references (file paths and URLs),
+* loads them, and returns them as ImageContent array ready to be passed to
+* the model's prompt method.
+*
+* @param params Configuration for image detection and loading
+* @returns Object with loaded images for current prompt only
+*/
+async function detectAndLoadPromptImages(params) {
+	if (!modelSupportsImages(params.model)) return {
+		images: [],
+		detectedRefs: [],
+		loadedCount: 0,
+		skippedCount: 0
+	};
+	const allRefs = detectImageReferences(params.prompt);
+	if (allRefs.length === 0) return {
+		images: params.existingImages ?? [],
+		detectedRefs: [],
+		loadedCount: 0,
+		skippedCount: 0
+	};
+	log.debug(`Native image: detected ${allRefs.length} image refs in prompt`);
+	const { promptRefs, attachmentRefs } = splitPromptAndAttachmentRefs({
+		prompt: params.prompt,
+		refs: allRefs,
+		imageOrder: params.imageOrder
+	});
+	const promptRefImages = [];
+	const offloadedImages = [];
+	let loadedCount = 0;
+	let skippedCount = 0;
+	for (const ref of promptRefs) {
+		const image = await loadImageFromRef(ref, params.workspaceDir, {
+			maxBytes: params.maxBytes,
+			workspaceOnly: params.workspaceOnly,
+			sandbox: params.sandbox
+		});
+		if (image) {
+			promptRefImages.push(image);
+			loadedCount++;
+			log.debug(`Native image: loaded ${ref.type} ${ref.resolved}`);
+		} else skippedCount++;
+	}
+	for (const ref of attachmentRefs) {
+		const image = await loadImageFromRef(ref, params.workspaceDir, {
+			maxBytes: params.maxBytes,
+			workspaceOnly: params.workspaceOnly,
+			sandbox: params.sandbox
+		});
+		offloadedImages.push(image);
+		if (image) {
+			loadedCount++;
+			log.debug(`Native image: loaded ${ref.type} ${ref.resolved}`);
+		} else skippedCount++;
+	}
+	return {
+		images: await sanitizeImagesWithLog(mergePromptAttachmentImages({
+			imageOrder: params.imageOrder,
+			existingImages: params.existingImages,
+			offloadedImages,
+			promptRefImages
+		}), "prompt:images", { maxDimensionPx: params.maxDimensionPx }),
+		detectedRefs: allRefs,
+		loadedCount,
+		skippedCount
+	};
+}
+//#endregion
+export { detectImageReferences as n, loadImageFromRef as r, detectAndLoadPromptImages as t };

package/dist/inbound-reply-dispatch-CYtgAOpZ.js

@@ -0,0 +1,73 @@
+import { n as createNormalizedOutboundDeliverer } from "./reply-payload-ChFsXpe2.js";
+import { c as withReplyDispatcher, s as dispatchReplyFromConfig } from "./dispatch-CRDSpd0f.js";
+import { t as createChannelReplyPipeline } from "./channel-reply-pipeline-BgPhKdUO.js";
+//#region src/plugin-sdk/inbound-reply-dispatch.ts
+/** Run `dispatchReplyFromConfig` with a dispatcher that always gets its settled callback. */
+async function dispatchReplyFromConfigWithSettledDispatcher(params) {
+	return await withReplyDispatcher({
+		dispatcher: params.dispatcher,
+		onSettled: params.onSettled,
+		run: () => dispatchReplyFromConfig({
+			ctx: params.ctxPayload,
+			cfg: params.cfg,
+			dispatcher: params.dispatcher,
+			replyOptions: params.replyOptions,
+			configOverride: params.configOverride
+		})
+	});
+}
+/** Assemble the common inbound reply dispatch dependencies for a resolved route. */
+function buildInboundReplyDispatchBase(params) {
+	return {
+		cfg: params.cfg,
+		channel: params.channel,
+		accountId: params.accountId,
+		agentId: params.route.agentId,
+		routeSessionKey: params.route.sessionKey,
+		storePath: params.storePath,
+		ctxPayload: params.ctxPayload,
+		recordInboundSession: params.core.channel.session.recordInboundSession,
+		dispatchReplyWithBufferedBlockDispatcher: params.core.channel.reply.dispatchReplyWithBufferedBlockDispatcher
+	};
+}
+/** Resolve the shared dispatch base and immediately record + dispatch one inbound reply turn. */
+async function dispatchInboundReplyWithBase(params) {
+	await recordInboundSessionAndDispatchReply({
+		...buildInboundReplyDispatchBase(params),
+		deliver: params.deliver,
+		onRecordError: params.onRecordError,
+		onDispatchError: params.onDispatchError,
+		replyOptions: params.replyOptions
+	});
+}
+/** Record the inbound session first, then dispatch the reply using normalized outbound delivery. */
+async function recordInboundSessionAndDispatchReply(params) {
+	await params.recordInboundSession({
+		storePath: params.storePath,
+		sessionKey: params.ctxPayload.SessionKey ?? params.routeSessionKey,
+		ctx: params.ctxPayload,
+		onRecordError: params.onRecordError
+	});
+	const { onModelSelected, ...replyPipeline } = createChannelReplyPipeline({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		channel: params.channel,
+		accountId: params.accountId
+	});
+	const deliver = createNormalizedOutboundDeliverer(params.deliver);
+	await params.dispatchReplyWithBufferedBlockDispatcher({
+		ctx: params.ctxPayload,
+		cfg: params.cfg,
+		dispatcherOptions: {
+			...replyPipeline,
+			deliver,
+			onError: params.onDispatchError
+		},
+		replyOptions: {
+			...params.replyOptions,
+			onModelSelected
+		}
+	});
+}
+//#endregion
+export { recordInboundSessionAndDispatchReply as i, dispatchInboundReplyWithBase as n, dispatchReplyFromConfigWithSettledDispatcher as r, buildInboundReplyDispatchBase as t };

package/dist/index.js

@@ -27,7 +27,7 @@ let runExec;
 let saveSessionStore;
 let waitForever;
 async function loadLegacyCliDeps() {
-	const { runCli } = await import("./run-main-BLD1wTLU.js");
+	const { runCli } = await import("./run-main-Bc7hVWlB.js");
 	return { runCli };
 }
 async function runLegacyCliEntry(argv = process.argv, deps) {
@@ -35,7 +35,7 @@ async function runLegacyCliEntry(argv = process.argv, deps) {
 	await runCli(argv);
 }
 const isMain = isMainModule({ currentFile: fileURLToPath(import.meta.url) });
-if (!isMain) ({applyTemplate, createDefaultDeps, deriveSessionKey, describePortOwner, ensureBinary, ensurePortAvailable, getReplyFromConfig, handlePortError, loadConfig, loadSessionStore, monitorWebChannel, normalizeE164, PortInUseError, promptYesNo, resolveSessionKey, resolveStorePath, runCommandWithTimeout, runExec, saveSessionStore, waitForever} = await import("./library-DGd4UZKC.js"));
+if (!isMain) ({applyTemplate, createDefaultDeps, deriveSessionKey, describePortOwner, ensureBinary, ensurePortAvailable, getReplyFromConfig, handlePortError, loadConfig, loadSessionStore, monitorWebChannel, normalizeE164, PortInUseError, promptYesNo, resolveSessionKey, resolveStorePath, runCommandWithTimeout, runExec, saveSessionStore, waitForever} = await import("./library-BzChF6u9.js"));
 if (isMain) {
 	const { restoreTerminalState } = await import("./restore-Bq3mpjIz.js");
 	installUnhandledRejectionHandler();

package/dist/infra-runtime-DXR8kcRT.js

@@ -0,0 +1,39 @@
+import "./errors-Jbvi20TW.js";
+import "./env-CLDDxlAx.js";
+import "./file-lock-COJsWxeA.js";
+import "./heartbeat-summary-Dri6qdcY.js";
+import "./ssrf-Blp2w01T.js";
+import "./undici-global-dispatcher-n010VK9i.js";
+import "./fetch-guard-DKzLBD09.js";
+import "./fs-safe-Dbuf-IZV.js";
+import "./exec-approvals-BD-zKkI1.js";
+import "./proxy-fetch-DUI641Ve.js";
+import { n as drainPendingDeliveries$1 } from "./delivery-queue-DynIYkyI.js";
+import "./system-events-CXxVc5Du.js";
+import "./retry-UR2J2jUF.js";
+import "./secret-file-CM0P-Rsm.js";
+import "./http-body-DDG39e3E.js";
+import "./exec-approval-reply-CwnSisXg.js";
+import "./approval-native-runtime-c-AA06Kd.js";
+import "./exec-approval-command-display-BmFgYBPz.js";
+import "./exec-approval-session-target-BcyDQz_G.js";
+import "./heartbeat-visibility-BnRwGAOP.js";
+import "./transport-ready-cakWXLl3.js";
+import "./identity-BtEqwuA4.js";
+import "./retry-policy-CEf4_Mv8.js";
+import "./ssrf-policy-l2DzrZX2.js";
+//#region src/plugin-sdk/infra-runtime.ts
+let outboundDeliverRuntimePromise = null;
+async function loadOutboundDeliverRuntime() {
+	outboundDeliverRuntimePromise ??= import("./deliver-runtime-BvDWmZrW.js");
+	return await outboundDeliverRuntimePromise;
+}
+async function drainPendingDeliveries(opts) {
+	const deliver = opts.deliver ?? (await loadOutboundDeliverRuntime()).deliverOutboundPayloads;
+	await drainPendingDeliveries$1({
+		...opts,
+		deliver
+	});
+}
+//#endregion
+export { drainPendingDeliveries as t };

package/dist/init-CjPPA1H0.js

@@ -0,0 +1,59 @@
+import { r as registerContextEngineForOwner } from "./registry-rRTGE3gH.js";
+import { n as delegateCompactionToRuntime } from "./delegate-Bd-FPQqY.js";
+//#region src/context-engine/legacy.ts
+/**
+* LegacyContextEngine wraps the existing compaction behavior behind the
+* ContextEngine interface, preserving 100% backward compatibility.
+*
+* - ingest: no-op (SessionManager handles message persistence)
+* - assemble: pass-through (existing sanitize/validate/limit pipeline in attempt.ts handles this)
+* - compact: delegates to compactEmbeddedPiSessionDirect
+*/
+var LegacyContextEngine = class {
+	constructor() {
+		this.info = {
+			id: "legacy",
+			name: "Legacy Context Engine",
+			version: "1.0.0"
+		};
+	}
+	async ingest(_params) {
+		return { ingested: false };
+	}
+	async assemble(params) {
+		return {
+			messages: params.messages,
+			estimatedTokens: 0
+		};
+	}
+	async afterTurn(_params) {}
+	async compact(params) {
+		return await delegateCompactionToRuntime(params);
+	}
+	async dispose() {}
+};
+//#endregion
+//#region src/context-engine/legacy.registration.ts
+function registerLegacyContextEngine() {
+	registerContextEngineForOwner("legacy", async () => new LegacyContextEngine(), "core", { allowSameOwnerRefresh: true });
+}
+//#endregion
+//#region src/context-engine/init.ts
+/**
+* Ensures all built-in context engines are registered exactly once.
+*
+* The legacy engine is always registered as a safe fallback so that
+* `resolveContextEngine()` can resolve the default "legacy" slot without
+* callers needing to remember manual registration.
+*
+* Additional engines are registered by their own plugins via
+* `api.registerContextEngine()` during plugin load.
+*/
+let initialized = false;
+function ensureContextEnginesInitialized() {
+	if (initialized) return;
+	initialized = true;
+	registerLegacyContextEngine();
+}
+//#endregion
+export { ensureContextEnginesInitialized as t };