@lmzhen/dsh-evolution-skill-discovery 0.30.43 → 0.31.0

package/lib/domain-description-Dxv-Rcon.js

@@ -0,0 +1,2104 @@
+import { _ as skillKeyOf, d as SkillIndex, m as projectionDigestOf, p as policyDigestOf, v as threeFieldHashOf } from "./tool-CvUTwKvW.js";
+import { createHash } from "node:crypto";
+import { isRecord, parseFrontmatter } from "@lmzhen/dsh-evolution-core";
+import { BlockAssembler, createUserMessage } from "@deepseek-ai/dsh-llm";
+import { escapeText } from "@deepseek-ai/dsh-skill";
+//#region lib/types/domain-generation.js
+/** @returns stable id derived from title, not the title itself. */
+function mintDomainId(title) {
+	return "domain-" + createHash("sha256").update(title).digest("hex").slice(0, 12);
+}
+/** @returns direct for <=100 skills; prechunk-eligible above 100. */
+function domainGenerationMode(skillCount) {
+	if (!Number.isSafeInteger(skillCount) || skillCount < 0) throw new RangeError("skillCount must be a non-negative safe integer");
+	return skillCount <= 100 ? "direct" : "prechunk-eligible";
+}
+function nonEmpty(value) {
+	return typeof value === "string" && value.trim().length > 0;
+}
+function nonEmptyList(value) {
+	return Array.isArray(value) && value.length > 0 && value.every(nonEmpty);
+}
+function forbiddenKeys(value) {
+	return [
+		"primaryParent",
+		"primaryParentId",
+		"parent",
+		"embedding",
+		"embeddingVector",
+		"taxonomyMethod"
+	].filter((key) => key in value);
+}
+/**
+* Validate an initial generation proposal and mint ids. Does not call an LLM
+* and does not read skill bodies; embedding taxonomy is rejected.
+* @param input - skills the proposal was generated from.
+* @param proposal - LLM output.
+* @returns normalized domains or stable errors.
+*/
+function validateDomainGeneration(input, proposal) {
+	const errors = [];
+	if (proposal.domains.length < 8 || proposal.domains.length > 12) errors.push("domain count must be 8-12");
+	const known = new Set(input.skills.map((skill) => skill.name));
+	const ids = /* @__PURE__ */ new Set();
+	const titles = /* @__PURE__ */ new Set();
+	const domains = [];
+	for (const candidate of proposal.domains) {
+		if (candidate === null || typeof candidate !== "object") {
+			errors.push("domain is not an object");
+			continue;
+		}
+		const bad = forbiddenKeys(candidate);
+		if (bad.length > 0) errors.push("forbidden fields: " + bad.join(","));
+		if (!nonEmpty(candidate.title) || !nonEmpty(candidate.purpose)) {
+			errors.push("domain title/purpose is empty");
+			continue;
+		}
+		if (!nonEmptyList(candidate.inScope) || !nonEmptyList(candidate.outOfScope) || !nonEmptyList(candidate.triggers)) errors.push("domain scope/triggers are empty");
+		if (!Array.isArray(candidate.evidenceSkillKeys) || candidate.evidenceSkillKeys.length === 0) errors.push("domain evidence is empty");
+		if (candidate.evidenceSkillKeys?.some((key) => !known.has(key)) === true) errors.push("domain evidence references unknown skill");
+		const id = mintDomainId(candidate.title);
+		if (ids.has(id)) errors.push("duplicate minted domain id");
+		if (titles.has(candidate.title)) errors.push("duplicate domain title");
+		ids.add(id);
+		titles.add(candidate.title);
+		domains.push({
+			...candidate,
+			id
+		});
+	}
+	if ("embedding" in proposal || "taxonomyMethod" in proposal) errors.push("embedding taxonomy is not allowed");
+	return errors.length === 0 ? {
+		ok: true,
+		domains
+	} : {
+		ok: false,
+		errors
+	};
+}
+//#endregion
+//#region lib/types/domain-bootstrap.js
+/**
+* Write an initial LLM proposal using live skill facts. Code owns IDs and
+* validation; no synthetic description/hash is written.
+* @param store - map owner.
+* @param proposal - 8–12 domain proposal.
+* @param facts - real rows with stable keys and three-field hashes.
+* @param expectedMapVersion - CAS precondition.
+* @param provenance - prompt/run identity for audit.
+* @returns committed snapshot.
+*/
+async function bootstrapDomainMapWithFacts(store, proposal, facts, expectedMapVersion, provenance) {
+	const checked = validateDomainGeneration({ skills: facts.map(({ name, description, whenToUse }) => ({
+		name,
+		description,
+		...whenToUse === void 0 ? {} : { whenToUse }
+	})) }, proposal);
+	if (!checked.ok) throw new Error("invalid domain proposal: " + checked.errors.join("; "));
+	const byName = new Map(facts.map((fact) => [fact.name, fact]));
+	const now = Date.now();
+	const qualityOf = (domain) => {
+		const triggerCount = domain.triggers.filter((value) => value.trim() !== "").length;
+		const scopeCount = domain.inScope.filter((value) => value.trim() !== "").length;
+		const duplicate = checked.domains.some((other) => other.id !== domain.id && other.purpose.trim().toLowerCase() === domain.purpose.trim().toLowerCase());
+		const fields = [
+			domain.purpose.trim() !== "",
+			triggerCount > 0,
+			scopeCount > 0,
+			domain.outOfScope.some((value) => value.trim() !== ""),
+			!duplicate
+		];
+		return {
+			score: fields.filter(Boolean).length / fields.length,
+			triggerCount,
+			scopeCount
+		};
+	};
+	const domains = checked.domains.map((domain) => ({
+		id: domain.id,
+		name: domain.title,
+		purpose: domain.purpose,
+		description: domain.purpose,
+		inScope: domain.inScope,
+		outOfScope: domain.outOfScope,
+		triggers: domain.triggers,
+		parentIds: [],
+		status: "provisional",
+		version: 1,
+		createdAt: now,
+		updatedAt: now,
+		descriptionHash: "bootstrap",
+		descriptionVersion: 1,
+		descriptionStatus: "fresh",
+		provenance: {
+			source: "llm",
+			promptVersion: provenance.promptVersion,
+			sourceDigest: provenance.sourceDigest,
+			model: provenance.model,
+			runId: provenance.runId
+		},
+		quality: qualityOf(domain)
+	}));
+	const primary = /* @__PURE__ */ new Set();
+	const edges = [];
+	for (const [domainIndex, domain] of checked.domains.entries()) for (const name of domain.evidenceSkillKeys) {
+		const fact = byName.get(name);
+		if (fact === void 0) continue;
+		const role = primary.has(fact.skillKey) ? "secondary" : "primary";
+		if (role === "primary") primary.add(fact.skillKey);
+		edges.push({
+			skillKey: fact.skillKey,
+			domainId: checked.domains[domainIndex].id,
+			role,
+			confidence: 1,
+			source: "create",
+			skillHash: fact.threeFieldHash,
+			mapVersion: expectedMapVersion,
+			status: "active",
+			assignedAt: now
+		});
+	}
+	return store.commit(expectedMapVersion, {
+		mapVersion: String(Number(expectedMapVersion) + 1),
+		domains,
+		edges
+	});
+}
+/**
+* Legacy fallback for callers that only have a name -> key mapping.
+* Production must use bootstrapDomainMapWithFacts.
+*/
+async function bootstrapDomainMap(store, proposal, skillKeys, expectedMapVersion) {
+	return bootstrapDomainMapWithFacts(store, proposal, Object.entries(skillKeys).map(([name, skillKey]) => ({
+		name,
+		description: name,
+		skillKey,
+		threeFieldHash: ""
+	})), expectedMapVersion, {
+		promptVersion: "legacy",
+		sourceDigest: "legacy",
+		model: "legacy",
+		runId: "legacy"
+	});
+}
+//#endregion
+//#region lib/types/domain-generation-coordinator.js
+/** Single-flight initial map generation; mapVersion CAS is the final arbiter. */
+var DomainGenerationCoordinator = class {
+	store;
+	port;
+	inflight = /* @__PURE__ */ new Map();
+	epoch = 0;
+	constructor(store, port) {
+		this.store = store;
+		this.port = port;
+	}
+	/** @returns current map version; increment makes older requests stale. */
+	get currentEpoch() {
+		return this.epoch;
+	}
+	/**
+	* Generate an initial map once per scope; concurrent calls share one job.
+	* @param request - live skills, stable keys, prompt, and CAS precondition.
+	* @returns committed or existing snapshot.
+	*/
+	async ensure(request) {
+		const current = await this.store.read();
+		if (current.domains.length > 0) return current;
+		const existing = this.inflight.get(request.mapScope);
+		if (existing !== void 0) return existing;
+		this.epoch += 1;
+		const epoch = this.epoch;
+		const job = this.run(request, epoch).finally(() => {
+			this.inflight.delete(request.mapScope);
+		});
+		this.inflight.set(request.mapScope, job);
+		return job;
+	}
+	async run(request, epoch) {
+		const current = await this.store.read();
+		if (current.domains.length > 0) return current;
+		const proposal = await this.port.generate({
+			skills: request.facts.map(({ name, description, whenToUse }) => ({
+				name,
+				description,
+				...whenToUse === void 0 ? {} : { whenToUse }
+			})),
+			prompt: request.prompt,
+			...request.signal === void 0 ? {} : { signal: request.signal }
+		});
+		if (epoch !== this.epoch) {
+			const latest = await this.store.read();
+			if (latest.domains.length > 0) return latest;
+			throw new Error("domain generation superseded by a newer source snapshot");
+		}
+		return bootstrapDomainMapWithFacts(this.store, proposal, request.facts, request.expectedMapVersion, {
+			promptVersion: request.promptVersion,
+			sourceDigest: request.sourceDigest,
+			model: request.model,
+			runId: request.runId
+		});
+	}
+};
+//#endregion
+//#region lib/types/domain-policy.js
+/** Invalid policy layer (e.g. attempts to edit taxonomy). */
+var DomainPolicyValidationError = class extends Error {
+	code = "domain-policy-invalid";
+	constructor(message) {
+		super(message);
+		this.name = "DomainPolicyValidationError";
+	}
+};
+const ALLOWED = new Set([
+	"mode",
+	"pinDomains",
+	"disableDomains",
+	"revision"
+]);
+const MODES = new Set([
+	"off",
+	"auto",
+	"on"
+]);
+function checkLayer(layer) {
+	for (const key of Object.keys(layer)) if (!ALLOWED.has(key)) throw new DomainPolicyValidationError("unsupported policy field " + key);
+	if (layer.mode !== void 0 && !MODES.has(layer.mode)) throw new DomainPolicyValidationError("unsupported policy mode");
+}
+function knownOnly(values, known, degraded) {
+	const result = /* @__PURE__ */ new Set();
+	for (const value of values ?? []) {
+		if (known !== void 0 && !known.has(value)) {
+			degraded.add(value);
+			continue;
+		}
+		result.add(value);
+	}
+	return result;
+}
+/**
+* Merge global -> workspace -> scope policy. Disable wins over pin; unknown
+* domains are ignored and reported as degraded.
+* @param global - mandatory global layer.
+* @param workspace - optional workspace overlay.
+* @param scope - optional scope overlay.
+* @param knownDomainIds - optional known ids for validation.
+* @returns immutable effective policy.
+*/
+function mergeDomainPolicy(global, workspace, scope, knownDomainIds) {
+	checkLayer(global);
+	if (workspace) checkLayer(workspace);
+	if (scope) checkLayer(scope);
+	const degraded = /* @__PURE__ */ new Set();
+	const blocked = new Set([
+		...knownOnly(global.disableDomains, knownDomainIds, degraded),
+		...knownOnly(workspace?.disableDomains, knownDomainIds, degraded),
+		...knownOnly(scope?.disableDomains, knownDomainIds, degraded)
+	]);
+	const pinned = new Set([
+		...knownOnly(global.pinDomains, knownDomainIds, degraded),
+		...knownOnly(workspace?.pinDomains, knownDomainIds, degraded),
+		...knownOnly(scope?.pinDomains, knownDomainIds, degraded)
+	]);
+	for (const id of blocked) pinned.delete(id);
+	return {
+		mode: scope?.mode ?? workspace?.mode ?? global.mode ?? "off",
+		pinned,
+		disabled: blocked,
+		degraded: [...degraded].sort(),
+		globalRevision: global.revision,
+		workspaceRevision: workspace?.revision,
+		scopeRevision: scope?.revision
+	};
+}
+//#endregion
+//#region lib/types/domain-policy-store.js
+/** Resolves global/workspace/scope policy without touching DomainMap or mapVersion. */
+var DomainPolicyStore = class {
+	input;
+	constructor(input) {
+		this.input = input;
+	}
+	/**
+	* @param knownDomainIds - optional live id set; overrides the construction-time set.
+	* @returns effective policy with unknown ids reported as degraded.
+	*/
+	resolve(knownDomainIds = this.input.knownDomainIds) {
+		return mergeDomainPolicy(this.input.global, this.input.workspace, this.input.scope, knownDomainIds);
+	}
+	/**
+	* @param knownDomainIds - optional live id set used for the effective policy.
+	* @returns stable digest of effective policy and all layer revisions.
+	*/
+	digest(knownDomainIds = this.input.knownDomainIds) {
+		const policy = this.resolve(knownDomainIds);
+		return policyDigestOf({
+			globalPolicyRevision: policy.globalRevision ?? "0",
+			...policy.workspaceRevision === void 0 ? {} : { workspaceOverlayRevision: policy.workspaceRevision },
+			...policy.scopeRevision === void 0 ? {} : { scopeOverlayRevision: policy.scopeRevision },
+			effectivePolicy: policy
+		});
+	}
+};
+//#endregion
+//#region lib/types/domain-map-store.js
+/** File schema version supported by this store. */
+const DOMAIN_MAP_SCHEMA_VERSION = 1;
+/** Typed failure for an invalid persisted file. */
+var DomainMapCorruptError = class extends Error {
+	code = "domain-map-corrupt";
+	constructor(message) {
+		super(message);
+		this.name = "DomainMapCorruptError";
+	}
+};
+/** Typed failure for a CAS mismatch. */
+var DomainMapVersionConflict = class extends Error {
+	code = "domain-map-version-conflict";
+	expected;
+	actual;
+	constructor(expected, actual) {
+		super("domain map version conflict: expected " + expected + ", found " + actual);
+		this.expected = expected;
+		this.actual = actual;
+		this.name = "DomainMapVersionConflict";
+	}
+};
+/** Typed failure for an invalid write. */
+var DomainMapValidationError = class extends Error {
+	code = "domain-map-invalid";
+	constructor(message) {
+		super(message);
+		this.name = "DomainMapValidationError";
+	}
+};
+function emptySnapshot() {
+	return {
+		mapVersion: "0",
+		domains: [],
+		edges: []
+	};
+}
+function assertNode(node) {
+	if (!isRecord(node) || typeof node.id !== "string" || node.id.length === 0) throw new DomainMapCorruptError("domain node id is missing");
+	if (typeof node.name !== "string" || typeof node.purpose !== "string" || typeof node.description !== "string") throw new DomainMapCorruptError("domain node text fields are missing");
+	if (!Array.isArray(node.inScope) || !Array.isArray(node.outOfScope) || !Array.isArray(node.triggers) || !Array.isArray(node.parentIds)) throw new DomainMapCorruptError("domain node arrays are invalid");
+	if (node.status !== "active" && node.status !== "provisional" && node.status !== "deprecated") throw new DomainMapCorruptError("domain node status is invalid");
+}
+function assertEdge(edge) {
+	if (!isRecord(edge) || typeof edge.skillKey !== "string" || typeof edge.domainId !== "string") throw new DomainMapCorruptError("skill edge identity is missing");
+	if (edge.role !== "primary" && edge.role !== "secondary") throw new DomainMapCorruptError("skill edge role is invalid");
+	if (edge.status !== "active" && edge.status !== "stale" && edge.status !== "pending") throw new DomainMapCorruptError("skill edge status is invalid");
+	if (typeof edge.confidence !== "number" || edge.confidence < 0 || edge.confidence > 1) throw new DomainMapCorruptError("skill edge confidence is invalid");
+}
+function validateWrite(next) {
+	if (next.mapVersion.length === 0) throw new DomainMapValidationError("mapVersion must be non-empty");
+	const ids = /* @__PURE__ */ new Set();
+	for (const node of next.domains) {
+		assertNode(node);
+		if (ids.has(node.id)) throw new DomainMapValidationError("duplicate domain id " + node.id);
+		ids.add(node.id);
+	}
+	for (const node of next.domains) for (const parent of node.parentIds) {
+		if (parent === node.id) throw new DomainMapValidationError("domain self-parent " + node.id);
+		if (!ids.has(parent)) throw new DomainMapValidationError("unknown parent domain " + parent);
+	}
+	const edgeKeys = /* @__PURE__ */ new Set();
+	const primaries = /* @__PURE__ */ new Map();
+	for (const edge of next.edges) {
+		assertEdge(edge);
+		if (!ids.has(edge.domainId)) throw new DomainMapValidationError("unknown edge domain " + edge.domainId);
+		const key = edge.skillKey + "\0" + edge.domainId;
+		if (edgeKeys.has(key)) throw new DomainMapValidationError("duplicate skill/domain edge");
+		edgeKeys.add(key);
+		if (edge.role === "primary") {
+			const count = (primaries.get(edge.skillKey) ?? 0) + 1;
+			if (count > 1) throw new DomainMapValidationError("more than one primary domain for " + edge.skillKey);
+			primaries.set(edge.skillKey, count);
+		}
+	}
+}
+/**
+* JSON-backed DomainMap owner. One file, schemaVersion, CAS mapVersion, and a
+* best-effort .bak for rollback; no evolution-state tables or graph DB.
+*/
+var DomainMapFileStore = class {
+	queue = Promise.resolve();
+	io;
+	path;
+	now;
+	constructor(io, path, now = Date.now) {
+		this.io = io;
+		this.path = path;
+		this.now = now;
+	}
+	get backupPath() {
+		return this.path + ".bak";
+	}
+	parse(content) {
+		if (content === null) return emptySnapshot();
+		let value;
+		try {
+			value = JSON.parse(content);
+		} catch {
+			throw new DomainMapCorruptError("domain map is not valid JSON");
+		}
+		if (!isRecord(value) || value.schemaVersion !== 1 || typeof value.mapVersion !== "string" || !Array.isArray(value.domains) || !Array.isArray(value.edges)) throw new DomainMapCorruptError("domain map schema is unsupported");
+		for (const node of value.domains) assertNode(node);
+		for (const edge of value.edges) assertEdge(edge);
+		return {
+			mapVersion: value.mapVersion,
+			domains: value.domains,
+			edges: value.edges
+		};
+	}
+	async read() {
+		return this.parse(await this.io.readText(this.path));
+	}
+	async commitNow(current, expected, next) {
+		const snapshot = this.parse(current);
+		if (snapshot.mapVersion !== expected) throw new DomainMapVersionConflict(expected, snapshot.mapVersion);
+		if (next.mapVersion === expected) throw new DomainMapValidationError("mapVersion must change on commit");
+		validateWrite(next);
+		if (current !== null) await this.io.writeText(this.backupPath, current);
+		const file = {
+			schemaVersion: 1,
+			mapVersion: next.mapVersion,
+			updatedAt: this.now(),
+			domains: next.domains,
+			edges: next.edges
+		};
+		return JSON.stringify(file);
+	}
+	async commit(expectedMapVersion, next) {
+		const run = async () => {
+			if (this.io.transact !== void 0) await this.io.transact(this.path, (current) => this.commitNow(current, expectedMapVersion, next));
+			else {
+				const current = await this.io.readText(this.path);
+				await this.io.writeText(this.path, await this.commitNow(current, expectedMapVersion, next));
+			}
+		};
+		const pending = this.queue.then(run, run);
+		this.queue = pending.catch(() => {});
+		await pending;
+		return this.read();
+	}
+	async rollback() {
+		const backup = await this.io.readText(this.backupPath);
+		if (backup === null) throw new DomainMapCorruptError("domain map backup is missing");
+		const snapshot = this.parse(backup);
+		await this.io.writeText(this.path, backup);
+		return snapshot;
+	}
+};
+//#endregion
+//#region lib/types/projection-journal.js
+function keyOf(record) {
+	return record.sessionId + "|" + record.viewKey + "|" + record.projectionDigest + "|" + record.codecVersion;
+}
+/** Durable projection journal; no base means restore must fail closed. */
+var ProjectionJournal = class {
+	io;
+	path;
+	maxRecords;
+	constructor(io, path, options = {}) {
+		this.io = io;
+		this.path = path;
+		this.maxRecords = options.maxRecords ?? 512;
+	}
+	async read() {
+		const content = await this.io.readText(this.path);
+		if (content === null) return {
+			schemaVersion: 1,
+			records: {}
+		};
+		try {
+			const parsed = JSON.parse(content);
+			return parsed.schemaVersion === 1 && typeof parsed.records === "object" && parsed.records !== null ? {
+				schemaVersion: 1,
+				records: parsed.records
+			} : {
+				schemaVersion: 1,
+				records: {}
+			};
+		} catch {
+			return {
+				schemaVersion: 1,
+				records: {}
+			};
+		}
+	}
+	/** Persist one projection record; later records with the same key win. */
+	async put(record) {
+		const records = {
+			...(await this.read()).records,
+			[keyOf(record)]: record
+		};
+		const ordered = Object.entries(records).sort((left, right) => right[1].createdAt - left[1].createdAt).slice(0, this.maxRecords);
+		await this.io.writeText(this.path, JSON.stringify({
+			schemaVersion: 1,
+			records: Object.fromEntries(ordered)
+		}));
+	}
+	/** @returns the exact projection record for one view/digest/codec, if present. */
+	async get(sessionId, viewKey, projectionDigest, codecVersion) {
+		return (await this.read()).records[keyOf({
+			sessionId,
+			viewKey,
+			projectionDigest,
+			codecVersion
+		})];
+	}
+	/** @returns newest record for a view, used when leaving ready without a known digest. */
+	async latest(sessionId, viewKey, codecVersion) {
+		return Object.values((await this.read()).records).filter((record) => record.sessionId === sessionId && record.viewKey === viewKey && record.codecVersion === codecVersion).sort((left, right) => right.createdAt - left.createdAt)[0];
+	}
+	/** Delete one record after a successful restore. */
+	async remove(sessionId, viewKey, projectionDigest, codecVersion) {
+		const records = { ...(await this.read()).records };
+		delete records[keyOf({
+			sessionId,
+			viewKey,
+			projectionDigest,
+			codecVersion
+		})];
+		await this.io.writeText(this.path, JSON.stringify({
+			schemaVersion: 1,
+			records
+		}));
+	}
+};
+//#endregion
+//#region lib/types/domain-quality.js
+function tokens(values) {
+	return new Set(values.join(" ").toLowerCase().split(/[^\p{Letter}\p{Number}]+/u).filter((token) => token.length > 0));
+}
+function jaccard(left, right) {
+	if (left.size === 0 && right.size === 0) return 1;
+	let overlap = 0;
+	for (const token of left) if (right.has(token)) overlap += 1;
+	return overlap / (left.size + right.size - overlap);
+}
+/**
+* Evaluate whether a domain definition is specific, triggered, and distinct.
+* @param domain - candidate domain.
+* @param peers - other visible domains.
+* @returns auditable issues; does not mutate the candidate.
+*/
+function evaluateDomainQuality(domain, peers) {
+	const issues = [];
+	if (domain.purpose.trim().length === 0) issues.push("empty-purpose");
+	else if (domain.purpose.trim().length < 8) issues.push("vague-purpose");
+	if (domain.inScope.length === 0) issues.push("empty-in-scope");
+	if (domain.outOfScope.length === 0) issues.push("empty-out-of-scope");
+	if (domain.triggers.length === 0) issues.push("empty-triggers");
+	const own = tokens([...domain.inScope, ...domain.triggers]);
+	for (const peer of peers) {
+		if (domain.name.trim().toLowerCase() === peer.name.trim().toLowerCase() || domain.purpose.trim().toLowerCase() === peer.purpose.trim().toLowerCase()) {
+			issues.push("indistinguishable");
+			break;
+		}
+		if (jaccard(own, tokens([...peer.inScope, ...peer.triggers])) > .8) {
+			issues.push("overlaps-peer");
+			break;
+		}
+	}
+	const unique = [...new Set(issues)];
+	return {
+		passed: unique.length === 0,
+		issues: unique,
+		score: Math.max(0, 1 - unique.length * .2)
+	};
+}
+//#endregion
+//#region lib/types/security.js
+/**
+* Treat description text as data: strip control characters, escape HTML
+* delimiters, and cap length. It never turns data into instructions.
+* @param value - untrusted domain/skill text.
+* @param limit - maximum characters retained.
+* @returns escaped text plus truncation flag.
+*/
+function sanitizeUntrustedText(value, limit = 2e3) {
+	const escaped = value.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "").replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+	return escaped.length <= limit ? {
+		text: escaped,
+		truncated: false
+	} : {
+		text: escaped.slice(0, limit),
+		truncated: true
+	};
+}
+//#endregion
+//#region lib/types/projection.js
+function escapeData(value) {
+	return sanitizeUntrustedText(value, 2e3).text;
+}
+function renderCards(cards) {
+	if (cards.length === 0) return "";
+	return [
+		"<system-reminder>",
+		"Domain cards summarize where skills cluster; they support awareness, not retrieval. skill_search matches task text to skill summaries, skill(name) loads an exact skill, and the full catalog remains the fallback.",
+		"<skill_domains>",
+		...cards.map((card) => [
+			"- ",
+			escapeData(card.id),
+			" ",
+			escapeData(card.title),
+			": ",
+			escapeData(card.purpose),
+			" triggers=",
+			card.triggers.map(escapeData).join(","),
+			" | managed=",
+			String(card.managedModelInvocableCount),
+			" external=",
+			String(card.externalCatalogCount),
+			" pending=",
+			String(card.pendingCount),
+			" unclassified=",
+			String(card.unclassifiedCount ?? 0),
+			" state=",
+			card.state,
+			" descriptionStatus=",
+			card.descriptionStatus,
+			" asOf=",
+			escapeData(card.asOf),
+			" mapVersion=",
+			escapeData(card.mapVersion),
+			" mapStale=",
+			String(card.mapStale)
+		].join("")),
+		"</skill_domains>",
+		"</system-reminder>"
+	].join("\n");
+}
+/**
+* Pure catalog projection: hide only active managed entries, preserve every
+* other entry, and render L1 cards. Incomplete input fails open.
+* @param input - view rows, active managed keys, cards, and identity inputs.
+* @returns projected entries/context/hidden names and digest.
+*/
+function projectCatalog(input) {
+	if (!input.complete) return {
+		catalogEntries: input.entries,
+		context: "",
+		hiddenNames: [],
+		scope: input.scope,
+		digest: projectionDigestOf({
+			viewKey: input.viewKey,
+			mapVersion: input.mapVersion,
+			policyDigest: input.policyDigest,
+			viewCatalogDigest: input.viewCatalogDigest,
+			adapterVersion: input.adapterVersion,
+			projectionSchemaVersion: input.projectionSchemaVersion,
+			discoveryMode: input.discoveryMode
+		}),
+		complete: false
+	};
+	const activeByName = /* @__PURE__ */ new Map();
+	for (const row of input.rows) if (row.managed && row.modelInvocable && !row.protected && input.activeManagedSkillKeys.has(row.skillKey)) activeByName.set(row.name, row);
+	const hiddenNames = input.entries.filter((entry) => activeByName.has(entry.name)).map((entry) => entry.name).sort();
+	const hidden = new Set(hiddenNames);
+	return {
+		catalogEntries: input.entries.filter((entry) => !hidden.has(entry.name)),
+		context: renderCards(input.cards),
+		hiddenNames,
+		scope: input.scope,
+		digest: projectionDigestOf({
+			viewKey: input.viewKey,
+			mapVersion: input.mapVersion,
+			policyDigest: input.policyDigest,
+			viewCatalogDigest: input.viewCatalogDigest,
+			adapterVersion: input.adapterVersion,
+			projectionSchemaVersion: input.projectionSchemaVersion,
+			discoveryMode: input.discoveryMode
+		}),
+		complete: true
+	};
+}
+//#endregion
+//#region lib/types/domain-projection.js
+function qualityPasses(node, domains) {
+	return evaluateDomainQuality(node, domains.filter((peer) => peer.id !== node.id)).passed;
+}
+/**
+* Build L1 cards and the hidden set for one view, then delegate the pure
+* catalog rewrite. Structural staleness fails open; description staleness does not.
+* @param input - rows, domain facts, policy, and identity inputs.
+* @returns projection result with cards and hidden names.
+*/
+function hiddenRecoverable(hiddenNames, searchResultNames) {
+	return hiddenNames.every((name) => searchResultNames.has(name));
+}
+function buildDomainProjection(input) {
+	const mode = input.mode ?? "on";
+	if (mode === "off") return projectCatalog({
+		entries: input.entries,
+		rows: input.rows,
+		activeManagedSkillKeys: /* @__PURE__ */ new Set(),
+		cards: [],
+		viewKey: input.viewKey,
+		scope: input.scope,
+		mapVersion: input.mapVersion,
+		policyDigest: input.policyDigest,
+		viewCatalogDigest: input.viewCatalogDigest,
+		adapterVersion: input.adapterVersion,
+		projectionSchemaVersion: input.projectionSchemaVersion,
+		discoveryMode: input.discoveryMode,
+		complete: false
+	});
+	const staleByAge = input.staleAfterHours !== void 0 && input.snapshot.domains.some((node) => input.now !== void 0 && input.now - node.updatedAt > input.staleAfterHours * 36e5);
+	const mapStale = input.mapStale === true || staleByAge;
+	if (!input.complete) return projectCatalog({
+		entries: input.entries,
+		rows: input.rows,
+		activeManagedSkillKeys: /* @__PURE__ */ new Set(),
+		cards: [],
+		viewKey: input.viewKey,
+		scope: input.scope,
+		mapVersion: input.mapVersion,
+		policyDigest: input.policyDigest,
+		viewCatalogDigest: input.viewCatalogDigest,
+		adapterVersion: input.adapterVersion,
+		projectionSchemaVersion: input.projectionSchemaVersion,
+		discoveryMode: input.discoveryMode,
+		complete: false
+	});
+	const rowByKey = new Map(input.rows.map((row) => [row.skillKey, row]));
+	const staleEdgeDomains = new Set(input.snapshot.edges.filter((edge) => edge.status === "active" && edge.role === "primary" && rowByKey.get(edge.skillKey) !== void 0 && edge.skillHash !== rowByKey.get(edge.skillKey).threeFieldHash).map((edge) => edge.domainId));
+	const linkedKeys = new Set(input.snapshot.edges.filter((edge) => edge.status === "active" || edge.status === "pending").map((edge) => edge.skillKey));
+	const unclassifiedCount = input.rows.filter((row) => row.modelInvocable && !linkedKeys.has(row.skillKey)).length;
+	const domains = input.snapshot.domains.filter((node) => node.status === "active" || node.status === "provisional");
+	const cardDomains = domains.filter((node) => node.parentIds.length <= (input.maxVisibleDepth ?? 3) - 1 && node.parentIds.length === 0).filter((node) => !input.policy.disabled.has(node.id)).filter((node) => input.policy.pinned.has(node.id) || qualityPasses(node, domains)).sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0).slice(0, Math.max(1, input.maxCards ?? 12));
+	const domainById = new Map(domains.map((node) => [node.id, node]));
+	const cards = cardDomains.map((node) => {
+		let managedModelInvocableCount = 0;
+		let externalCatalogCount = 0;
+		let pendingCount = 0;
+		for (const edge of input.snapshot.edges) {
+			if (edge.domainId !== node.id) continue;
+			const row = rowByKey.get(edge.skillKey);
+			if (row === void 0) continue;
+			if (edge.status === "pending") {
+				pendingCount += 1;
+				continue;
+			}
+			if (edge.status !== "active") continue;
+			if (row.managed && row.modelInvocable && !row.protected && !row.pinned) managedModelInvocableCount += 1;
+			else if (!row.managed) externalCatalogCount += 1;
+		}
+		return {
+			id: node.id,
+			title: node.name,
+			purpose: node.purpose.slice(0, 80),
+			descriptionStatus: node.descriptionStatus === "fresh" && input.descriptionStaleAfterHours !== void 0 && input.now !== void 0 && input.now - node.updatedAt > input.descriptionStaleAfterHours * 36e5 ? "stale" : node.descriptionStatus,
+			triggers: node.triggers.slice(0, 3),
+			managedModelInvocableCount,
+			externalCatalogCount,
+			managedCount: managedModelInvocableCount,
+			externalCount: externalCatalogCount,
+			pendingCount,
+			unclassifiedCount,
+			state: node.status === "provisional" ? "provisional" : "active",
+			asOf: new Date(node.updatedAt).toISOString(),
+			mapVersion: input.mapVersion,
+			mapStale: mapStale || staleEdgeDomains.has(node.id)
+		};
+	});
+	const budget = input.tokenBudget;
+	if (budget !== void 0 && budget > 0) while (cards.length > 1 && Math.ceil(JSON.stringify(cards).length / 4) > budget) cards.pop();
+	const cardIds = new Set(cards.map((card) => card.id));
+	const wouldHide = /* @__PURE__ */ new Set();
+	for (const edge of input.snapshot.edges) {
+		if (edge.status !== "active" || edge.role !== "primary") continue;
+		const node = domainById.get(edge.domainId);
+		const row = rowByKey.get(edge.skillKey);
+		if (node === void 0 || row === void 0) continue;
+		if (node.status !== "active" || !cardIds.has(node.id) || !row.managed || !row.modelInvocable || row.protected || row.pinned) continue;
+		if (edge.skillHash !== row.threeFieldHash) continue;
+		if (input.policy.disabled.has(node.id)) continue;
+		wouldHide.add(edge.skillKey);
+	}
+	const activeManaged = mode === "on" && !mapStale && input.searchAvailable !== false && input.policy.degraded.length === 0 ? wouldHide : /* @__PURE__ */ new Set();
+	const projected = projectCatalog({
+		entries: input.entries,
+		rows: input.rows,
+		activeManagedSkillKeys: activeManaged,
+		cards,
+		viewKey: input.viewKey,
+		scope: input.scope,
+		mapVersion: input.mapVersion,
+		policyDigest: input.policyDigest,
+		viewCatalogDigest: input.viewCatalogDigest,
+		adapterVersion: input.adapterVersion,
+		projectionSchemaVersion: input.projectionSchemaVersion,
+		discoveryMode: input.discoveryMode,
+		complete: true
+	});
+	return mode === "on" ? projected : projected;
+}
+//#endregion
+//#region lib/types/catalog-codec.js
+function textOf(message) {
+	return message.content.map((block) => block.type === "text" ? block.text : "").join("\n");
+}
+function sourceOf(message) {
+	if (message.source.kind !== "skill-catalog") return void 0;
+	return message.source;
+}
+/** @returns captured catalog when text has the known available_skills block. */
+function captureCatalog(message) {
+	const source = sourceOf(message);
+	if (source === void 0 || source.form !== "catalog") return void 0;
+	const text = textOf(message);
+	if (!text.includes("<available_skills>") || !text.includes("</available_skills>")) return void 0;
+	return {
+		text,
+		source,
+		entries: source.entries,
+		update: source.update === true
+	};
+}
+function renderEntries(entries) {
+	return entries.map((entry) => "- `" + entry.name + "`: " + escapeText(entry.description)).join("\n");
+}
+/**
+* Replace only the available_skills block; preamble, footer, and update marker stay byte-identical.
+* @param capture - platform message captured before projection.
+* @param entries - projected entries.
+* @returns a platform-sourced message with the same framing.
+*/
+function renderCatalog(capture, entries) {
+	const start = capture.text.indexOf("<available_skills>");
+	const end = capture.text.indexOf("</available_skills>", start);
+	return createUserMessage({
+		content: [{
+			type: "text",
+			text: capture.text.slice(0, start + 18) + "\n" + renderEntries(entries) + "\n" + capture.text.slice(end)
+		}],
+		source: {
+			...capture.source,
+			entries: capture.source.entries
+		}
+	});
+}
+/**
+* Build a replacement catalog when no current catalog message exists.
+* @param sourceEntries - full platform entries; keeps the platform digest stable.
+* @param entries - projected entries.
+* @returns a skill-catalog message with update=true.
+*/
+function renderCatalogUpdate(sourceEntries, entries) {
+	return createUserMessage({
+		content: [{
+			type: "text",
+			text: [
+				"<system-reminder>",
+				"The available skill catalog changed. This complete catalog replaces every earlier available-skills list in this session:",
+				"",
+				"<available_skills>",
+				...entries.map((entry) => "- `" + entry.name + "`: " + escapeText(entry.description)),
+				"</available_skills>",
+				"",
+				"Use only names in this replacement catalog. If the user names a listed skill, or the task clearly matches its description, call the `skill` tool with the exact name before acting.",
+				"A user may also invoke a skill directly; its <skill_content> block then appears in this conversation. Follow it, and do not call the `skill` tool again for that skill.",
+				"</system-reminder>"
+			].join("\n")
+		}],
+		source: {
+			kind: "skill-catalog",
+			form: "catalog",
+			update: true,
+			entries: sourceEntries
+		}
+	});
+}
+/** @returns the exact platform message captured before projection. */
+function restoreCatalog(capture) {
+	return createUserMessage({
+		content: [{
+			type: "text",
+			text: capture.text
+		}],
+		source: capture.source
+	});
+}
+//#endregion
+//#region lib/types/projection-adapter.js
+/** @returns the first platform catalog message in the current decision. */
+function findCatalogMessage(decision) {
+	if (decision.kind !== "enter") return void 0;
+	return decision.messages.find((message) => message.source.kind === "skill-catalog");
+}
+/**
+* Replace the current catalog message with projected entries, preserving its framing.
+* @param decision - current pre-step decision.
+* @param capture - platform catalog captured from the same decision.
+* @param entries - projected entries.
+* @returns a new decision; unchanged when no catalog message exists.
+*/
+function applyCapturedProjection(decision, capture, entries) {
+	if (decision.kind !== "enter") return decision;
+	const index = decision.messages.findIndex((message) => message.source.kind === "skill-catalog");
+	if (index < 0) return decision;
+	const messages = [...decision.messages];
+	messages[index] = renderCatalog(capture, entries);
+	return {
+		...decision,
+		messages
+	};
+}
+/**
+* Restore the exact captured platform catalog in the current decision.
+* @param decision - current pre-step decision.
+* @param capture - durable platform catalog capture.
+* @returns a new decision; unchanged when no catalog message exists.
+*/
+function restoreCapturedProjection(decision, capture) {
+	if (decision.kind !== "enter") return decision;
+	const withoutContext = decision.messages.filter((message) => message.source.kind !== "evolution-skill-projection");
+	const index = withoutContext.findIndex((message) => message.source.kind === "skill-catalog");
+	if (index < 0) return decision;
+	const messages = [...withoutContext];
+	messages[index] = restoreCatalog(capture);
+	return {
+		...decision,
+		messages
+	};
+}
+/**
+* Append a replacement catalog when the current decision has no catalog message.
+* @param decision - current pre-step decision.
+* @param sourceEntries - full platform entries for the stable digest.
+* @param result - projection result.
+* @returns decision with replacement catalog plus optional context.
+*/
+function applyReplacementDecision(decision, sourceEntries, result) {
+	if (decision.kind !== "enter") return decision;
+	const update = renderCatalogUpdate(sourceEntries, result.catalogEntries);
+	const context = renderProjectionContext(result);
+	const messages = context === void 0 ? [...decision.messages, update] : [
+		...decision.messages,
+		update,
+		context
+	];
+	return {
+		...decision,
+		messages
+	};
+}
+/**
+* Append a full replacement catalog without a current catalog message.
+* @param decision - current pre-step decision.
+* @param capture - durable platform capture.
+* @returns decision with a full replacement catalog.
+*/
+function applyRestoreUpdate(decision, capture) {
+	if (decision.kind !== "enter") return decision;
+	return {
+		...decision,
+		messages: [...decision.messages, renderCatalogUpdate(capture.source.entries, capture.entries)]
+	};
+}
+/** @returns captured current catalog or undefined when the shape is unknown. */
+function captureDecisionCatalog(decision) {
+	const message = findCatalogMessage(decision);
+	return message === void 0 ? void 0 : captureCatalog(message);
+}
+/** @returns a model-visible projection context message, or undefined when empty. */
+function renderProjectionContext(result) {
+	if (result.context === "") return void 0;
+	return createUserMessage({
+		content: [{
+			type: "text",
+			text: result.context
+		}],
+		source: {
+			kind: "evolution-skill-projection",
+			entries: result.catalogEntries,
+			hiddenNames: result.hiddenNames,
+			digest: result.digest
+		}
+	});
+}
+/**
+* Apply the complete projection: replace the current catalog and append one context message.
+* @param decision - current pre-step decision.
+* @param capture - platform catalog captured from the same decision.
+* @param result - complete projection.
+* @returns new decision; unchanged when no catalog exists.
+*/
+function applyProjectedDecision(decision, capture, result) {
+	const withCatalog = applyCapturedProjection(decision, capture, result.catalogEntries);
+	const context = renderProjectionContext(result);
+	if (context === void 0 || withCatalog.kind !== "enter") return withCatalog;
+	return withCatalog.messages.some((message) => message.source.kind === "evolution-skill-projection" && message.source.digest === result.digest) ? withCatalog : {
+		...withCatalog,
+		messages: [...withCatalog.messages, context]
+	};
+}
+//#endregion
+//#region lib/types/view-state.js
+/**
+* Derive one view's state without consulting another view.
+* @param input - per-view health and identity.
+* @returns state with reasons; hidden safety is evaluated by canHide.
+*/
+function deriveViewState(input) {
+	const reasons = [...input.reasons ?? []];
+	if (input.mode === "off") return {
+		...input,
+		phase: "off",
+		reasons
+	};
+	if (!input.catalogComplete) reasons.push("catalog-incomplete");
+	if (input.map === "empty" || input.map === "corrupt") {
+		reasons.push(input.map === "corrupt" ? "map-corrupt" : "map-empty");
+		return {
+			...input,
+			phase: "unavailable",
+			reasons
+		};
+	}
+	if (input.map === "stale") reasons.push("map-stale");
+	if (input.search === "degraded") reasons.push("search-degraded");
+	if (input.policy === "degraded") reasons.push("policy-degraded");
+	if (!input.catalogComplete || input.search === "degraded" || input.policy === "degraded") return {
+		...input,
+		phase: "degraded",
+		reasons
+	};
+	return {
+		...input,
+		phase: "ready",
+		reasons
+	};
+}
+/** @returns true only when this view may hide catalog entries. */
+function canHide(state) {
+	return state.phase === "ready" && state.map === "ready" && state.search === "ready" && state.policy === "ready";
+}
+/** @returns true when this view may render cards, even if hiding is blocked. */
+function canProject(state) {
+	return (state.phase === "ready" || state.phase === "degraded") && (state.map === "ready" || state.map === "stale");
+}
+/** Bounded view-state cache keyed by view identity and codec version. */
+var ViewStateRegistry = class {
+	entries = /* @__PURE__ */ new Map();
+	limit;
+	ttlMs;
+	now;
+	constructor(options = {}) {
+		this.limit = options.limit ?? 64;
+		this.ttlMs = options.ttlMs ?? 10 * 6e4;
+		this.now = options.now ?? Date.now;
+	}
+	/** @returns cache key including all identity components that can change a view. */
+	key(state, codecVersion) {
+		return state.viewKey + "|" + state.mapVersion + "|" + state.policyDigest + "|" + codecVersion;
+	}
+	set(state, codecVersion) {
+		const key = this.key(state, codecVersion);
+		this.entries.delete(key);
+		this.entries.set(key, {
+			state,
+			at: this.now()
+		});
+		this.prune();
+	}
+	get(viewKey, mapVersion, policyDigest, codecVersion) {
+		const key = viewKey + "|" + mapVersion + "|" + policyDigest + "|" + codecVersion;
+		const entry = this.entries.get(key);
+		if (entry === void 0) return void 0;
+		if (this.now() - entry.at > this.ttlMs) {
+			this.entries.delete(key);
+			return;
+		}
+		return entry.state;
+	}
+	deleteView(viewKey) {
+		for (const [key, entry] of this.entries) if (entry.state.viewKey === viewKey) this.entries.delete(key);
+	}
+	prune() {
+		const now = this.now();
+		for (const [key, entry] of this.entries) if (now - entry.at > this.ttlMs) this.entries.delete(key);
+		while (this.entries.size > this.limit) {
+			const oldest = this.entries.keys().next().value;
+			if (oldest === void 0) break;
+			this.entries.delete(oldest);
+		}
+	}
+};
+//#endregion
+//#region lib/types/projection-runtime.js
+function mapStateOf(snapshot, staleAfterHours, now) {
+	if (snapshot === void 0) return "corrupt";
+	if (snapshot.domains.length === 0) return "empty";
+	if (staleAfterHours !== void 0 && snapshot.domains.some((node) => now - node.updatedAt > staleAfterHours * 36e5)) return "stale";
+	return "ready";
+}
+function effectiveMode(mode) {
+	return mode === "off" ? "off" : mode === "auto" ? "shadow" : "on";
+}
+function catalogText(message) {
+	return message.content.map((block) => block.type === "text" ? block.text ?? "" : "").join("");
+}
+function fullCatalogText(capture) {
+	return catalogText(renderCatalog(capture, capture.entries));
+}
+function sessionCatalogCapture(agent) {
+	const readEvents = agent.session.readEvents;
+	if (readEvents === void 0) return void 0;
+	let projected;
+	for (const event of readEvents()) {
+		if (event.type !== "user/message" || typeof event.data !== "object" || event.data === null) continue;
+		const message = event.data;
+		if (message.source.kind !== "skill-catalog") continue;
+		const capture = captureCatalog(message);
+		if (capture === void 0) continue;
+		projected = capture;
+		if (catalogText(message) === fullCatalogText(capture)) return capture;
+	}
+	return projected;
+}
+/** Per-view projection runtime; no global readiness and no history edits. */
+var ProjectionRuntime = class {
+	ports;
+	states = new ViewStateRegistry();
+	last = {
+		action: "none",
+		digest: "",
+		at: 0
+	};
+	lastByAgent = /* @__PURE__ */ new Map();
+	constructor(ports) {
+		this.ports = ports;
+	}
+	/** @returns last action for one agent, or the latest process-wide action. */
+	report(agent) {
+		return agent === void 0 ? this.last : this.lastByAgent.get(String(agent.id)) ?? this.last;
+	}
+	mark(agent, action, digest, content = "") {
+		const report = {
+			action,
+			digest,
+			content,
+			at: Date.now()
+		};
+		this.last = report;
+		this.lastByAgent.set(String(agent.id), report);
+	}
+	/** @returns current state for diagnostics, if this process has seen the view. */
+	stateFor(viewKey, mapVersion, policyDigest) {
+		return this.states.get(viewKey, mapVersion, policyDigest, this.ports.codecVersion);
+	}
+	async restore(agent, viewKey, decision, currentCapture) {
+		const record = await this.ports.journal.latest(String(agent.id), viewKey, this.ports.codecVersion);
+		const sessionBase = sessionCatalogCapture(agent);
+		const fullSession = sessionBase !== void 0 && sessionBase.text === fullCatalogText(sessionBase) ? sessionBase : void 0;
+		const durable = currentCapture !== void 0 && currentCapture.text !== fullCatalogText(currentCapture) ? fullSession ?? record?.base : currentCapture ?? fullSession ?? record?.base;
+		if (durable === void 0) {
+			this.mark(agent, "blocked", "");
+			return decision;
+		}
+		const fullText = fullCatalogText(durable);
+		const previous = this.report(agent);
+		if (previous.action === "restored" && previous.content === fullText) return decision;
+		const restored = currentCapture === void 0 ? applyRestoreUpdate(decision, durable) : restoreCapturedProjection(decision, durable);
+		if (record !== void 0) await this.ports.journal.remove(record.sessionId, record.viewKey, record.projectionDigest, record.codecVersion);
+		this.mark(agent, "restored", record?.projectionDigest ?? "", fullText);
+		return restored;
+	}
+	async readState(agent, signal) {
+		const cwd = await this.ports.workingDirectory.ensure(agent, signal);
+		const view = await new SkillIndex(this.ports.skillIndexSource).read({
+			cwd,
+			scopeKey: String(agent.id),
+			scope: agent,
+			signal
+		});
+		let snapshot;
+		try {
+			snapshot = await this.ports.map.read();
+		} catch {
+			snapshot = void 0;
+		}
+		const knownDomainIds = snapshot === void 0 ? void 0 : new Set(snapshot.domains.map((node) => node.id));
+		const store = this.ports.policyFor === void 0 ? this.ports.policy : await this.ports.policyFor(cwd);
+		const policy = store.resolve(knownDomainIds);
+		const policyDigest = store.digest(knownDomainIds);
+		const search = this.ports.searchAvailable?.() === false ? "degraded" : "ready";
+		const state = deriveViewState({
+			viewKey: view.viewKey,
+			mode: effectiveMode(policy.mode),
+			map: mapStateOf(snapshot, this.ports.staleAfterHours, Date.now()),
+			search,
+			policy: policy.degraded.length === 0 ? "ready" : "degraded",
+			catalogComplete: view.complete,
+			mapVersion: snapshot?.mapVersion ?? "0",
+			policyDigest,
+			viewCatalogDigest: view.viewCatalogDigest
+		});
+		this.states.set(state, this.ports.codecVersion);
+		return {
+			view,
+			snapshot,
+			policy,
+			policyDigest,
+			state
+		};
+	}
+	/** @returns current per-view state without projecting; used by diagnostic commands. */
+	async inspect(agent, signal) {
+		if (this.ports.mode === "off") return {
+			viewKey: "off",
+			phase: "off",
+			map: "empty",
+			search: "ready",
+			policy: "ready",
+			reasons: [],
+			mapVersion: "0",
+			policyDigest: "",
+			viewCatalogDigest: ""
+		};
+		return (await this.readState(agent, signal)).state;
+	}
+	/**
+	* Project or restore one current pre-step decision.
+	* @param agent - session owner; identity comes from workingDirectory.
+	* @param decision - current waterfall decision.
+	* @param signal - request cancellation.
+	* @returns projected, restored, or unchanged decision.
+	*/
+	async project(agent, decision, signal) {
+		if (this.ports.mode === "off") return decision;
+		if (this.ports.isFrozen !== void 0 && await this.ports.isFrozen(agent)) return decision;
+		const { view, snapshot, policy, policyDigest, state } = await this.readState(agent, signal);
+		const currentCapture = captureDecisionCatalog(decision);
+		let capture = currentCapture;
+		if (capture === void 0) capture = (await this.ports.journal.latest(String(agent.id), view.viewKey, this.ports.codecVersion))?.base;
+		if (capture === void 0) capture = sessionCatalogCapture(agent);
+		if (!canProject(state) || snapshot === void 0) return this.restore(agent, view.viewKey, decision, currentCapture);
+		if (capture === void 0) {
+			this.mark(agent, "blocked", "");
+			return decision;
+		}
+		const projection = buildDomainProjection({
+			entries: capture.entries,
+			rows: view.rows,
+			complete: view.complete,
+			snapshot,
+			policy,
+			viewKey: view.viewKey,
+			scope: String(agent.id),
+			mapVersion: snapshot.mapVersion,
+			policyDigest,
+			viewCatalogDigest: view.viewCatalogDigest,
+			adapterVersion: this.ports.adapterVersion,
+			projectionSchemaVersion: this.ports.projectionSchemaVersion,
+			discoveryMode: this.ports.mode,
+			...this.ports.maxCards === void 0 ? {} : { maxCards: this.ports.maxCards },
+			...this.ports.tokenBudget === void 0 ? {} : { tokenBudget: this.ports.tokenBudget },
+			searchAvailable: state.search === "ready",
+			mode: effectiveMode(policy.mode),
+			mapStale: state.map === "stale",
+			now: Date.now(),
+			...this.ports.staleAfterHours === void 0 ? {} : { staleAfterHours: this.ports.staleAfterHours },
+			...this.ports.descriptionStaleAfterHours === void 0 ? {} : { descriptionStaleAfterHours: this.ports.descriptionStaleAfterHours }
+		});
+		if (!projection.complete) return this.restore(agent, view.viewKey, decision, currentCapture);
+		const expectedText = renderCatalog(capture, projection.catalogEntries).content.map((block) => block.type === "text" ? block.text : "").join("");
+		if (currentCapture !== void 0 && currentCapture.text === expectedText) return decision;
+		const previous = this.report(agent);
+		if (currentCapture === void 0 && previous.action === "applied" && previous.digest === projection.digest && previous.content === expectedText) return decision;
+		await this.ports.journal.put({
+			sessionId: String(agent.id),
+			viewKey: view.viewKey,
+			projectionDigest: projection.digest,
+			codecVersion: this.ports.codecVersion,
+			mapVersion: snapshot.mapVersion,
+			policyDigest,
+			base: capture,
+			createdAt: Date.now()
+		});
+		this.mark(agent, "applied", projection.digest, expectedText);
+		return currentCapture === void 0 ? applyReplacementDecision(decision, capture.source.entries, projection) : applyProjectedDecision(decision, capture, projection);
+	}
+};
+//#endregion
+//#region lib/types/domain-generation-prompt.js
+/** Frozen initial domain-generation prompt; caller owns schema/IDs. */
+const DOMAIN_GENERATION_PROMPT_VERSION = "v2";
+const DOMAIN_GENERATION_PROMPT_V1 = `Group the provided skills into first-level domains.
+Use only name, description, and whenToUse; do not infer from skill bodies.
+Produce 8–12 domains that are coherent, distinct, task-recognizable, and useful as an awareness layer. A single skill is not a domain. Each domain has a name, one-sentence purpose, in-scope, out-of-scope, triggers, and evidence skill names that actually support it.
+Prefer clear boundaries over exhaustive coverage. If the evidence is weak, leave the skill unassigned rather than forcing it into a domain. Together the domains should cover the library where evidence supports it. Domain IDs are assigned by the caller.
+Return only the structured result.`;
+/** @returns a parameterized initial-domain prompt; default 8–12. */
+function buildDomainGenerationPrompt(options = {}) {
+	const requestedMin = options.minDomains ?? 8;
+	const requestedMax = options.maxDomains ?? 12;
+	const valid = Number.isSafeInteger(requestedMin) && Number.isSafeInteger(requestedMax) && requestedMin >= 2 && requestedMax >= requestedMin && requestedMax <= 20;
+	return `You are designing a first-level domain map for a skill library.
+Input is limited to each skill's name, description, and whenToUse; do not infer from skill bodies.
+Choose ${valid ? requestedMin : 8}–${valid ? requestedMax : 12} domains that help a model decide where to look. Domains are an awareness layer, not a complete taxonomy.
+Each domain needs a name, one-sentence purpose, in-scope, out-of-scope, triggers, and evidence skill names copied from the input.
+Keep domains coherent, distinguishable, and recognizable from a task description; a single skill is not a domain. Do not invent skills or domains.
+Prefer clear boundaries over exhaustive coverage. Leave a skill unassigned when evidence is weak rather than forcing it. The caller assigns IDs.
+Return only a JSON object with a "domains" array. Each domain must have title, purpose, inScope, outOfScope, triggers, and evidenceSkillKeys. No markdown fences and no prose.`;
+}
+const DOMAIN_GENERATION_PROMPT_V2 = buildDomainGenerationPrompt();
+const DOMAIN_GENERATION_PROMPT_HASH = createHash("sha256").update(DOMAIN_GENERATION_PROMPT_V2, "utf8").digest("hex");
+/** Active prompt; v1 remains frozen for traceability. */
+const DOMAIN_GENERATION_PROMPT = DOMAIN_GENERATION_PROMPT_V2;
+//#endregion
+//#region lib/types/domain-generation-llm.js
+/** Typed failure from LLM transport/parse/validation. */
+var DomainGenerationError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "DomainGenerationError";
+	}
+};
+/** @returns parsed proposal with the caller's skill set; throws on malformed/empty output. */
+function parseDomainGenerationProposal(text, skills) {
+	const cleaned = text.trim().replace(/^\`\`\`(?:json)?\s*/i, "").replace(/\`\`\`$/, "").trim();
+	if (cleaned.length === 0) throw new DomainGenerationError("invalid-output", "domain generation returned empty output");
+	let parsed;
+	try {
+		parsed = JSON.parse(cleaned);
+	} catch (error) {
+		throw new DomainGenerationError("invalid-output", "domain generation returned non-JSON output: " + (error instanceof Error ? error.message : String(error)));
+	}
+	const candidate = isRecord(parsed) && Array.isArray(parsed.domains) ? { domains: parsed.domains } : Array.isArray(parsed) ? { domains: parsed } : void 0;
+	if (candidate === void 0) throw new DomainGenerationError("invalid-output", "domain generation output must be an object with domains[]");
+	const checked = validateDomainGeneration({ skills }, candidate);
+	if (!checked.ok) throw new DomainGenerationError("invalid-proposal", "invalid domain proposal: " + checked.errors.join("; "));
+	return candidate;
+}
+/** Production LLM adapter; validates before returning, never writes the map. */
+var LlmDomainGenerationPort = class {
+	llm;
+	options;
+	constructor(llm, options) {
+		this.llm = llm;
+		this.options = {
+			provider: options.provider,
+			model: options.model,
+			maxTokens: options.maxTokens ?? 4096,
+			timeoutMs: options.timeoutMs ?? 12e4,
+			attempts: options.attempts ?? 3
+		};
+	}
+	/**
+	* Generate one validated domain proposal.
+	* @param input - live facts, prompt, and cancellation.
+	* @returns validated proposal with 8–12 domains and known evidence.
+	*/
+	async generate(input) {
+		const timeout = AbortSignal.timeout(this.options.timeoutMs);
+		const signal = input.signal === void 0 ? timeout : AbortSignal.any([input.signal, timeout]);
+		const skillContext = "\n\nAvailable skills (copy evidenceSkillKeys only from these names):\n" + input.skills.map((skill) => "- " + skill.name + ": " + skill.description + (skill.whenToUse === void 0 ? "" : " | when: " + skill.whenToUse)).join("\n");
+		const basePrompt = input.prompt + skillContext;
+		let feedback = "";
+		let last;
+		for (let attempt = 1; attempt <= this.options.attempts; attempt += 1) try {
+			const prompt = feedback === "" ? basePrompt : basePrompt + "\nPrevious output was rejected: " + feedback + "\nReturn only the structured result with 8-12 domains.";
+			const assembler = new BlockAssembler();
+			for await (const chunk of this.llm.stream({
+				provider: this.options.provider,
+				model: this.options.model,
+				messages: [createUserMessage({
+					content: [{
+						type: "text",
+						text: prompt
+					}],
+					source: {
+						kind: "evolution-skill-generation",
+						form: "notice",
+						summary: "initial domain generation"
+					}
+				})],
+				maxTokens: this.options.maxTokens,
+				signal
+			})) assembler.push(chunk);
+			return parseDomainGenerationProposal(assembler.blocks().filter((block) => block.type === "text").map((block) => block.text).join("\n"), input.skills);
+		} catch (error) {
+			if (!(error instanceof DomainGenerationError) || error.code !== "invalid-output" && error.code !== "invalid-proposal") {
+				if (timeout.aborted) throw new DomainGenerationError("timeout", "domain generation timed out after " + this.options.timeoutMs + "ms");
+				throw new DomainGenerationError("llm-unavailable", "domain generation llm failed: " + (error instanceof Error ? error.message : String(error)));
+			}
+			last = error;
+			feedback = error.message;
+		}
+		throw last ?? new DomainGenerationError("invalid-output", "domain generation failed");
+	}
+};
+//#endregion
+//#region lib/types/generation-input.js
+/**
+* Convert live model-invocable rows into the initial-map writer's real facts.
+* @param rows - current view rows.
+* @returns stable keys and three-field hashes, never synthetic values.
+*/
+function bootstrapFactsFromRows(rows) {
+	return rows.filter((row) => row.modelInvocable).map((row) => ({
+		name: row.name,
+		description: row.description,
+		...row.whenToUse === void 0 ? {} : { whenToUse: row.whenToUse },
+		skillKey: row.skillKey,
+		threeFieldHash: row.threeFieldHash
+	}));
+}
+//#endregion
+//#region lib/types/generation-composition.js
+/**
+* Resolve the production port; mode:on without an llm service fails loud.
+* @param input - mode and concrete llm service.
+* @returns port, or undefined for mode:off.
+*/
+function resolveGenerationPort(input) {
+	if (input.mode === "off") return void 0;
+	if (input.llm === void 0) throw new DomainGenerationError("llm-unavailable", "evolution-skill-discovery: mode=" + input.mode + " requires an llm service for initial domain generation");
+	return new LlmDomainGenerationPort(input.llm, {
+		provider: input.provider,
+		model: input.model,
+		...input.maxTokens === void 0 ? {} : { maxTokens: input.maxTokens },
+		...input.timeoutMs === void 0 ? {} : { timeoutMs: input.timeoutMs },
+		...input.attempts === void 0 ? {} : { attempts: input.attempts }
+	});
+}
+/**
+* Build a global-map generation request from live rows.
+* @param input - map scope, source identity, rows, and prompt.
+* @returns request with real facts; never reads config arrays.
+*/
+function buildGenerationRequest(input) {
+	return {
+		mapScope: input.mapScope,
+		sourceDigest: input.sourceDigest,
+		expectedMapVersion: input.mapVersion,
+		facts: bootstrapFactsFromRows(input.rows),
+		prompt: input.prompt,
+		promptVersion: input.promptVersion,
+		model: input.model,
+		runId: input.runId
+	};
+}
+//#endregion
+//#region lib/types/view-snapshot-store.js
+/** Durable per-session view snapshot; old epochs stay frozen. */
+var ViewSnapshotStore = class {
+	io;
+	path;
+	constructor(io, path) {
+		this.io = io;
+		this.path = path;
+	}
+	async read() {
+		const content = await this.io.readText(this.path);
+		if (content === null) return {
+			schemaVersion: 1,
+			sessions: {}
+		};
+		try {
+			const parsed = JSON.parse(content);
+			return parsed.schemaVersion === 1 && typeof parsed.sessions === "object" && parsed.sessions !== null ? {
+				schemaVersion: 1,
+				sessions: parsed.sessions
+			} : {
+				schemaVersion: 1,
+				sessions: {}
+			};
+		} catch {
+			return {
+				schemaVersion: 1,
+				sessions: {}
+			};
+		}
+	}
+	/** Persist one session snapshot; first writer wins unless overwrite is explicit. */
+	async put(snapshot, options = {}) {
+		const current = await this.read();
+		if (current.sessions[snapshot.sessionId] !== void 0 && options.overwrite !== true) return;
+		const sessions = {
+			...current.sessions,
+			[snapshot.sessionId]: {
+				viewKey: snapshot.viewKey,
+				cwd: snapshot.cwd,
+				viewCatalogDigest: snapshot.viewCatalogDigest,
+				mapVersion: snapshot.mapVersion,
+				configDigest: snapshot.configDigest,
+				featureEpoch: snapshot.featureEpoch,
+				createdAt: snapshot.createdAt
+			}
+		};
+		await this.io.writeText(this.path, JSON.stringify({
+			schemaVersion: 1,
+			sessions
+		}));
+	}
+	/** @returns frozen snapshot for one session, if recorded. */
+	async get(sessionId) {
+		const entry = (await this.read()).sessions[sessionId];
+		return entry === void 0 ? void 0 : {
+			sessionId,
+			...entry
+		};
+	}
+	/**
+	* @returns true for legacy sessions without a snapshot and for older feature epochs.
+	*/
+	async isFrozen(sessionId, currentFeatureEpoch) {
+		const snapshot = await this.get(sessionId);
+		return snapshot === void 0 || snapshot.featureEpoch !== currentFeatureEpoch;
+	}
+};
+//#endregion
+//#region lib/types/assignment.js
+/** In-memory idempotent queue; production adapter can persist by key. */
+var MemoryAssignmentQueue = class {
+	entries = /* @__PURE__ */ new Map();
+	async enqueue(input) {
+		const existing = this.entries.get(input.key);
+		if (existing !== void 0) return {
+			entry: existing,
+			duplicate: true
+		};
+		const entry = {
+			...input,
+			status: "queued"
+		};
+		this.entries.set(input.key, entry);
+		return {
+			entry,
+			duplicate: false
+		};
+	}
+	async update(key, status, pendingReason) {
+		const entry = this.entries.get(key);
+		if (entry !== void 0) {
+			entry.status = status;
+			entry.pendingReason = pendingReason;
+		}
+	}
+	list() {
+		return [...this.entries.values()];
+	}
+};
+function digest(value) {
+	return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+/** @returns idempotency key for one proposal observation. */
+function assignmentKey(input) {
+	return digest([
+		input.skillKey,
+		input.threeFieldHash,
+		input.proposalDigest,
+		input.mapVersion
+	]);
+}
+/** @returns stable proposal digest; undefined proposal is digest of null. */
+function proposalDigest(proposal) {
+	return digest(proposal ?? null);
+}
+/** @returns a closed-set pending reason or undefined when the proposal can enqueue. */
+function validateProposal(proposal) {
+	if (proposal.mode !== "existing" && proposal.mode !== "new") return "schema-invalid";
+	if (typeof proposal.confidence !== "number" || proposal.confidence < 0 || proposal.confidence > 1 || typeof proposal.reason !== "string" || typeof proposal.mapVersion !== "string") return "schema-invalid";
+	if (proposal.mode === "existing" && (typeof proposal.id !== "string" || proposal.id.length === 0)) return "invalid-id";
+	if (proposal.mode === "new") {
+		const proposed = proposal.proposed;
+		if (proposed === void 0 || proposed.title.trim().length === 0 || proposed.purpose.trim().length === 0 || proposed.inScope.length === 0 || proposed.outOfScope.length === 0 || proposed.triggers.length === 0) return "new-domain-conflict";
+	}
+}
+/** @returns true only when whenToUse is covered by in/out/triggers; names alone do not count. */
+function coveredByDomain(whenToUse, domain) {
+	const text = whenToUse.toLowerCase();
+	if (text.length === 0) return false;
+	if (domain.outOfScope.some((value) => value.length > 0 && text.includes(value.toLowerCase()))) return false;
+	return domain.triggers.some((value) => value.length > 0 && text.includes(value.toLowerCase())) || domain.inScope.some((value) => value.length > 0 && text.includes(value.toLowerCase()));
+}
+/** One assignment sidecar service; the only map write path for create. */
+var DomainAssignmentService = class {
+	queue;
+	store;
+	options;
+	constructor(queue, store, options) {
+		this.queue = queue;
+		this.store = store;
+		this.options = options;
+	}
+	/** Stage a create proposal without queueing it. */
+	stage(submission) {
+		return {
+			id: digest([
+				"staged",
+				submission.skillKey,
+				submission.threeFieldHash
+			]),
+			submission
+		};
+	}
+	/** Approve a staged create; only this call enqueues. */
+	async approve(staged) {
+		return this.submit(staged.submission);
+	}
+	/**
+	* Submit a create proposal after SkillLibrary.create succeeded.
+	* @param submission - skill identity, three-field hash, permission, proposal.
+	* @returns queue/pending/unclassified; never rolls back create.
+	*/
+	async submit(submission) {
+		if (!this.options.createClassificationEnabled) return {
+			kind: "unclassified",
+			reason: "feature-off"
+		};
+		if (!submission.modelInvocable) return {
+			kind: "unclassified",
+			reason: "not-model-invocable"
+		};
+		if (submission.proposal === void 0) {
+			if (this.options.createCardsAvailable === true) {
+				const reason = "schema-invalid";
+				return {
+					kind: "pending",
+					entry: {
+						key: digest([
+							"missing-proposal",
+							submission.skillKey,
+							submission.threeFieldHash
+						]),
+						submission,
+						proposalDigest: proposalDigest(void 0),
+						createdAt: this.now(),
+						status: "pending",
+						pendingReason: reason
+					},
+					reason
+				};
+			}
+			return {
+				kind: "unclassified",
+				reason: "no-proposal"
+			};
+		}
+		const invalid = validateProposal(submission.proposal);
+		const pdigest = proposalDigest(submission.proposal);
+		const key = assignmentKey({
+			skillKey: submission.skillKey,
+			threeFieldHash: submission.threeFieldHash,
+			proposalDigest: pdigest,
+			mapVersion: submission.proposal.mapVersion
+		});
+		let queued;
+		try {
+			queued = await this.queue.enqueue({
+				key,
+				submission,
+				proposalDigest: pdigest,
+				createdAt: submission.now ?? this.now()
+			});
+		} catch {
+			return {
+				kind: "pending",
+				entry: {
+					key,
+					submission,
+					proposalDigest: pdigest,
+					createdAt: submission.now ?? this.now(),
+					status: "pending",
+					pendingReason: "queue-unavailable"
+				},
+				reason: "queue-unavailable"
+			};
+		}
+		if (invalid !== void 0) {
+			await this.queue.update(key, "pending", invalid);
+			return {
+				kind: "pending",
+				entry: {
+					...queued.entry,
+					status: "pending",
+					pendingReason: invalid
+				},
+				reason: invalid
+			};
+		}
+		return {
+			kind: "queued",
+			entry: queued.entry,
+			duplicate: queued.duplicate
+		};
+	}
+	/** Process one queued entry with the current map; CAS failure becomes pending. */
+	async process(entry) {
+		const proposal = entry.submission.proposal;
+		if (proposal === void 0) return {
+			kind: "pending",
+			entry,
+			reason: "schema-invalid"
+		};
+		const current = await this.store.read();
+		if (proposal.mapVersion !== current.mapVersion) {
+			await this.queue.update(entry.key, "pending", "map-version-stale");
+			return {
+				kind: "pending",
+				entry: {
+					...entry,
+					status: "pending",
+					pendingReason: "map-version-stale"
+				},
+				reason: "map-version-stale"
+			};
+		}
+		try {
+			const next = buildNext(current, entry, proposal, this.options.provisionalThreshold ?? 3);
+			const committed = await this.store.commit(current.mapVersion, {
+				mapVersion: next.mapVersion,
+				domains: next.domains,
+				edges: next.edges
+			});
+			const status = next.provisional ? "provisional" : "applied";
+			await this.queue.update(entry.key, status);
+			return {
+				kind: status,
+				entry: {
+					...entry,
+					status
+				},
+				mapVersion: committed.mapVersion
+			};
+		} catch (error) {
+			if (error instanceof DomainMapVersionConflict) {
+				await this.queue.update(entry.key, "pending", "map-version-stale");
+				return {
+					kind: "pending",
+					entry: {
+						...entry,
+						status: "pending",
+						pendingReason: "map-version-stale"
+					},
+					reason: "map-version-stale"
+				};
+			}
+			const reason = error instanceof Error && (error.message === "unknown-domain" || error.message === "new-domain-conflict" || error.message === "schema-invalid") ? error.message : "queue-unavailable";
+			await this.queue.update(entry.key, "pending", reason);
+			return {
+				kind: "pending",
+				entry: {
+					...entry,
+					status: "pending",
+					pendingReason: reason
+				},
+				reason
+			};
+		}
+	}
+	/** Manually confirm one provisional domain; no semantic reclassification. */
+	async confirm(domainId) {
+		const current = await this.store.read();
+		const domain = current.domains.find((node) => node.id === domainId);
+		if (domain === void 0 || domain.status !== "provisional") return false;
+		const domains = current.domains.map((node) => node.id === domainId ? {
+			...node,
+			status: "active",
+			updatedAt: this.now()
+		} : node);
+		await this.store.commit(current.mapVersion, {
+			mapVersion: nextMapVersion(current.mapVersion),
+			domains,
+			edges: current.edges
+		});
+		return true;
+	}
+	now() {
+		return this.options.now?.() ?? Date.now();
+	}
+};
+function nextMapVersion(version) {
+	const numeric = Number(version);
+	return Number.isSafeInteger(numeric) && numeric >= 0 ? String(numeric + 1) : version + "+1";
+}
+function buildNext(current, entry, proposal, threshold) {
+	const edge = {
+		skillKey: entry.submission.skillKey,
+		domainId: "",
+		role: "primary",
+		confidence: proposal.confidence,
+		source: "create",
+		skillHash: entry.submission.threeFieldHash,
+		mapVersion: nextMapVersion(current.mapVersion),
+		status: "active",
+		assignedAt: entry.createdAt
+	};
+	const secondaries = (proposal.secondaryDomainIds ?? []).map((id) => {
+		const secondary = current.domains.find((node) => node.id === id);
+		if (secondary === void 0) throw new Error("unknown-domain");
+		return {
+			...edge,
+			domainId: secondary.id,
+			role: "secondary"
+		};
+	});
+	if (proposal.mode === "existing") {
+		const domain = current.domains.find((node) => node.id === proposal.id);
+		if (domain === void 0) throw new Error("unknown-domain");
+		if (!coveredByDomain(entry.submission.whenToUse ?? "", domain)) throw new Error("new-domain-conflict");
+		const members = new Set(current.edges.filter((item) => item.domainId === domain.id).map((item) => item.skillKey));
+		members.add(entry.submission.skillKey);
+		const promote = domain.status === "provisional" && members.size >= threshold;
+		const domains = promote ? current.domains.map((node) => node.id === domain.id ? {
+			...node,
+			status: "active",
+			updatedAt: entry.createdAt
+		} : node) : current.domains;
+		return {
+			mapVersion: nextMapVersion(current.mapVersion),
+			domains,
+			edges: [
+				...current.edges,
+				{
+					...edge,
+					domainId: domain.id
+				},
+				...secondaries.filter((secondary) => secondary.domainId !== domain.id)
+			],
+			provisional: domain.status === "provisional" && !promote
+		};
+	}
+	const proposed = proposal.proposed;
+	if (proposed === void 0) throw new Error("schema-invalid");
+	const normalizedTitle = proposed.title.trim().toLowerCase();
+	const existing = current.domains.find((node) => node.name.trim().toLowerCase() === normalizedTitle);
+	if (existing !== void 0 && existing.status !== "provisional") throw new Error("new-domain-conflict");
+	const id = existing?.id ?? mintDomainId(proposed.title);
+	if (current.domains.some((node) => node.id !== id && node.triggers.some((trigger) => proposed.triggers.includes(trigger)))) throw new Error("new-domain-conflict");
+	const domain = existing ?? {
+		id,
+		name: proposed.title,
+		purpose: proposed.purpose,
+		description: proposed.purpose,
+		inScope: proposed.inScope,
+		outOfScope: proposed.outOfScope,
+		triggers: proposed.triggers,
+		parentIds: [],
+		status: "provisional",
+		version: 1,
+		createdAt: entry.createdAt,
+		updatedAt: entry.createdAt,
+		descriptionHash: "pending",
+		descriptionVersion: 1,
+		descriptionStatus: "fresh",
+		provenance: { source: "create" },
+		quality: {}
+	};
+	const members = new Set(current.edges.filter((item) => item.domainId === id).map((item) => item.skillKey));
+	members.add(entry.submission.skillKey);
+	const promote = members.size >= threshold;
+	const finalDomain = promote ? {
+		...domain,
+		status: "active",
+		updatedAt: entry.createdAt
+	} : domain;
+	return {
+		mapVersion: nextMapVersion(current.mapVersion),
+		domains: existing === void 0 ? [...current.domains, finalDomain] : current.domains.map((node) => node.id === id ? finalDomain : node),
+		edges: [
+			...current.edges,
+			{
+				...edge,
+				domainId: id
+			},
+			...secondaries.filter((secondary) => secondary.domainId !== id)
+		],
+		provisional: !promote
+	};
+}
+//#endregion
+//#region lib/types/assignment-queue.js
+/** Durable assignment queue; process-local cache over one JSON file. */
+var JsonAssignmentQueue = class {
+	entries = /* @__PURE__ */ new Map();
+	loaded = false;
+	io;
+	path;
+	constructor(io, path) {
+		this.io = io;
+		this.path = path;
+	}
+	async load() {
+		if (this.loaded) return;
+		this.loaded = true;
+		const content = await this.io.readText(this.path);
+		if (content === null) return;
+		try {
+			const parsed = JSON.parse(content);
+			if (parsed.schemaVersion !== 1 || !Array.isArray(parsed.entries)) return;
+			for (const entry of parsed.entries) this.entries.set(entry.key, entry);
+		} catch {}
+	}
+	async persist() {
+		await this.io.writeText(this.path, JSON.stringify({
+			schemaVersion: 1,
+			entries: [...this.entries.values()]
+		}));
+	}
+	async enqueue(input) {
+		await this.load();
+		const existing = this.entries.get(input.key);
+		if (existing !== void 0) return {
+			entry: existing,
+			duplicate: true
+		};
+		const entry = {
+			...input,
+			status: "queued"
+		};
+		this.entries.set(input.key, entry);
+		await this.persist();
+		return {
+			entry,
+			duplicate: false
+		};
+	}
+	async update(key, status, pendingReason) {
+		await this.load();
+		const entry = this.entries.get(key);
+		if (entry === void 0) return;
+		entry.status = status;
+		entry.pendingReason = pendingReason;
+		await this.persist();
+	}
+	list() {
+		return [...this.entries.values()];
+	}
+};
+//#endregion
+//#region lib/types/worker.js
+/** Drivable worker; the composition may call drain on a schedule. */
+var AssignmentWorker = class {
+	service;
+	queue;
+	constructor(service, queue) {
+		this.service = service;
+		this.queue = queue;
+	}
+	/** Process queued entries once; returns processed count. */
+	async drain(limit = 10) {
+		const entries = this.queue.list().filter((entry) => entry.status === "queued").slice(0, Math.max(0, limit));
+		for (const entry of entries) await this.service.process(entry);
+		return entries.length;
+	}
+};
+//#endregion
+//#region lib/types/assignment-sidecar.js
+function submitCreate(service, args, options) {
+	if (typeof args.name !== "string" || args.name.length === 0) return void 0;
+	const parsed = parseFrontmatter(typeof args.content === "string" ? args.content : "");
+	const description = parsed?.frontmatter.description ?? "";
+	const rawWhenToUse = parsed?.frontmatter.whenToUse;
+	const whenToUse = typeof rawWhenToUse === "string" ? rawWhenToUse : void 0;
+	const domain = args.domain;
+	const proposal = typeof domain === "object" && domain !== null ? domain : void 0;
+	return service.submit({
+		skillKey: skillKeyOf({
+			provider: options.provider ?? "dsh-evolution",
+			source: options.source ?? "user-dsh",
+			name: args.name
+		}),
+		threeFieldHash: threeFieldHashOf({
+			name: args.name,
+			description,
+			...whenToUse === void 0 ? {} : { whenToUse }
+		}),
+		modelInvocable: parsed?.frontmatter["disable-model-invocation"] !== true,
+		...whenToUse === void 0 ? {} : { whenToUse },
+		...proposal === void 0 ? {} : { proposal }
+	}).then(() => options.onSubmitted?.());
+}
+/**
+* Observe successful create calls and submit their optional domain proposal.
+* Direct creates submit immediately; staged creates submit only after approval.
+* @param ctx - plugin context with tools and approval events.
+* @param service - the one assignment service.
+* @param options - provider/source identity for skillKey.
+* @returns disposer for both listeners.
+*/
+function installAssignmentSidecar(ctx, service, options = {}) {
+	const stopResult = ctx.on("tools/result", (exec, result) => {
+		if (result.isError || exec.name !== "skill_manage" || exec.agent === void 0) return;
+		if (result.value?.pending_id !== void 0) return;
+		const args = exec.arguments;
+		if (typeof args !== "object" || args === null) return;
+		const record = args;
+		if (record.action !== "create") return;
+		submitCreate(service, record, options)?.catch(() => {});
+	});
+	const stopApproval = ctx.on("evolution/approval-decided", ({ record, action, ok }) => {
+		if (!ok || action !== "approve" || record.kind !== "skill" || typeof record.args !== "object" || record.args === null) return;
+		const raw = record.args;
+		const operation = typeof raw.operation === "object" && raw.operation !== null ? raw.operation : raw;
+		if (operation.action !== "create") return;
+		submitCreate(service, operation, options)?.catch(() => {});
+	});
+	return () => {
+		stopResult();
+		stopApproval();
+	};
+}
+//#endregion
+//#region lib/types/awareness.js
+/** Static 1–2 sentence awareness; no domain list/tree. */
+const DISCOVERY_AWARENESS = "When skill coverage for a task is uncertain, the domain cards and skill_search can reduce it; search is optional, not a required step.";
+/**
+* Register the static awareness section; absent systemPrompt is a no-op.
+* platform-declaration anchor: the optional systemPrompt service declared in core PLATFORM_SERVICE_PROBES.
+*/
+function installDiscoveryAwareness(ctx) {
+	const prompt = ctx.get("systemPrompt");
+	if (prompt === void 0) return () => {};
+	return prompt.section({
+		name: "evolution-skill-discovery-awareness",
+		order: 40,
+		text: DISCOVERY_AWARENESS,
+		interpolate: false
+	});
+}
+//#endregion
+//#region lib/types/domain-description.js
+/** @returns true only for structural/definition events; normal skill add does not rewrite. */
+function shouldRegenerateDescription(event) {
+	return event !== "skill-add";
+}
+/** @returns true when the existing description may still serve. */
+function descriptionIsServable(status) {
+	return status === "fresh" || status === "stale";
+}
+/** @returns hash of child ids/description versions, never member skill names. */
+function descriptionHashOf(domain, children) {
+	const childRefs = children.map((child) => JSON.stringify([child.id, child.descriptionVersion])).sort();
+	return createHash("sha256").update(JSON.stringify([
+		domain.id,
+		domain.descriptionVersion,
+		childRefs
+	])).digest("hex");
+}
+/**
+* Render a domain description from definition fields only. It never appends
+* evidence/member skill names and is capped to 600 characters.
+* @param domain - domain definition.
+* @returns description text.
+*/
+function renderDomainDescription(domain) {
+	return [
+		domain.name + "：" + domain.purpose,
+		"适用：" + domain.inScope.join("；"),
+		"不适用：" + domain.outOfScope.join("；"),
+		"触发：" + domain.triggers.join("；")
+	].join("\n").slice(0, 600);
+}
+//#endregion
+export { DomainMapCorruptError as $, ViewStateRegistry as A, renderProjectionContext as B, DOMAIN_GENERATION_PROMPT as C, DOMAIN_GENERATION_PROMPT_VERSION as D, DOMAIN_GENERATION_PROMPT_V2 as E, applyProjectedDecision as F, restoreCatalog as G, captureCatalog as H, applyReplacementDecision as I, projectCatalog as J, buildDomainProjection as K, applyRestoreUpdate as L, canProject as M, deriveViewState as N, buildDomainGenerationPrompt as O, applyCapturedProjection as P, DOMAIN_MAP_SCHEMA_VERSION as Q, captureDecisionCatalog as R, parseDomainGenerationProposal as S, DOMAIN_GENERATION_PROMPT_V1 as T, renderCatalog as U, restoreCapturedProjection as V, renderCatalogUpdate as W, evaluateDomainQuality as X, sanitizeUntrustedText as Y, ProjectionJournal as Z, buildGenerationRequest as _, DISCOVERY_AWARENESS as a, mergeDomainPolicy as at, DomainGenerationError as b, AssignmentWorker as c, bootstrapDomainMapWithFacts as ct, MemoryAssignmentQueue as d, validateDomainGeneration as dt, DomainMapFileStore as et, assignmentKey as f, ViewSnapshotStore as g, validateProposal as h, shouldRegenerateDescription as i, DomainPolicyValidationError as it, canHide as j, ProjectionRuntime as k, JsonAssignmentQueue as l, domainGenerationMode as lt, proposalDigest as m, descriptionIsServable as n, DomainMapVersionConflict as nt, installDiscoveryAwareness as o, DomainGenerationCoordinator as ot, coveredByDomain as p, hiddenRecoverable as q, renderDomainDescription as r, DomainPolicyStore as rt, installAssignmentSidecar as s, bootstrapDomainMap as st, descriptionHashOf as t, DomainMapValidationError as tt, DomainAssignmentService as u, mintDomainId as ut, resolveGenerationPort as v, DOMAIN_GENERATION_PROMPT_HASH as w, LlmDomainGenerationPort as x, bootstrapFactsFromRows as y, findCatalogMessage as z };