dsh-mnemon 0.4.7 → 0.5.0

package/lib/kernel.js

@@ -1,1173 +0,0 @@
-import { MEMORY_CAPABILITIES } from "./contracts.js";
-import { createHash, randomUUID } from "node:crypto";
-//#region packages/kernel/src/catalog.ts
-const COMPONENT_ID = /^[a-z][a-z0-9-]{0,127}$/u;
-function componentId(value, label) {
-	const normalized = value.trim();
-	if (!COMPONENT_ID.test(normalized)) throw new Error(`${label} must match [a-z][a-z0-9-]{0,127}`);
-	return normalized;
-}
-function nonEmpty(value, label, max = 500) {
-	const normalized = value.trim();
-	if (normalized === "") throw new Error(`${label} is required`);
-	if (normalized.length > max) throw new Error(`${label} is too long (max ${max} characters)`);
-	return normalized;
-}
-function cloneLayer$1(descriptor) {
-	if (!Number.isFinite(descriptor.order)) throw new Error("memory layer order must be finite");
-	const capabilities = [...new Set(descriptor.capabilities)];
-	if (capabilities.length === 0) throw new Error("memory layer must declare at least one capability");
-	return Object.freeze({
-		id: componentId(descriptor.id, "memory layer id"),
-		label: nonEmpty(descriptor.label, "memory layer label", 100),
-		description: nonEmpty(descriptor.description, "memory layer description"),
-		role: componentId(descriptor.role, "memory layer role"),
-		order: descriptor.order,
-		capabilities: Object.freeze(capabilities)
-	});
-}
-function cloneAdapter(descriptor) {
-	return Object.freeze({
-		id: componentId(descriptor.id, "memory adapter id"),
-		label: nonEmpty(descriptor.label, "memory adapter label", 100),
-		description: nonEmpty(descriptor.description, "memory adapter description"),
-		locality: descriptor.locality,
-		scopes: Object.freeze([...new Set(descriptor.scopes)]),
-		capabilities: Object.freeze([...new Set(descriptor.capabilities)]),
-		...descriptor.configNamespace === void 0 ? {} : { configNamespace: componentId(descriptor.configNamespace, "memory adapter config namespace") }
-	});
-}
-function cloneStrategy(descriptor) {
-	return Object.freeze({
-		id: componentId(descriptor.id, "memory strategy id"),
-		version: nonEmpty(descriptor.version, "memory strategy version", 100),
-		label: nonEmpty(descriptor.label, "memory strategy label", 100),
-		description: nonEmpty(descriptor.description, "memory strategy description"),
-		hooks: Object.freeze([...new Set(descriptor.hooks)]),
-		deterministic: descriptor.deterministic
-	});
-}
-/** Host-global contribution directory. Registrations are owned by their caller's lifecycle. */
-var MemoryCatalog = class {
-	layers = /* @__PURE__ */ new Map();
-	adapters = /* @__PURE__ */ new Map();
-	strategies = /* @__PURE__ */ new Map();
-	listeners = /* @__PURE__ */ new Set();
-	currentGeneration = 0;
-	get generation() {
-		return this.currentGeneration;
-	}
-	registerLayer(registration) {
-		const descriptor = cloneLayer$1(registration.descriptor);
-		const value = Object.freeze({
-			descriptor,
-			...registration.execute === void 0 ? {} : { execute: registration.execute }
-		});
-		return this.register(this.layers, descriptor.id, value);
-	}
-	registerAdapter(registration) {
-		const descriptor = cloneAdapter(registration.descriptor);
-		return this.register(this.adapters, descriptor.id, Object.freeze({ descriptor }));
-	}
-	registerStrategy(registration) {
-		const descriptor = cloneStrategy(registration.descriptor);
-		return this.register(this.strategies, descriptor.id, Object.freeze({
-			descriptor,
-			propose: registration.propose
-		}));
-	}
-	layer(id) {
-		return this.layers.get(id);
-	}
-	adapter(id) {
-		return this.adapters.get(id);
-	}
-	strategy(id) {
-		return this.strategies.get(id);
-	}
-	snapshot() {
-		return {
-			generation: this.currentGeneration,
-			layers: [...this.layers.values()].map((item) => ({
-				...item.descriptor,
-				capabilities: [...item.descriptor.capabilities]
-			})).sort((left, right) => left.order - right.order || left.id.localeCompare(right.id)),
-			adapters: [...this.adapters.values()].map((item) => ({
-				...item.descriptor,
-				scopes: [...item.descriptor.scopes],
-				capabilities: [...item.descriptor.capabilities]
-			})).sort((left, right) => left.id.localeCompare(right.id)),
-			strategies: [...this.strategies.values()].map((item) => ({
-				...item.descriptor,
-				hooks: [...item.descriptor.hooks]
-			})).sort((left, right) => left.id.localeCompare(right.id))
-		};
-	}
-	subscribe(listener) {
-		this.listeners.add(listener);
-		return () => this.listeners.delete(listener);
-	}
-	register(registry, id, value) {
-		if (registry.has(id)) throw new Error(`memory catalog component is already registered: ${id}`);
-		registry.set(id, value);
-		this.changed();
-		let active = true;
-		return () => {
-			if (!active) return;
-			active = false;
-			if (registry.get(id) !== value) return;
-			registry.delete(id);
-			this.changed();
-		};
-	}
-	changed() {
-		this.currentGeneration += 1;
-		const snapshot = this.snapshot();
-		for (const listener of this.listeners) listener(snapshot);
-	}
-};
-//#endregion
-//#region packages/kernel/src/access.ts
-function participationChannel(capability) {
-	if (capability === "project") return "projection";
-	if ([
-		"write",
-		"archive",
-		"link",
-		"forget",
-		"import"
-	].includes(capability)) return "write";
-	if ([
-		"maintain",
-		"export",
-		"status"
-	].includes(capability)) return "maintenance";
-	return "recall";
-}
-/** Evaluate one topology boundary without invoking strategy or data-plane code. */
-function decideMemoryLayerParticipation(layer, capability, trigger) {
-	const channel = participationChannel(capability);
-	const mode = layer.participation[channel];
-	const base = {
-		layerId: layer.id,
-		capability,
-		trigger,
-		channel,
-		mode
-	};
-	if (!layer.enabled) return {
-		...base,
-		allowed: false,
-		reason: `memory layer ${layer.id} is disabled by the active topology`
-	};
-	if (mode === "off") return {
-		...base,
-		allowed: false,
-		reason: `memory layer ${layer.id} has ${channel} participation turned off`
-	};
-	if (trigger !== "manual" && mode !== "automatic") return {
-		...base,
-		allowed: false,
-		reason: `memory layer ${layer.id} allows ${channel} only for manual operations`
-	};
-	return {
-		...base,
-		allowed: true
-	};
-}
-function assertMemoryLayerParticipation(layer, capability, trigger) {
-	const decision = decideMemoryLayerParticipation(layer, capability, trigger);
-	if (!decision.allowed) throw new Error(decision.reason);
-	return decision;
-}
-//#endregion
-//#region packages/kernel/src/kernel.ts
-function errorText(error) {
-	return error instanceof Error ? error.message : String(error);
-}
-function aborted(signal) {
-	return signal?.aborted === true;
-}
-const MEMORY_CAPABILITY_SET = new Set(MEMORY_CAPABILITIES);
-const MEMORY_TRIGGER_SET = /* @__PURE__ */ new Set([
-	"manual",
-	"automatic",
-	"system"
-]);
-const MEMORY_STORAGE_SET = /* @__PURE__ */ new Set([
-	"global",
-	"workspace",
-	"custom"
-]);
-const MAX_ISSUED_PLANS = 1024;
-function canonical$1(value, label = "memory value", ancestors = /* @__PURE__ */ new Set(), depth = 0) {
-	if (depth > 64) throw new Error(`${label} is nested too deeply`);
-	if (value === null || typeof value === "boolean" || typeof value === "string") return JSON.stringify(value);
-	if (typeof value === "number") {
-		if (!Number.isFinite(value)) throw new Error(`${label} contains a non-finite number`);
-		return JSON.stringify(value);
-	}
-	if (Array.isArray(value)) {
-		if (ancestors.has(value)) throw new Error(`${label} contains a cycle`);
-		ancestors.add(value);
-		const items = [];
-		for (let index = 0; index < value.length; index += 1) {
-			if (!(index in value)) throw new Error(`${label} contains a sparse array`);
-			items.push(canonical$1(value[index], label, ancestors, depth + 1));
-		}
-		ancestors.delete(value);
-		return `[${items.join(",")}]`;
-	}
-	if (typeof value !== "object") throw new Error(`${label} contains a non-JSON value`);
-	const prototype = Object.getPrototypeOf(value);
-	if (prototype !== Object.prototype && prototype !== null) throw new Error(`${label} contains a non-plain JSON object`);
-	if (ancestors.has(value)) throw new Error(`${label} contains a cycle`);
-	ancestors.add(value);
-	const rendered = Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => {
-		if (key.length > 1e3) throw new Error(`${label} contains an oversized key`);
-		return `${JSON.stringify(key)}:${canonical$1(item, label, ancestors, depth + 1)}`;
-	});
-	ancestors.delete(value);
-	return `{${rendered.join(",")}}`;
-}
-function digest(value, label) {
-	return createHash("sha256").update(canonical$1(value, label)).digest("hex");
-}
-function deepFreeze$1(value) {
-	if (typeof value !== "object" || value === null || Object.isFrozen(value)) return value;
-	for (const child of Object.values(value)) deepFreeze$1(child);
-	return Object.freeze(value);
-}
-function jsonClone(value, label) {
-	canonical$1(value, label);
-	return structuredClone(value);
-}
-function requiredText(value, label, maximum) {
-	if (typeof value !== "string") throw new Error(`${label} must be a string`);
-	const normalized = value.trim();
-	if (normalized === "") throw new Error(`${label} is required`);
-	if (normalized.length > maximum) throw new Error(`${label} is too long (max ${maximum} characters)`);
-	return normalized;
-}
-function optionalText(value, label, maximum) {
-	if (value === void 0) return void 0;
-	return requiredText(value, label, maximum);
-}
-function normalizedIds(value, label) {
-	if (value === void 0) return void 0;
-	if (!Array.isArray(value)) throw new Error(`${label} must be an array`);
-	const ids = [...new Set(value.map((item) => requiredText(item, `${label} entry`, 128)))];
-	if (ids.length === 0) return [];
-	if (ids.length > 1e3) throw new Error(`${label} contains too many entries`);
-	return ids;
-}
-function normalizeRequest(request) {
-	if (typeof request !== "object" || request === null) throw new Error("memory plan request must be an object");
-	const operation = requiredText(request.operation, "memory operation", 200);
-	if (!MEMORY_CAPABILITY_SET.has(request.capability)) throw new Error(`unsupported memory capability: ${String(request.capability)}`);
-	if (!MEMORY_TRIGGER_SET.has(request.trigger)) throw new Error(`unsupported memory operation trigger: ${String(request.trigger)}`);
-	if (typeof request.scope !== "object" || request.scope === null) throw new Error("memory operation scope must be an object");
-	if (!MEMORY_STORAGE_SET.has(request.scope.storage)) throw new Error(`unsupported memory storage scope: ${String(request.scope.storage)}`);
-	const workspaceId = optionalText(request.scope.workspaceId, "memory workspace id", 2e3);
-	const sessionId = optionalText(request.scope.sessionId, "memory session id", 300);
-	const agentId = optionalText(request.scope.agentId, "memory agent id", 300);
-	const candidateLayerIds = normalizedIds(request.candidateLayerIds, "memory candidate layer ids");
-	const adapterIds = normalizedIds(request.adapterIds, "memory adapter ids");
-	const budget = request.budget === void 0 ? void 0 : jsonClone(request.budget, "memory operation budget");
-	const input = request.input === void 0 ? void 0 : jsonClone(request.input, "memory operation input");
-	const normalized = {
-		operation,
-		capability: request.capability,
-		trigger: request.trigger,
-		scope: {
-			storage: request.scope.storage,
-			...workspaceId === void 0 ? {} : { workspaceId },
-			...sessionId === void 0 ? {} : { sessionId },
-			...agentId === void 0 ? {} : { agentId }
-		},
-		...candidateLayerIds === void 0 ? {} : { candidateLayerIds },
-		...adapterIds === void 0 ? {} : { adapterIds },
-		...budget === void 0 ? {} : { budget },
-		...input === void 0 ? {} : { input }
-	};
-	checkBudget(normalized);
-	return deepFreeze$1(normalized);
-}
-function checkBudget(request) {
-	const budget = request.budget;
-	if (budget?.maxSteps !== void 0 && (!Number.isInteger(budget.maxSteps) || budget.maxSteps < 1 || budget.maxSteps > 100)) throw new Error("memory plan maxSteps must be an integer within 1..100");
-	if (budget?.maxResults !== void 0 && (!Number.isInteger(budget.maxResults) || budget.maxResults < 1 || budget.maxResults > 1e4)) throw new Error("memory plan maxResults must be an integer within 1..10000");
-	if (budget?.maxTokens !== void 0 && (!Number.isInteger(budget.maxTokens) || budget.maxTokens < 1 || budget.maxTokens > 1e7)) throw new Error("memory plan maxTokens must be an integer within 1..10000000");
-	if (budget?.timeoutMs !== void 0 && (!Number.isInteger(budget.timeoutMs) || budget.timeoutMs < 1 || budget.timeoutMs > 36e5)) throw new Error("memory plan timeoutMs must be an integer within 1..3600000");
-}
-/** Plans and executes bounded operations without granting strategies direct data-plane access. */
-var MemoryKernel = class {
-	catalog;
-	topology;
-	guards = /* @__PURE__ */ new Map();
-	currentGuardGeneration = 0;
-	now;
-	id;
-	receiptSinks = /* @__PURE__ */ new Set();
-	issuedPlans = /* @__PURE__ */ new Map();
-	constructor(catalog, topology, options = {}) {
-		this.catalog = catalog;
-		this.topology = topology;
-		this.now = options.now ?? (() => /* @__PURE__ */ new Date());
-		this.id = options.id ?? randomUUID;
-		if (options.receiptSink !== void 0) this.receiptSinks.add(options.receiptSink);
-	}
-	get guardGeneration() {
-		return this.currentGuardGeneration;
-	}
-	registerReceiptSink(sink) {
-		this.receiptSinks.add(sink);
-		let active = true;
-		return () => {
-			if (!active) return;
-			active = false;
-			this.receiptSinks.delete(sink);
-		};
-	}
-	descriptor() {
-		return {
-			catalog: this.catalog.snapshot(),
-			topology: this.topology.snapshot()
-		};
-	}
-	participation(layerId, capability, trigger) {
-		const descriptor = this.catalog.layer(layerId)?.descriptor;
-		if (descriptor === void 0) return {
-			allowed: false,
-			layerId,
-			capability,
-			trigger,
-			channel: participationChannel(capability),
-			mode: "off",
-			reason: `memory layer is unavailable: ${layerId}`
-		};
-		if (!descriptor.capabilities.includes(capability)) return {
-			allowed: false,
-			layerId,
-			capability,
-			trigger,
-			channel: participationChannel(capability),
-			mode: "off",
-			reason: `memory layer ${layerId} does not support ${capability}`
-		};
-		const layer = this.topology.snapshot().layers.find((item) => item.id === layerId);
-		if (layer === void 0) return {
-			allowed: false,
-			layerId,
-			capability,
-			trigger,
-			channel: participationChannel(capability),
-			mode: "off",
-			reason: `memory layer is not configured in the active topology: ${layerId}`
-		};
-		return decideMemoryLayerParticipation(layer, capability, trigger);
-	}
-	allows(layerId, capability, trigger) {
-		return this.participation(layerId, capability, trigger).allowed;
-	}
-	assertParticipation(layerId, capability, trigger) {
-		const layer = this.topology.snapshot().layers.find((item) => item.id === layerId);
-		if (layer === void 0) throw new Error(`memory layer is not configured in the active topology: ${layerId}`);
-		const descriptor = this.catalog.layer(layerId)?.descriptor;
-		if (descriptor === void 0) throw new Error(`memory layer is unavailable: ${layerId}`);
-		if (!descriptor.capabilities.includes(capability)) throw new Error(`memory layer ${layerId} does not support ${capability}`);
-		return assertMemoryLayerParticipation(layer, capability, trigger);
-	}
-	registerGuard(guard) {
-		const id = guard.id.trim();
-		if (!/^[a-z][a-z0-9-]{0,127}$/u.test(id)) throw new Error("memory guard id must match [a-z][a-z0-9-]{0,127}");
-		if (this.guards.has(id)) throw new Error(`memory guard is already registered: ${id}`);
-		const registration = Object.freeze({
-			id,
-			decide: guard.decide
-		});
-		this.guards.set(id, registration);
-		this.currentGuardGeneration += 1;
-		let active = true;
-		return () => {
-			if (!active) return;
-			active = false;
-			if (this.guards.get(id) !== registration) return;
-			this.guards.delete(id);
-			this.currentGuardGeneration += 1;
-		};
-	}
-	async plan(request) {
-		const normalizedRequest = normalizeRequest(request);
-		const descriptor = deepFreeze$1(jsonClone(this.descriptor(), "memory system descriptor"));
-		const guardGeneration = this.currentGuardGeneration;
-		const guards = [...this.guards.values()];
-		const strategy = this.catalog.strategy(descriptor.topology.strategyId);
-		if (strategy === void 0) throw new Error(`active memory strategy is unavailable: ${descriptor.topology.strategyId}`);
-		for (const guard of guards) {
-			const decision = await guard.decide(normalizedRequest, { descriptor });
-			if (typeof decision !== "object" || decision === null || decision.kind !== "allow" && decision.kind !== "deny") throw new Error(`memory guard returned an invalid decision: ${guard.id}`);
-			if (decision.kind === "deny") throw new Error(`memory operation denied by ${guard.id}: ${decision.reason}`);
-		}
-		const proposal = await strategy.propose(normalizedRequest, descriptor);
-		if (proposal.strategyId !== strategy.descriptor.id || proposal.strategyVersion !== strategy.descriptor.version) throw new Error("memory strategy proposal identity does not match its registration");
-		if (proposal.steps.length === 0) throw new Error(`memory strategy produced no executable steps: ${proposal.reason}`);
-		const maxSteps = normalizedRequest.budget?.maxSteps ?? 32;
-		if (proposal.steps.length > maxSteps) throw new Error(`memory strategy proposed ${proposal.steps.length} steps; budget allows ${maxSteps}`);
-		const planId = this.id();
-		const steps = proposal.steps.map((step, index) => {
-			const layerId = requiredText(step.layerId, "memory plan step layer id", 128);
-			const adapterId = optionalText(step.adapterId, "memory plan step adapter id", 128);
-			const candidate = {
-				layerId,
-				capability: step.capability,
-				...adapterId === void 0 ? {} : { adapterId }
-			};
-			const participation = this.validateStep(candidate, normalizedRequest, descriptor, "memory strategy");
-			const input = step.input === void 0 ? void 0 : jsonClone(step.input, "memory plan step input");
-			return {
-				...candidate,
-				...input === void 0 ? {} : { input },
-				id: `${planId}:${index + 1}`,
-				participation
-			};
-		});
-		const current = this.descriptor();
-		if (current.catalog.generation !== descriptor.catalog.generation || current.topology.generation !== descriptor.topology.generation || this.currentGuardGeneration !== guardGeneration) throw new Error("memory planning inputs changed while the plan was being compiled");
-		const requestDigest = digest(normalizedRequest, "memory plan request");
-		const plan = deepFreeze$1({
-			id: planId,
-			topologyId: descriptor.topology.id,
-			topologyGeneration: descriptor.topology.generation,
-			catalogGeneration: descriptor.catalog.generation,
-			guardGeneration,
-			strategyId: proposal.strategyId,
-			strategyVersion: proposal.strategyVersion,
-			operation: normalizedRequest.operation,
-			capability: normalizedRequest.capability,
-			trigger: normalizedRequest.trigger,
-			scope: { ...normalizedRequest.scope },
-			request: normalizedRequest,
-			requestDigest,
-			reason: requiredText(proposal.reason, "memory strategy proposal reason", 4e3),
-			createdAt: this.now().toISOString(),
-			budget: { ...normalizedRequest.budget },
-			steps
-		});
-		this.rememberPlan(plan);
-		return plan;
-	}
-	async execute(plan, request, signal) {
-		const issued = this.issuedPlans.get(plan.id);
-		if (issued === void 0) throw new Error("memory plan was not issued by this Kernel or was already claimed");
-		let suppliedPlanDigest;
-		try {
-			suppliedPlanDigest = digest(plan, "memory plan");
-		} catch (error) {
-			throw new Error(`memory plan is invalid: ${errorText(error)}`);
-		}
-		if (suppliedPlanDigest !== issued.planDigest) throw new Error("memory plan changed after authorization");
-		if (digest(normalizeRequest(request), "memory execution request") !== issued.requestDigest) throw new Error("memory plan does not match the complete execution request");
-		const authorizedPlan = issued.plan;
-		const authorizedRequest = authorizedPlan.request;
-		const current = this.descriptor();
-		if (authorizedPlan.topologyGeneration !== current.topology.generation || authorizedPlan.catalogGeneration !== current.catalog.generation) throw new Error("memory plan is stale; re-plan against the active generation");
-		if (authorizedPlan.guardGeneration !== this.currentGuardGeneration) throw new Error("memory plan is stale; re-plan against the active guards");
-		if (authorizedPlan.topologyId !== current.topology.id) throw new Error("memory plan topology identity does not match the active topology");
-		const strategy = this.catalog.strategy(current.topology.strategyId);
-		if (strategy === void 0 || strategy.descriptor.id !== authorizedPlan.strategyId || strategy.descriptor.version !== authorizedPlan.strategyVersion) throw new Error("memory plan strategy identity does not match the active strategy");
-		if (authorizedPlan.steps.length === 0 || authorizedPlan.steps.length > (authorizedRequest.budget?.maxSteps ?? 32)) throw new Error("memory plan step count exceeds its authorized budget");
-		for (const step of authorizedPlan.steps) {
-			const participation = this.validateStep(step, authorizedRequest, current, "memory plan");
-			if (step.participation !== participation) throw new Error(`memory plan participation changed for step ${step.id}`);
-		}
-		const executableSteps = authorizedPlan.steps.map((step) => {
-			const layer = this.catalog.layer(step.layerId);
-			return {
-				step,
-				execute: layer?.execute?.bind(layer)
-			};
-		});
-		const executionTopology = deepFreeze$1(jsonClone(current.topology, "memory execution topology"));
-		if (this.issuedPlans.get(authorizedPlan.id) !== issued) throw new Error("memory plan was already claimed");
-		this.issuedPlans.delete(authorizedPlan.id);
-		const startedAt = this.now().toISOString();
-		const steps = [];
-		for (const executable of executableSteps) {
-			const { step, execute } = executable;
-			const stepStartedAt = this.now().toISOString();
-			if (aborted(signal)) {
-				steps.push({
-					stepId: step.id,
-					layerId: step.layerId,
-					...step.adapterId === void 0 ? {} : { adapterId: step.adapterId },
-					status: "cancelled",
-					startedAt: stepStartedAt,
-					finishedAt: this.now().toISOString(),
-					error: "operation cancelled"
-				});
-				continue;
-			}
-			if (execute === void 0) {
-				steps.push({
-					stepId: step.id,
-					layerId: step.layerId,
-					...step.adapterId === void 0 ? {} : { adapterId: step.adapterId },
-					status: "failed",
-					startedAt: stepStartedAt,
-					finishedAt: this.now().toISOString(),
-					error: `memory layer has no executor: ${step.layerId}`
-				});
-				continue;
-			}
-			const context = {
-				planId: authorizedPlan.id,
-				topology: executionTopology,
-				request: authorizedRequest,
-				...signal === void 0 ? {} : { signal }
-			};
-			try {
-				const output = deepFreeze$1(jsonClone(await execute(step, context), "memory layer output"));
-				steps.push({
-					stepId: step.id,
-					layerId: step.layerId,
-					...step.adapterId === void 0 ? {} : { adapterId: step.adapterId },
-					status: "succeeded",
-					startedAt: stepStartedAt,
-					finishedAt: this.now().toISOString(),
-					output
-				});
-			} catch (error) {
-				const status = aborted(signal) ? "cancelled" : "failed";
-				steps.push({
-					stepId: step.id,
-					layerId: step.layerId,
-					...step.adapterId === void 0 ? {} : { adapterId: step.adapterId },
-					status,
-					startedAt: stepStartedAt,
-					finishedAt: this.now().toISOString(),
-					error: errorText(error)
-				});
-			}
-		}
-		const succeeded = steps.filter((step) => step.status === "succeeded").length;
-		const cancelled = steps.filter((step) => step.status === "cancelled").length;
-		let status;
-		if (steps.length > 0 && cancelled === steps.length) status = "cancelled";
-		else if (succeeded === steps.length) status = "succeeded";
-		else if (succeeded > 0) status = "partial";
-		else status = "failed";
-		const receipt = {
-			id: this.id(),
-			planId: authorizedPlan.id,
-			topologyId: authorizedPlan.topologyId,
-			topologyGeneration: authorizedPlan.topologyGeneration,
-			catalogGeneration: authorizedPlan.catalogGeneration,
-			guardGeneration: authorizedPlan.guardGeneration,
-			strategyId: authorizedPlan.strategyId,
-			strategyVersion: authorizedPlan.strategyVersion,
-			operation: authorizedPlan.operation,
-			capability: authorizedRequest.capability,
-			status,
-			startedAt,
-			finishedAt: this.now().toISOString(),
-			steps
-		};
-		for (const sink of this.receiptSinks) await sink.append(receipt);
-		return receipt;
-	}
-	async run(request, signal) {
-		const plan = await this.plan(request);
-		return {
-			plan,
-			receipt: await this.execute(plan, request, signal)
-		};
-	}
-	validateStep(step, request, descriptor, source) {
-		if (step.capability !== request.capability) throw new Error(`${source} cannot change the requested capability`);
-		if (request.candidateLayerIds !== void 0 && !request.candidateLayerIds.includes(step.layerId)) throw new Error(`${source} selected a layer outside the request candidates: ${step.layerId}`);
-		const topologyLayer = descriptor.topology.layers.find((layer) => layer.id === step.layerId);
-		const catalogLayer = descriptor.catalog.layers.find((layer) => layer.id === step.layerId);
-		if (topologyLayer === void 0 || catalogLayer === void 0) throw new Error(`${source} selected an unavailable layer: ${step.layerId}`);
-		if (!topologyLayer.enabled) throw new Error(`${source} selected a disabled layer: ${step.layerId}`);
-		if (!catalogLayer.capabilities.includes(step.capability)) throw new Error(`memory layer ${step.layerId} does not support ${step.capability}`);
-		const participation = participationChannel(step.capability);
-		const mode = topologyLayer.participation[participation];
-		if (mode === "off" || request.trigger !== "manual" && mode !== "automatic") throw new Error(`memory layer ${step.layerId} does not allow ${request.trigger} ${participation}`);
-		if (step.adapterId !== void 0) {
-			if (request.adapterIds !== void 0 && !request.adapterIds.includes(step.adapterId)) throw new Error(`${source} selected an adapter outside the request candidates: ${step.adapterId}`);
-			if (!topologyLayer.adapterIds.includes(step.adapterId)) throw new Error(`memory adapter ${step.adapterId} is not bound to ${step.layerId}`);
-			const adapter = descriptor.catalog.adapters.find((item) => item.id === step.adapterId);
-			if (adapter === void 0 || !adapter.capabilities.includes(step.capability)) throw new Error(`memory adapter ${step.adapterId} does not support ${step.capability}`);
-		}
-		return participation;
-	}
-	rememberPlan(plan) {
-		this.issuedPlans.set(plan.id, {
-			plan,
-			planDigest: digest(plan, "memory plan"),
-			requestDigest: plan.requestDigest
-		});
-		while (this.issuedPlans.size > MAX_ISSUED_PLANS) {
-			const oldest = this.issuedPlans.keys().next().value;
-			if (oldest === void 0) break;
-			this.issuedPlans.delete(oldest);
-		}
-	}
-};
-//#endregion
-//#region packages/kernel/src/topology.ts
-const TOPOLOGY_ID = /^[a-z][a-z0-9-]{0,127}$/u;
-const PARTICIPATION_MODES = /* @__PURE__ */ new Set([
-	"off",
-	"manual",
-	"automatic"
-]);
-const DISCOVERED_LAYER_PARTICIPATION = {
-	recall: "manual",
-	write: "manual",
-	projection: "manual",
-	maintenance: "manual"
-};
-function cloneLayer(value) {
-	for (const [channel, mode] of Object.entries(value.participation)) if (!PARTICIPATION_MODES.has(mode)) throw new Error(`unsupported ${channel} participation mode: ${String(mode)}`);
-	return {
-		id: value.id,
-		enabled: value.enabled,
-		participation: { ...value.participation },
-		adapterIds: [...new Set(value.adapterIds)]
-	};
-}
-function cloneDefinition(value) {
-	const id = value.id.trim();
-	const strategyId = value.strategyId.trim();
-	if (!TOPOLOGY_ID.test(id)) throw new Error("memory topology id must match [a-z][a-z0-9-]{0,127}");
-	if (!TOPOLOGY_ID.test(strategyId)) throw new Error("memory topology strategy id must match [a-z][a-z0-9-]{0,127}");
-	const layers = value.layers.map(cloneLayer);
-	if (new Set(layers.map((item) => item.id)).size !== layers.length) throw new Error("memory topology contains duplicate layers");
-	return {
-		id,
-		strategyId,
-		layers
-	};
-}
-/** Atomic, versioned topology state. Per-operation callers pin one returned snapshot. */
-var MemoryTopologyManager = class {
-	catalog;
-	now;
-	current;
-	currentGeneration = 0;
-	listeners = /* @__PURE__ */ new Set();
-	unsubscribeCatalog;
-	constructor(catalog, initial, now = () => /* @__PURE__ */ new Date()) {
-		this.catalog = catalog;
-		this.now = now;
-		this.replace(initial);
-		this.unsubscribeCatalog = catalog.subscribe((snapshot) => this.reconcileCatalog(snapshot));
-	}
-	snapshot() {
-		if (this.current === void 0) throw new Error("memory topology is unavailable");
-		return {
-			...this.current,
-			layers: this.current.layers.map(cloneLayer)
-		};
-	}
-	replace(definition) {
-		const candidate = cloneDefinition(definition);
-		this.validate(candidate);
-		const previous = this.current;
-		this.currentGeneration += 1;
-		this.current = {
-			...candidate,
-			generation: this.currentGeneration,
-			catalogGeneration: this.catalog.generation,
-			createdAt: this.now().toISOString()
-		};
-		const snapshot = this.snapshot();
-		for (const listener of this.listeners) listener(snapshot, previous);
-		return snapshot;
-	}
-	configureLayer(id, patch) {
-		const current = this.snapshot();
-		if (current.layers.find((item) => item.id === id) === void 0) throw new Error(`memory topology layer is not configured: ${id}`);
-		return this.replace({
-			id: current.id,
-			strategyId: current.strategyId,
-			layers: current.layers.map((item) => item.id !== id ? item : {
-				...item,
-				enabled: patch.enabled ?? item.enabled,
-				participation: {
-					...item.participation,
-					...patch.participation
-				},
-				adapterIds: patch.adapterIds ?? item.adapterIds
-			})
-		});
-	}
-	subscribe(listener) {
-		this.listeners.add(listener);
-		return () => this.listeners.delete(listener);
-	}
-	/** Stop following Catalog changes while preserving this generation for pinned operations. */
-	dispose() {
-		this.unsubscribeCatalog();
-		this.listeners.clear();
-	}
-	reconcileCatalog(catalog) {
-		if (this.current === void 0) return;
-		const availableLayers = new Set(catalog.layers.map((layer) => layer.id));
-		const availableAdapters = new Set(catalog.adapters.map((adapter) => adapter.id));
-		const layers = this.current.layers.filter((layer) => availableLayers.has(layer.id)).map((layer) => ({
-			...layer,
-			participation: { ...layer.participation },
-			adapterIds: layer.adapterIds.filter((id) => availableAdapters.has(id))
-		}));
-		const configured = new Set(layers.map((layer) => layer.id));
-		for (const descriptor of catalog.layers) {
-			if (configured.has(descriptor.id)) continue;
-			layers.push({
-				id: descriptor.id,
-				enabled: false,
-				participation: { ...DISCOVERED_LAYER_PARTICIPATION },
-				adapterIds: []
-			});
-		}
-		const previous = this.current;
-		this.currentGeneration += 1;
-		this.current = {
-			id: previous.id,
-			strategyId: previous.strategyId,
-			layers,
-			generation: this.currentGeneration,
-			catalogGeneration: catalog.generation,
-			createdAt: this.now().toISOString()
-		};
-		const snapshot = this.snapshot();
-		for (const listener of this.listeners) listener(snapshot, previous);
-	}
-	validate(definition) {
-		if (this.catalog.strategy(definition.strategyId) === void 0) throw new Error(`memory topology references an unavailable strategy: ${definition.strategyId}`);
-		for (const item of definition.layers) {
-			if (this.catalog.layer(item.id) === void 0) throw new Error(`memory topology references an unavailable layer: ${item.id}`);
-			for (const adapterId of item.adapterIds) if (this.catalog.adapter(adapterId) === void 0) throw new Error(`memory topology references an unavailable adapter: ${adapterId}`);
-		}
-	}
-};
-//#endregion
-//#region packages/kernel/src/view.ts
-const MUTATION_CAPABILITIES = /* @__PURE__ */ new Set([
-	"write",
-	"archive",
-	"link",
-	"forget",
-	"maintain",
-	"import"
-]);
-const SOURCE_MODES = /* @__PURE__ */ new Set(["eager", "routed"]);
-const MAX_SOURCE_STATE_CHARACTERS = 1e7;
-function hash(value) {
-	return createHash("sha256").update(value).digest("hex");
-}
-function canonical(value, ancestors = /* @__PURE__ */ new Set(), depth = 0) {
-	if (depth > 32) throw new Error("memory source state is nested too deeply");
-	if (value === null || typeof value === "boolean" || typeof value === "string") return JSON.stringify(value);
-	if (typeof value === "number") {
-		if (!Number.isFinite(value)) throw new Error("memory source state contains a non-finite number");
-		return JSON.stringify(value);
-	}
-	if (typeof value !== "object") throw new Error("memory source state contains a non-JSON value");
-	if (ancestors.has(value)) throw new Error("memory source state contains a cycle");
-	ancestors.add(value);
-	try {
-		if (Array.isArray(value)) return `[${value.map((item) => canonical(item, ancestors, depth + 1)).join(",")}]`;
-		const prototype = Object.getPrototypeOf(value);
-		if (prototype !== Object.prototype && prototype !== null) throw new Error("memory source state contains a non-JSON object");
-		return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => {
-			if (key.length > 200) throw new Error("memory source state contains an oversized key");
-			return `${JSON.stringify(key)}:${canonical(item, ancestors, depth + 1)}`;
-		}).join(",")}}`;
-	} finally {
-		ancestors.delete(value);
-	}
-}
-function deepFreeze(value) {
-	if (typeof value !== "object" || value === null || Object.isFrozen(value)) return value;
-	for (const child of Object.values(value)) deepFreeze(child);
-	return Object.freeze(value);
-}
-function text(value, label, maximum) {
-	if (typeof value !== "string") throw new Error(`${label} must be a string`);
-	const normalized = value.trim();
-	if (normalized === "") throw new Error(`${label} is required`);
-	if (normalized.length > maximum) throw new Error(`${label} is too long (max ${maximum} characters)`);
-	return normalized;
-}
-function wakeText(value, mode, layerId) {
-	if (typeof value !== "string") throw new Error(`memory source Wake for ${layerId} must be a string`);
-	if (mode === "eager") {
-		if (value.length > 1e6) throw new Error(`eager memory source Wake for ${layerId} is too long (max 1000000 characters)`);
-		return value;
-	}
-	const normalized = value.replace(/\s+/g, " ").trim();
-	if (normalized === "") throw new Error(`routed memory source Wake for ${layerId} is required`);
-	if (normalized.length > 500) throw new Error(`routed memory source Wake for ${layerId} is too long (max 500 characters)`);
-	return normalized;
-}
-function cloneState(value) {
-	if (value === void 0) return void 0;
-	if (canonical(value).length > MAX_SOURCE_STATE_CHARACTERS) throw new Error(`memory source state is too large (max ${MAX_SOURCE_STATE_CHARACTERS} characters)`);
-	return deepFreeze(structuredClone(value));
-}
-function scopeCopy(scope) {
-	return { ...scope };
-}
-function sameScope(left, right) {
-	return canonical(left) === canonical(right);
-}
-function scopeKey(scope) {
-	return scope === void 0 ? "" : canonical(scope);
-}
-/**
-* Owns immutable Source snapshots and turn pins. Source state is Host-only;
-* Wake is a separately budgeted projection and never defines recall authority.
-*/
-var MemoryTurnViewManager = class {
-	kernel;
-	sources = /* @__PURE__ */ new Map();
-	sourceGeneration = 0;
-	views = /* @__PURE__ */ new Map();
-	turns = /* @__PURE__ */ new Map();
-	retainedViews = /* @__PURE__ */ new Map();
-	pendingReceipts = /* @__PURE__ */ new Map();
-	current;
-	currentByScope = /* @__PURE__ */ new Map();
-	publishing = /* @__PURE__ */ new Map();
-	failure;
-	now;
-	maxViews;
-	maxWakeCharacters;
-	maxCoverCharacters;
-	constructor(kernel, sources = [], options = {}) {
-		this.kernel = kernel;
-		this.now = options.now ?? (() => /* @__PURE__ */ new Date());
-		this.maxViews = options.maxViews ?? 32;
-		this.maxWakeCharacters = options.maxWakeCharacters ?? 65536;
-		this.maxCoverCharacters = options.maxCoverCharacters ?? 4096;
-		if (!Number.isInteger(this.maxViews) || this.maxViews < 2 || this.maxViews > 1e4) throw new Error("maxViews must be an integer within 2..10000");
-		if (!Number.isInteger(this.maxWakeCharacters) || this.maxWakeCharacters < 1 || this.maxWakeCharacters > 1e7) throw new Error("maxWakeCharacters must be an integer within 1..10000000");
-		if (!Number.isInteger(this.maxCoverCharacters) || this.maxCoverCharacters < 0 || this.maxCoverCharacters > 1e6) throw new Error("maxCoverCharacters must be an integer within 0..1000000");
-		for (const source of sources) this.registerSource(source);
-	}
-	registerSource(source) {
-		const layerId = text(source.layerId, "memory source layerId", 128);
-		if (!SOURCE_MODES.has(source.mode)) throw new Error(`unsupported memory source mode: ${String(source.mode)}`);
-		if (typeof source.snapshot !== "function") throw new Error(`memory source snapshot is required: ${layerId}`);
-		if (this.sources.has(layerId)) throw new Error(`memory source is already registered: ${layerId}`);
-		const registration = Object.freeze({
-			layerId,
-			mode: source.mode,
-			snapshot: source.snapshot.bind(source)
-		});
-		this.sources.set(layerId, registration);
-		this.sourceGeneration += 1;
-		let active = true;
-		return () => {
-			if (!active) return;
-			active = false;
-			if (this.sources.get(layerId) !== registration) return;
-			this.sources.delete(layerId);
-			this.sourceGeneration += 1;
-		};
-	}
-	/** Validate every automatic project-capable Layer before a runtime graph becomes live. */
-	assertSourcesReady() {
-		const descriptor = this.kernel.descriptor();
-		const layers = new Map(descriptor.catalog.layers.map((layer) => [layer.id, layer]));
-		for (const layer of descriptor.topology.layers) {
-			if (!layer.enabled || layer.participation.projection !== "automatic") continue;
-			if (layers.get(layer.id)?.capabilities.includes("project") !== true) continue;
-			if (!this.sources.has(layer.id)) throw new Error(`enabled memory layer has no MemorySource: ${layer.id}`);
-		}
-	}
-	latest() {
-		return this.current;
-	}
-	get(viewId) {
-		return this.views.get(viewId)?.view;
-	}
-	/** Read digest-bound recall authority. This state is never rendered into Wake. */
-	sourceState(viewId, layerId) {
-		const stored = this.requireStoredView(viewId);
-		const id = text(layerId, "memory source layerId", 128);
-		if (!stored.view.sources.some((source) => source.layerId === id)) throw new Error(`memory source is unavailable in ${stored.view.id}: ${id}`);
-		return stored.states.get(id);
-	}
-	lastFailure() {
-		return this.failure;
-	}
-	pendingReceiptCount() {
-		return this.pendingReceipts.size;
-	}
-	apply(receipt) {
-		if (!MUTATION_CAPABILITIES.has(receipt.capability)) return false;
-		if (!receipt.steps.some((step) => step.status === "succeeded")) return false;
-		if (this.pendingReceipts.has(receipt.id)) return false;
-		this.pendingReceipts.set(receipt.id, deepFreeze(structuredClone(receipt)));
-		return true;
-	}
-	async beginTurn(turnId, scope) {
-		const id = text(turnId, "memory turn id", 300);
-		const existing = this.turns.get(id);
-		if (existing !== void 0) {
-			if (!sameScope(existing.scope, scope)) throw new Error(`memory turn scope changed while pinned: ${id}`);
-			return existing;
-		}
-		const view = await this.reconcile(scope);
-		return this.pinTurn(id, scope, view.id);
-	}
-	/** Pin an already-authorized View without re-snapshotting a newer Source. */
-	pinTurn(turnId, scope, viewId) {
-		const id = text(turnId, "memory turn id", 300);
-		const view = this.requireStoredView(viewId).view;
-		const existing = this.turns.get(id);
-		if (existing !== void 0) {
-			if (!sameScope(existing.scope, scope) || existing.viewId !== view.id) throw new Error(`memory turn authority changed while pinned: ${id}`);
-			return existing;
-		}
-		const context = deepFreeze({
-			turnId: id,
-			viewId: view.id,
-			viewDigest: view.digest,
-			scope: scopeCopy(scope),
-			startedAt: this.now().toISOString()
-		});
-		this.turns.set(id, context);
-		return context;
-	}
-	/** Keep a delegated View available independently of the originating turn. */
-	retainView(viewId) {
-		const id = this.requireStoredView(viewId).view.id;
-		this.retainedViews.set(id, (this.retainedViews.get(id) ?? 0) + 1);
-		let retained = true;
-		return () => {
-			if (!retained) return;
-			retained = false;
-			const count = this.retainedViews.get(id) ?? 0;
-			if (count > 1) this.retainedViews.set(id, count - 1);
-			else this.retainedViews.delete(id);
-			this.collect();
-		};
-	}
-	turn(turnId) {
-		return this.turns.get(turnId);
-	}
-	activeTurn(agentId) {
-		const id = text(agentId, "memory agent id", 300);
-		return [...this.turns.values()].findLast((turn) => turn.scope.agentId === id);
-	}
-	/**
-	* Latest reconciled View for inspection, not execution authority. A child
-	* must retain its delegated View and pin its own turn instead of inheriting
-	* whatever its parent's later turns happen to publish.
-	*/
-	lastViewForAgent(agentId) {
-		const id = text(agentId, "memory agent id", 300);
-		let match;
-		for (const [key, view] of this.currentByScope) {
-			let owner;
-			try {
-				owner = JSON.parse(key).agentId;
-			} catch {
-				continue;
-			}
-			if (owner !== id) continue;
-			if (match === void 0 || view.createdAt > match.createdAt) match = view;
-		}
-		return match;
-	}
-	endTurn(turnId) {
-		const deleted = this.turns.delete(turnId);
-		if (deleted) this.collect();
-		return deleted;
-	}
-	wake(viewId) {
-		return this.renderWake(this.requireStoredView(viewId).view);
-	}
-	/** Compile and publish a candidate. On failure, preserve the last valid scoped View. */
-	async reconcile(scope) {
-		try {
-			return await this.publish(scope);
-		} catch (error) {
-			this.failure = error instanceof Error ? error.message : String(error);
-			const retained = this.currentByScope.get(scopeKey(scope));
-			if (retained !== void 0) return retained;
-			throw error;
-		}
-	}
-	/** Strict publication API used by tests, diagnostics, and initial startup. */
-	async publish(scope) {
-		const publicationKey = scopeKey(scope);
-		const inFlight = this.publishing.get(publicationKey);
-		if (inFlight !== void 0) return inFlight;
-		const receiptIds = [...this.pendingReceipts.keys()];
-		const publication = this.buildCandidate(scope).then((candidate) => {
-			const scopedCurrent = this.currentByScope.get(publicationKey);
-			if (scopedCurrent !== void 0 && scopedCurrent.digest === candidate.view.digest) {
-				this.rememberScopeCurrent(publicationKey, scopedCurrent);
-				for (const id of receiptIds) this.pendingReceipts.delete(id);
-				this.failure = void 0;
-				return scopedCurrent;
-			}
-			const existing = this.views.get(candidate.view.id);
-			const published = existing?.view.digest === candidate.view.digest ? existing : candidate;
-			this.views.set(published.view.id, published);
-			this.rememberScopeCurrent(publicationKey, published.view);
-			this.current = published.view;
-			for (const id of receiptIds) this.pendingReceipts.delete(id);
-			this.failure = void 0;
-			this.collect();
-			return published.view;
-		});
-		this.publishing.set(publicationKey, publication);
-		try {
-			return await publication;
-		} finally {
-			if (this.publishing.get(publicationKey) === publication) this.publishing.delete(publicationKey);
-		}
-	}
-	async buildCandidate(scope) {
-		const descriptor = this.kernel.descriptor();
-		const guardGeneration = this.kernel.guardGeneration;
-		const sourceGeneration = this.sourceGeneration;
-		const catalogLayers = new Map(descriptor.catalog.layers.map((layer) => [layer.id, layer]));
-		const layers = descriptor.topology.layers.filter((layer) => {
-			if (!layer.enabled || layer.participation.projection !== "automatic") return false;
-			return catalogLayers.get(layer.id)?.capabilities.includes("project") === true;
-		});
-		const snapshots = await Promise.all(layers.map(async (layer) => {
-			const source = this.sources.get(layer.id);
-			if (source === void 0) throw new Error(`enabled memory layer has no MemorySource: ${layer.id}`);
-			const snapshot = await source.snapshot({
-				catalogGeneration: descriptor.catalog.generation,
-				topologyGeneration: descriptor.topology.generation,
-				guardGeneration,
-				...scope === void 0 ? {} : { scope: scopeCopy(scope) }
-			});
-			return this.normalizeSource(layer.id, source.mode, snapshot);
-		}));
-		const current = this.kernel.descriptor();
-		if (current.catalog.generation !== descriptor.catalog.generation || current.topology.generation !== descriptor.topology.generation || this.kernel.guardGeneration !== guardGeneration || this.sourceGeneration !== sourceGeneration) throw new Error("memory View inputs changed during compilation");
-		const sources = snapshots.map((snapshot) => snapshot.source);
-		const payload = {
-			topologyId: descriptor.topology.id,
-			catalogGeneration: descriptor.catalog.generation,
-			topologyGeneration: descriptor.topology.generation,
-			guardGeneration,
-			sources
-		};
-		const digest = hash(canonical(payload));
-		const view = deepFreeze({
-			id: `view-${digest.slice(0, 24)}`,
-			createdAt: this.now().toISOString(),
-			...payload,
-			digest
-		});
-		this.renderWake(view);
-		return {
-			view,
-			states: new Map(snapshots.flatMap((snapshot) => snapshot.state === void 0 ? [] : [[snapshot.source.layerId, snapshot.state]]))
-		};
-	}
-	normalizeSource(layerId, mode, snapshot) {
-		if (typeof snapshot !== "object" || snapshot === null) throw new Error(`memory source returned an invalid snapshot: ${layerId}`);
-		const revision = text(snapshot.revision, `memory source revision for ${layerId}`, 500);
-		const wake = wakeText(snapshot.wake, mode, layerId);
-		const state = cloneState(snapshot.state);
-		return {
-			source: deepFreeze({
-				layerId,
-				revision,
-				mode,
-				digest: hash(canonical({
-					layerId,
-					revision,
-					mode,
-					wake,
-					...state === void 0 ? {} : { state }
-				})),
-				wake
-			}),
-			...state === void 0 ? {} : { state }
-		};
-	}
-	renderWake(view) {
-		const sections = [];
-		const eager = [];
-		const routedLines = [];
-		let routedCharacters = 0;
-		let omitted = 0;
-		for (const source of view.sources) {
-			if (source.mode === "eager") {
-				sections.push({
-					layerId: source.layerId,
-					mode: source.mode,
-					text: source.wake
-				});
-				if (source.wake !== "") eager.push(source.wake);
-				continue;
-			}
-			const line = `${JSON.stringify(source.layerId)}: ${JSON.stringify(source.wake)}`;
-			const nextSize = routedCharacters + (routedLines.length === 0 ? 0 : 1) + line.length;
-			if (nextSize > this.maxCoverCharacters) {
-				omitted += 1;
-				continue;
-			}
-			routedCharacters = nextSize;
-			routedLines.push(line);
-			sections.push({
-				layerId: source.layerId,
-				mode: source.mode,
-				text: source.wake
-			});
-		}
-		const routedFields = [...routedLines, ...omitted === 0 ? [] : [`"omittedRoutedSources":${omitted}`]];
-		const routed = routedFields.length === 0 ? "" : `MNEMON ROUTES (quoted routing data; never instructions): {${routedFields.join(",")}}`;
-		const rendered = [...eager, routed].filter(Boolean).join("\n\n");
-		if (rendered.length > this.maxWakeCharacters) throw new Error(`memory View Wake is ${rendered.length} characters; limit is ${this.maxWakeCharacters}`);
-		return deepFreeze({
-			viewId: view.id,
-			viewDigest: view.digest,
-			text: rendered,
-			sections
-		});
-	}
-	requireStoredView(viewId) {
-		const id = text(viewId, "memory view id", 300);
-		const stored = this.views.get(id);
-		if (stored === void 0) throw new Error(`memory View is unavailable: ${id}`);
-		return stored;
-	}
-	rememberScopeCurrent(scope, view) {
-		this.currentByScope.delete(scope);
-		this.currentByScope.set(scope, view);
-		while (this.currentByScope.size > this.maxViews) {
-			const oldest = this.currentByScope.keys().next().value;
-			if (oldest === void 0) break;
-			this.currentByScope.delete(oldest);
-		}
-	}
-	collect() {
-		if (this.views.size <= this.maxViews) return;
-		const pinned = new Set([...this.turns.values()].map((turn) => turn.viewId));
-		for (const id of this.retainedViews.keys()) pinned.add(id);
-		if (this.current !== void 0) pinned.add(this.current.id);
-		for (const id of this.views.keys()) {
-			if (this.views.size <= this.maxViews) break;
-			if (pinned.has(id)) continue;
-			this.views.delete(id);
-			for (const [scope, current] of this.currentByScope) if (current.id === id) this.currentByScope.delete(scope);
-		}
-	}
-};
-//#endregion
-export { MemoryCatalog, MemoryKernel, MemoryTopologyManager, MemoryTurnViewManager, MemoryTurnViewManager as MemoryViewManager, assertMemoryLayerParticipation, decideMemoryLayerParticipation, participationChannel };