@lmzhen/dsh-evolution-skill-discovery 0.0.0-stage → 0.30.40

package/lib/index.js

@@ -0,0 +1,2457 @@
+import { createHash } from "node:crypto";
+import { join, resolve } from "node:path";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { SessionSeq } from "@deepseek-ai/dsh-session";
+import MiniSearch from "minisearch";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { authorityFrom, evolutionIoAdapter, newSkillLibrary, parseFrontmatter } from "@lmzhen/dsh-evolution-core";
+import { homedir } from "node:os";
+//#region lib/types/identity.js
+function sha256(value) {
+	return createHash("sha256").update(value).digest("hex");
+}
+function canonical(value) {
+	if (value instanceof Set) return { $set: [...value].map(canonical).sort((left, right) => JSON.stringify(left) < JSON.stringify(right) ? -1 : JSON.stringify(left) > JSON.stringify(right) ? 1 : 0) };
+	if (value instanceof Map) return { $map: [...value.entries()].map(([key, entry]) => [canonical(key), canonical(entry)]).sort((left, right) => JSON.stringify(left) < JSON.stringify(right) ? -1 : JSON.stringify(left) > JSON.stringify(right) ? 1 : 0) };
+	if (Array.isArray(value)) return value.map(canonical);
+	if (typeof value === "object" && value !== null) return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, entry]) => [key, canonical(entry)]));
+	return value;
+}
+function digest$1(value) {
+	return sha256(JSON.stringify(canonical(value)));
+}
+/** @returns stable key for the winning provider/source/name tuple. */
+function skillKeyOf(summary) {
+	return JSON.stringify([
+		summary.provider,
+		summary.source,
+		summary.name
+	]);
+}
+/** @returns stable hash of the canonical cwd and optional scope key. */
+function viewKeyOf(input) {
+	return digest$1([resolve(input.cwd), input.scopeKey ?? null]);
+}
+/** @returns hash of the three fields used by discovery/retrieval. */
+function threeFieldHashOf(input) {
+	return digest$1([
+		input.name,
+		input.description,
+		input.whenToUse ?? null
+	]);
+}
+/** @returns normalized row for one skill summary. */
+function skillIndexRowOf(summary, managed, protectedSkill = false, pinned = false) {
+	return {
+		skillKey: skillKeyOf(summary),
+		name: summary.name,
+		description: summary.description,
+		...summary.whenToUse === void 0 ? {} : { whenToUse: summary.whenToUse },
+		provider: summary.provider,
+		source: summary.source,
+		managed,
+		modelInvocable: summary.invocation.modelInvocable,
+		protected: protectedSkill,
+		pinned,
+		threeFieldHash: threeFieldHashOf(summary)
+	};
+}
+/** @returns digest of the sorted rows plus completeness. */
+function catalogRevisionOf(rows, complete) {
+	return digest$1([complete, rows.map((row) => [
+		row.skillKey,
+		row.name,
+		row.description,
+		row.whenToUse ?? null,
+		row.provider,
+		row.source,
+		row.managed,
+		row.modelInvocable,
+		row.protected,
+		row.pinned,
+		row.threeFieldHash
+	])]);
+}
+/** @returns digest of a concrete per-view snapshot. */
+function viewCatalogDigestOf(viewKey, rows, complete) {
+	return digest$1([viewKey, catalogRevisionOf(rows, complete)]);
+}
+/** @returns digest of effective policy plus its revisions. */
+function policyDigestOf(input) {
+	return digest$1([
+		input.globalPolicyRevision,
+		input.workspaceOverlayRevision ?? null,
+		input.scopeOverlayRevision ?? null,
+		input.effectivePolicy
+	]);
+}
+/** @returns view-cache identity for one projection. */
+function projectionDigestOf(input) {
+	return digest$1([
+		input.viewKey,
+		input.mapVersion,
+		input.policyDigest,
+		input.viewCatalogDigest,
+		input.adapterVersion,
+		input.projectionSchemaVersion,
+		input.discoveryMode
+	]);
+}
+/** @returns view-cache identity for one search index. */
+function searchIndexKeyOf(input) {
+	return digest$1([
+		input.viewKey,
+		input.viewCatalogDigest,
+		input.policyDigest,
+		input.tokenizerVersion,
+		input.indexSchemaVersion,
+		input.discoveryMode
+	]);
+}
+//#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$1(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$1(card.id),
+			" ",
+			escapeData$1(card.title),
+			": ",
+			escapeData$1(card.purpose),
+			" triggers=",
+			card.triggers.map(escapeData$1).join(","),
+			" | managed=",
+			String(card.managedModelInvocableCount),
+			" external=",
+			String(card.externalCatalogCount),
+			" pending=",
+			String(card.pendingCount),
+			" state=",
+			card.state,
+			" descriptionStatus=",
+			card.descriptionStatus,
+			" asOf=",
+			escapeData$1(card.asOf),
+			" mapVersion=",
+			escapeData$1(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/adapter.js
+/** @returns true for the platform catalog message. */
+function isCatalogMessage(message) {
+	return message.source.kind === "skill-catalog";
+}
+function escapeData(value) {
+	return sanitizeUntrustedText(value, 2e3).text;
+}
+function renderCatalog(entries) {
+	if (entries.length === 0) return [];
+	return [
+		"<system-reminder>",
+		"A skill is a reusable set of task-specific instructions. The following skills are available in this session:",
+		"<available_skills>",
+		...entries.map((entry) => "- " + escapeData(entry.name) + ": " + escapeData(entry.description)),
+		"</available_skills>",
+		"Call the skill tool with the exact name before acting.",
+		"</system-reminder>"
+	];
+}
+/** Build the plugin-owned replacement message from a complete projection. */
+function projectionPresent(agent, digest) {
+	try {
+		const visible = new Set(agent.session.surface.nodes);
+		for (let index = agent.session.seq - 1; index >= 0; index -= 1) {
+			const event = agent.session.eventAt(SessionSeq(index));
+			if (event === void 0) return false;
+			if (event.type !== "user/message") continue;
+			const data = event.data;
+			if (data?.source?.kind !== "evolution-skill-projection" || data.source.digest !== digest) continue;
+			if (visible.has(event.seq)) return true;
+		}
+	} catch {
+		return false;
+	}
+	return false;
+}
+function renderProjection(result) {
+	const text = [...renderCatalog(result.catalogEntries), ...result.context === "" ? [] : [result.context]].join("\n");
+	if (text === "") return void 0;
+	return createUserMessage({
+		content: [{
+			type: "text",
+			text
+		}],
+		source: {
+			kind: "evolution-skill-projection",
+			entries: result.catalogEntries,
+			hiddenNames: result.hiddenNames,
+			digest: result.digest
+		}
+	});
+}
+/**
+* Atomically replace one platform catalog message with the plugin projection.
+* @param decision - the waterfall decision; only enter decisions are changed.
+* @param result - a complete projection; incomplete results are ignored.
+* @returns a new decision, or the original when no safe replacement exists.
+*/
+function applyCatalogProjection(decision, result) {
+	if (decision.kind !== "enter" || !result.complete) return decision;
+	const index = decision.messages.findIndex(isCatalogMessage);
+	if (index < 0) return decision;
+	const replacement = renderProjection(result);
+	const messages = [...decision.messages];
+	if (replacement === void 0) messages.splice(index, 1);
+	else messages[index] = replacement;
+	return {
+		...decision,
+		messages
+	};
+}
+/**
+* Install the thin pre-step adapter. The listener is outer; it always calls
+* next, only touches the platform catalog message, and fails open.
+* @param ctx - plugin context.
+* @param provider - projection provider backed by SkillIndex/DomainMap.
+* @returns disposer from ctx.on.
+*/
+function installCatalogProjection(ctx, provider, digestStore) {
+	const projectedDigest = /* @__PURE__ */ new Map();
+	return ctx.on("agent/pre-step", async ({ agent }, next) => {
+		const decision = await next();
+		if (decision.kind !== "enter") return decision;
+		const catalog = decision.messages.find(isCatalogMessage);
+		if (catalog === void 0) return decision;
+		try {
+			if (provider.shouldProject !== void 0 && !await provider.shouldProject(agent)) return decision;
+			const result = await provider.project({
+				agent,
+				catalogEntries: catalog.source.entries
+			});
+			if (!result.complete) return decision;
+			const agentKey = String(agent.id);
+			if ((projectedDigest.get(agentKey) ?? await digestStore?.get(agentKey)) === result.digest && projectionPresent(agent, result.digest)) return {
+				...decision,
+				messages: decision.messages.filter((message) => !isCatalogMessage(message))
+			};
+			const nextDecision = applyCatalogProjection(decision, result);
+			if (nextDecision !== decision) {
+				projectedDigest.set(agentKey, result.digest);
+				await digestStore?.set(agentKey, result.digest);
+			}
+			return nextDecision;
+		} catch {
+			return decision;
+		}
+	}, { prepend: true });
+}
+//#endregion
+//#region lib/types/features.js
+const V0_DISCOVERY_FEATURES = Object.freeze({
+	projectionEnabled: false,
+	searchEnabled: false,
+	createClassificationEnabled: false,
+	discoveryMode: "off"
+});
+function canClassifyAtCreate(config, hasCreateDomainCards) {
+	return config.createClassificationEnabled && hasCreateDomainCards;
+}
+//#endregion
+//#region lib/types/stages.js
+/** Ordered implementation stages from PLAN-DISC-001. */
+const DISCOVERY_STAGES = [
+	"G0-projection",
+	"G1-domain",
+	"G2-projection",
+	"G3-search",
+	"G4-assignment",
+	"G5-maintenance",
+	"G6-ui",
+	"G7-migration",
+	"G8-release"
+];
+function stageIndex(stage) {
+	return DISCOVERY_STAGES.indexOf(stage);
+}
+function mayAdvance(current, next) {
+	return stageIndex(next) === stageIndex(current) + 1;
+}
+//#endregion
+//#region lib/types/search.js
+/** Tokenizer version; changing the algorithm requires rebuilding indexes. */
+const SKILL_SEARCH_TOKENIZER_VERSION = "cjk-bigram-v1";
+/** Fields indexed by skill search; no body/path. */
+const SKILL_SEARCH_FIELDS = [
+	"name",
+	"description",
+	"whenToUse"
+];
+/** Index schema version; bump when indexed fields/options change. */
+const SKILL_SEARCH_INDEX_SCHEMA_VERSION = "skill-search-v1";
+const CJK = String.raw`[[\p{scx=Han}\p{scx=Hira}\p{scx=Kana}\p{scx=Hang}]&&[\p{L}\p{M}\p{N}]]`;
+const RUN = new RegExp(String.raw`${CJK}+|[[\p{L}\p{M}\p{N}]--${CJK}]+`, "gv");
+const CJK_START = new RegExp(String.raw`^${CJK}`, "v");
+/**
+* Split NFKC text into CJK overlapping bigrams plus tail, and ASCII/other runs.
+* Parity source: plugin-market/src/search.ts searchTerms.
+* @param text - indexed or queried text.
+* @returns terms in text order; callers lowercase.
+*/
+function searchTerms(text) {
+	return [...text.normalize("NFKC").matchAll(RUN)].flatMap(([run]) => {
+		if (!CJK_START.test(run)) return [run];
+		const chars = Array.from(run);
+		return [...chars.slice(1).map((char, position) => chars[position] + char), chars.at(-1)];
+	});
+}
+function clampLimit(limit) {
+	if (limit === void 0) return 3;
+	return Math.min(20, Math.max(1, Math.trunc(limit)));
+}
+function build(rows) {
+	const engine = new MiniSearch({
+		fields: [...SKILL_SEARCH_FIELDS],
+		storeFields: [...SKILL_SEARCH_FIELDS],
+		tokenize: searchTerms,
+		processTerm: (term) => term.toLowerCase(),
+		searchOptions: {
+			boost: {
+				name: 3,
+				whenToUse: 2
+			},
+			prefix: true,
+			combineWith: "AND",
+			fuzzy: (term) => term.length >= 4 && !CJK_START.test(term) ? .2 : false,
+			maxFuzzy: 2
+		}
+	});
+	const seen = /* @__PURE__ */ new Set();
+	const documents = [];
+	for (const row of rows) {
+		if (!row.modelInvocable || row.protected || row.pinned || seen.has(row.skillKey)) continue;
+		seen.add(row.skillKey);
+		documents.push({
+			id: row.skillKey,
+			name: row.name,
+			description: row.description,
+			whenToUse: row.whenToUse ?? ""
+		});
+	}
+	engine.addAll(documents);
+	return engine;
+}
+/** Per-view MiniSearch index; no global engine and no projection-only filtering. */
+var SkillSearchIndex = class SkillSearchIndex {
+	engine;
+	staleState = false;
+	viewKey;
+	constructor(viewKey, engine) {
+		this.viewKey = viewKey;
+		this.engine = engine;
+	}
+	/** @returns an index over every modelInvocable row in this view. */
+	static fromRows(viewKey, rows) {
+		return new SkillSearchIndex(viewKey, build(rows));
+	}
+	/** Mark the current index stale before a rebuild finishes. */
+	markStale() {
+		this.staleState = true;
+	}
+	/** Rebuild from this view's full rows; a failed rebuild keeps the old engine stale. */
+	async rebuild(rows) {
+		this.staleState = true;
+		try {
+			this.engine = build(rows);
+			this.staleState = false;
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/** @returns hits, truncation, and whether the index is stale. */
+	async search(query, options) {
+		const limit = clampLimit(query.limit);
+		const terms = searchTerms(query.query);
+		if (terms.length === 0) return {
+			results: [],
+			truncated: false,
+			stale: this.staleState
+		};
+		let fallback = false;
+		let hits = this.engine.search(query.query, { combineWith: "AND" });
+		if (hits.length === 0 && terms.length > 1) {
+			const relaxed = this.engine.search(query.query, { combineWith: "OR" });
+			fallback = relaxed.length > 0;
+			hits = relaxed;
+		}
+		const allowed = options?.allowedSkillKeys;
+		const filtered = allowed === void 0 ? hits : hits.filter((hit) => allowed.has(String(hit.id)));
+		return {
+			results: filtered.slice(0, limit).map((hit) => {
+				const fields = new Set(Object.values(hit.match).flat());
+				return {
+					name: String(hit.name),
+					description: String(hit.description),
+					...hit.whenToUse === void 0 || hit.whenToUse === "" ? {} : { whenToUse: String(hit.whenToUse) },
+					matchedBy: fields.has("name") ? "name" : fields.has("whenToUse") ? "whenToUse" : "description"
+				};
+			}),
+			truncated: filtered.length > limit,
+			...fallback ? { fallback: true } : {},
+			stale: this.staleState
+		};
+	}
+};
+/** Per-view cache keyed by searchIndexKey; never shares one engine across views. */
+var SkillSearchCache = class {
+	entries = /* @__PURE__ */ new Map();
+	/**
+	* Get or build one view index. A failed rebuild retains the previous engine
+	* and marks it stale; no previous engine means undefined.
+	* @param key - identity inputs for searchIndexKey.
+	* @param rows - current full rows for the view.
+	* @returns index plus stale state, or undefined when no index is available.
+	*/
+	async get(key, rows) {
+		const cacheKey = searchIndexKeyOf({
+			viewKey: key.viewKey,
+			viewCatalogDigest: key.viewCatalogDigest,
+			policyDigest: key.policyDigest,
+			tokenizerVersion: SKILL_SEARCH_TOKENIZER_VERSION,
+			indexSchemaVersion: SKILL_SEARCH_INDEX_SCHEMA_VERSION,
+			discoveryMode: key.discoveryMode
+		});
+		const existing = this.entries.get(cacheKey);
+		if (existing !== void 0) return {
+			index: existing.index,
+			stale: false
+		};
+		try {
+			const index = SkillSearchIndex.fromRows(key.viewKey, rows);
+			this.entries.set(cacheKey, {
+				key: cacheKey,
+				viewKey: key.viewKey,
+				index
+			});
+			return {
+				index,
+				stale: false
+			};
+		} catch {
+			const old = [...this.entries.values()].find((entry) => entry.viewKey === key.viewKey);
+			if (old === void 0) return void 0;
+			old.index.markStale();
+			return {
+				index: old.index,
+				stale: true
+			};
+		}
+	}
+	/** Drop every index for one view. */
+	invalidate(viewKey) {
+		for (const [cacheKey, entry] of this.entries) if (entry.viewKey === viewKey) this.entries.delete(cacheKey);
+	}
+	/** Drop every cached view index. */
+	clear() {
+		this.entries.clear();
+	}
+};
+//#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 isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+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/domain-view.js
+/**
+* Count visible skills by active domain membership.
+* @param snapshot - global domain facts.
+* @param visibleSkillKeys - skill keys visible in this view.
+* @returns per-domain member counts plus the unclassified virtual count.
+*/
+function domainViewCounts(snapshot, visibleSkillKeys) {
+	const byDomain = /* @__PURE__ */ new Map();
+	const classified = /* @__PURE__ */ new Set();
+	for (const edge of snapshot.edges) {
+		if (edge.status !== "active" || !visibleSkillKeys.has(edge.skillKey)) continue;
+		const set = byDomain.get(edge.domainId) ?? /* @__PURE__ */ new Set();
+		set.add(edge.skillKey);
+		byDomain.set(edge.domainId, set);
+		if (edge.role === "primary") classified.add(edge.skillKey);
+	}
+	const counts = /* @__PURE__ */ new Map();
+	for (const [domainId, members] of byDomain) counts.set(domainId, members.size);
+	return {
+		byDomain: counts,
+		unclassified: [...visibleSkillKeys].filter((key) => !classified.has(key)).length
+	};
+}
+//#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$1 = 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$1.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-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) {
+		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");
+		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-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
+//#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/domain-metrics.js
+/**
+* @param snapshot - domain facts.
+* @param visibleSkillKeys - skills visible in this view.
+* @param labels - optional assignment labels.
+* @returns metrics; null means the denominator is zero/unmeasured.
+*/
+function computeDomainMetrics(snapshot, visibleSkillKeys, labels, counters) {
+	const visible = visibleSkillKeys.size;
+	const primary = /* @__PURE__ */ new Set();
+	const domainsWithActiveMembers = /* @__PURE__ */ new Set();
+	let activeEdges = 0;
+	let pendingEdges = 0;
+	const memberships = /* @__PURE__ */ new Map();
+	for (const edge of snapshot.edges) {
+		if (edge.status === "pending") pendingEdges += 1;
+		if (edge.status !== "active") continue;
+		activeEdges += 1;
+		if (!visibleSkillKeys.has(edge.skillKey)) continue;
+		if (edge.role === "primary") primary.add(edge.skillKey);
+		domainsWithActiveMembers.add(edge.domainId);
+		memberships.set(edge.skillKey, (memberships.get(edge.skillKey) ?? 0) + 1);
+	}
+	const crossDomain = [...memberships.values()].filter((count) => count > 1).length;
+	const emptyDomainCount = snapshot.domains.filter((domain) => !domainsWithActiveMembers.has(domain.id)).length;
+	const assignmentAccuracy = labels === void 0 ? null : accuracy(labels);
+	const staleDescriptions = snapshot.domains.filter((domain) => domain.descriptionStatus === "stale").length;
+	const overAssigned = counters?.maxDomainsPerSkill === void 0 ? null : [...memberships.values()].filter((count) => count > counters.maxDomainsPerSkill).length;
+	return {
+		measured: visible > 0,
+		visibleSkills: visible,
+		coverage: visible === 0 ? null : primary.size / visible,
+		unclassifiedRatio: visible === 0 ? null : (visible - primary.size) / visible,
+		emptyDomainCount,
+		crossDomainRatio: primary.size === 0 ? null : crossDomain / primary.size,
+		pendingRate: activeEdges + pendingEdges === 0 ? null : pendingEdges / (activeEdges + pendingEdges),
+		assignmentAccuracy,
+		newDomainPrecision: labels?.newDomainIds === void 0 || labels.predictedNewDomainIds === void 0 || labels.newDomainIds.length === 0 ? null : precision(labels.newDomainIds, labels.predictedNewDomainIds),
+		descriptionRewriteRate: counters?.descriptionEligible === void 0 || counters.descriptionEligible === 0 ? null : (counters.descriptionRewritten ?? 0) / counters.descriptionEligible,
+		staleDescriptionRatio: snapshot.domains.length === 0 ? null : staleDescriptions / snapshot.domains.length,
+		overAssignmentRate: overAssigned === null || visible === 0 ? null : overAssigned / visible,
+		refusalRate: counters?.assignmentAttempts === void 0 || counters.assignmentAttempts === 0 ? null : (counters.refusedAssignments ?? 0) / counters.assignmentAttempts
+	};
+}
+function accuracy(labels) {
+	const keys = Object.keys(labels.expectedBySkill).filter((key) => labels.predictedBySkill[key] !== void 0);
+	if (keys.length === 0) return null;
+	return keys.filter((key) => labels.expectedBySkill[key] === labels.predictedBySkill[key]).length / keys.length;
+}
+function precision(expected, predicted) {
+	if (predicted.length === 0) return null;
+	const wanted = new Set(expected);
+	return predicted.filter((id) => wanted.has(id)).length / predicted.length;
+}
+//#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 && !mapStale && input.searchAvailable !== false)) 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 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;
+			if (edge.status === "pending") {
+				pendingCount += 1;
+				continue;
+			}
+			if (edge.status !== "active") continue;
+			const row = rowByKey.get(edge.skillKey);
+			if (row === void 0) 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,
+			triggers: node.triggers.slice(0, 3),
+			managedModelInvocableCount,
+			externalCatalogCount,
+			managedCount: managedModelInvocableCount,
+			externalCount: externalCatalogCount,
+			pendingCount,
+			state: node.status === "provisional" ? "provisional" : "active",
+			asOf: new Date(node.updatedAt).toISOString(),
+			mapVersion: input.mapVersion,
+			mapStale
+		};
+	});
+	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 (input.policy.disabled.has(node.id)) continue;
+		wouldHide.add(edge.skillKey);
+	}
+	const activeManaged = mode === "on" ? 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,
+		shadowHiddenNames: [...wouldHide],
+		shadowRecoveredNames: [...wouldHide]
+	};
+}
+/** @returns true when shadow evidence is sufficient to promote to on. */
+function canPromoteShadow(input) {
+	return input.samples >= 20 && input.hiddenRecoverableRate >= 1 && input.silentMisses === 0;
+}
+//#endregion
+//#region lib/types/session-projection.js
+/** @returns true only for a new, fully-enabled session in the current epoch. */
+function shouldHideCatalog(meta, currentFeatureEpoch) {
+	return meta?.discoveryMode === "on" && meta.featureEpoch === currentFeatureEpoch;
+}
+/** @returns true when awareness may be emitted (shadow or on). */
+function shouldEmitAwareness(meta, currentFeatureEpoch) {
+	return (meta?.discoveryMode === "on" || meta?.discoveryMode === "shadow") && meta.featureEpoch === currentFeatureEpoch;
+}
+/** @returns false when the same digest was already emitted in this session. */
+function shouldEmitDigest(previousDigest, nextDigest) {
+	return previousDigest !== nextDigest;
+}
+/** @returns off at <=2200 tokens, on at >=3000, shadow between. */
+function projectionBudgetMode(catalogTokens, promoted = false) {
+	if (catalogTokens <= 2200) return "off";
+	if (promoted && catalogTokens >= 3e3) return "on";
+	return "shadow";
+}
+/** @returns true when a resumed session already enabled discovery. */
+function shouldInstallAwarenessOnResume(record, featureEpoch) {
+	return record !== void 0 && record.discoveryMode !== "off" && record.featureEpoch === featureEpoch;
+}
+//#endregion
+//#region lib/types/tool.js
+/** Static model-facing description; no dynamic domain list/tree. */
+const SKILL_SEARCH_DESCRIPTION = "Search skill summaries by name, description, or whenToUse when coverage is uncertain. Results are summaries, not bodies; a matching name can be loaded directly. Empty results are inconclusive; the full catalog remains available.";
+/** @returns response or a degraded hint; never silent empty on failure. */
+async function searchWithDegraded(provider, query, allowedSkillKeys, agent) {
+	if (provider === void 0) return {
+		results: [],
+		truncated: false,
+		degraded: true,
+		hint: "Skill search is unavailable. Use the full catalog or load an exact skill by name with skill(name)."
+	};
+	try {
+		return await provider.search(query, allowedSkillKeys === void 0 ? void 0 : { allowedSkillKeys }, agent);
+	} catch {
+		return {
+			results: [],
+			truncated: false,
+			degraded: true,
+			hint: "Skill search failed. Use the full catalog or load an exact skill by name with skill(name)."
+		};
+	}
+}
+function toToolResponse(response) {
+	return {
+		results: response.results.map((hit) => ({
+			name: hit.name,
+			description: hit.description,
+			...hit.whenToUse === void 0 ? {} : { whenToUse: hit.whenToUse },
+			...hit.matchedBy === void 0 ? {} : { matchedBy: hit.matchedBy }
+		})),
+		truncated: response.truncated,
+		...response.fallback === void 0 ? {} : { fallback: response.fallback },
+		...response.stale === void 0 ? {} : { stale: response.stale },
+		...response.degraded === void 0 ? {} : { degraded: response.degraded },
+		...response.hint === void 0 ? {} : { hint: response.hint }
+	};
+}
+/**
+* Register skill_search on ctx.tools. The description/schema are static; the
+* provider is the only dynamic dependency.
+* @param ctx - plugin context.
+* @param provider - search service or undefined when unavailable.
+* @returns tool disposer.
+*/
+function registerSkillSearchTool(ctx, provider) {
+	return ctx.tools.register(defineTool({
+		name: "skill_search",
+		description: SKILL_SEARCH_DESCRIPTION,
+		parameters: {
+			query: {
+				type: "string",
+				required: true,
+				description: "Search terms; CJK and ASCII are supported."
+			},
+			limit: {
+				type: "integer",
+				description: "Maximum results; defaults to 3, capped at 20."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					results: {
+						type: "array",
+						required: true,
+						items: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								name: {
+									type: "string",
+									required: true
+								},
+								description: {
+									type: "string",
+									required: true
+								},
+								whenToUse: { type: "string" },
+								matchedBy: { type: "string" }
+							}
+						}
+					},
+					truncated: {
+						type: "boolean",
+						required: true
+					},
+					fallback: { type: "boolean" },
+					stale: { type: "boolean" },
+					degraded: { type: "boolean" },
+					hint: { type: "string" }
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: value.degraded === true ? "Skill search is degraded: " + (value.hint ?? "use the full catalog or skill(name).") : "Found " + value.results.length + " skill result(s)" + (value.fallback === true ? " (OR fallback)." : ".") + (value.stale === true ? " (stale index)." : "") + "\n" + value.results.map((result) => "- " + result.name + ": " + result.description + (result.whenToUse === void 0 ? "" : " | when: " + result.whenToUse)).join("\n")
+			}]
+		},
+		async execute(args, exec) {
+			const allowed = await provider?.allowedSkillKeys?.(exec.agent);
+			return toToolResponse(await searchWithDegraded(provider, {
+				query: args.query,
+				limit: args.limit
+			}, allowed, exec.agent));
+		}
+	}));
+}
+/** @returns true only for a search implementation; used by composition wiring. */
+function isSkillSearch(value) {
+	return typeof value === "object" && value !== null && typeof value.search === "function";
+}
+//#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/maintenance.js
+/** Maintenance defaults from PLAN/MAP-009. */
+const MAINTENANCE_DEFAULTS = Object.freeze({
+	splitSkillThreshold: 25,
+	coarsenDomainCount: 12,
+	maxVisibleDepth: 3,
+	minChildren: 2,
+	minMembersPerChild: 3,
+	coarsenMinDomains: 3,
+	coarsenMaxDomains: 8
+});
+function directMembers(snapshot, domainId) {
+	return new Set(snapshot.edges.filter((edge) => edge.status === "active" && edge.domainId === domainId).map((edge) => edge.skillKey));
+}
+function descendants(snapshot, domainId) {
+	const result = /* @__PURE__ */ new Set();
+	const queue = [domainId];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		for (const node of snapshot.domains) {
+			if (!node.parentIds.includes(current) || result.has(node.id)) continue;
+			result.add(node.id);
+			queue.push(node.id);
+		}
+	}
+	return result;
+}
+/**
+* Audit domain definitions/structure without mutating the map.
+* @param snapshot - domain facts.
+* @param visibleSkillKeys - optional view skills for unclassified count.
+* @returns per-domain audit plus map-level counts.
+*/
+function auditDomainMap(snapshot, visibleSkillKeys) {
+	const ids = new Set(snapshot.domains.map((node) => node.id));
+	const primary = /* @__PURE__ */ new Set();
+	for (const edge of snapshot.edges) if (edge.status === "active" && edge.role === "primary") primary.add(edge.skillKey);
+	const domains = snapshot.domains.map((node) => {
+		const direct = directMembers(snapshot, node.id);
+		const indirect = /* @__PURE__ */ new Set();
+		for (const child of descendants(snapshot, node.id)) for (const member of directMembers(snapshot, child)) indirect.add(member);
+		const definitionComplete = node.purpose.trim().length > 0 && node.inScope.length > 0 && node.outOfScope.length > 0 && node.triggers.length > 0;
+		return {
+			domainId: node.id,
+			definitionComplete,
+			childCount: snapshot.domains.filter((child) => child.parentIds.includes(node.id)).length,
+			directSkillCount: direct.size,
+			indirectSkillCount: indirect.size,
+			empty: direct.size === 0,
+			orphan: node.parentIds.some((parent) => !ids.has(parent)),
+			lastUpdated: node.updatedAt
+		};
+	});
+	const unclassifiedCount = [...visibleSkillKeys ?? new Set(snapshot.edges.map((edge) => edge.skillKey))].filter((key) => !primary.has(key)).length;
+	return {
+		domains,
+		domainCount: domains.length,
+		unclassifiedCount
+	};
+}
+/**
+* Find split candidates; no child domains are created and no skills are reassigned.
+* @param snapshot - domain facts.
+* @param threshold - minimum direct members to consider.
+* @returns candidates with blockers.
+*/
+function splitCandidates(snapshot, threshold = MAINTENANCE_DEFAULTS.splitSkillThreshold) {
+	return snapshot.domains.flatMap((node) => {
+		const direct = directMembers(snapshot, node.id).size;
+		if (direct < threshold) return [];
+		const children = Math.min(MAINTENANCE_DEFAULTS.coarsenMaxDomains, Math.floor(direct / MAINTENANCE_DEFAULTS.minMembersPerChild));
+		const blockers = [];
+		if (children < MAINTENANCE_DEFAULTS.minChildren) blockers.push("fewer-than-2-children");
+		return [{
+			domainId: node.id,
+			directSkillCount: direct,
+			children,
+			blockers
+		}];
+	});
+}
+/**
+* Find coarsen groups; only structure candidates, never edge rewrites.
+* @param snapshot - domain facts.
+* @param maxDomains - above this count coarsening is considered.
+* @returns groups of 3–8 domains, at least 2 groups.
+*/
+function coarsenCandidates(snapshot, maxDomains = MAINTENANCE_DEFAULTS.coarsenDomainCount) {
+	if (snapshot.domains.length <= maxDomains) return [];
+	const ids = snapshot.domains.map((node) => node.id).sort();
+	const size = Math.min(MAINTENANCE_DEFAULTS.coarsenMaxDomains, Math.max(MAINTENANCE_DEFAULTS.coarsenMinDomains, Math.ceil(ids.length / 2)));
+	const groups = [];
+	for (let index = 0; index < ids.length; index += size) groups.push({ domainIds: ids.slice(index, index + size) });
+	return groups.length >= 2 ? groups : [];
+}
+//#endregion
+//#region lib/types/ui.js
+const POLICY_KEYS = new Set([
+	"mode",
+	"maxCards",
+	"tokenBudget",
+	"staleAfterHours",
+	"pinDomains",
+	"disableDomains"
+]);
+const MODES = new Set([
+	"auto",
+	"off",
+	"on"
+]);
+/** @returns true when the policy only edits supported fields. */
+function isDiscoveryUserPolicy(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const record = value;
+	if (Object.keys(record).some((key) => !POLICY_KEYS.has(key))) return false;
+	if (record.mode !== void 0 && (typeof record.mode !== "string" || !MODES.has(record.mode))) return false;
+	if (record.maxCards !== void 0 && (typeof record.maxCards !== "number" || !Number.isSafeInteger(record.maxCards) || record.maxCards < 1)) return false;
+	if (record.tokenBudget !== void 0 && (typeof record.tokenBudget !== "number" || !Number.isSafeInteger(record.tokenBudget) || record.tokenBudget < 1)) return false;
+	if (record.staleAfterHours !== void 0 && (typeof record.staleAfterHours !== "number" || record.staleAfterHours <= 0)) return false;
+	if (record.pinDomains !== void 0 && !Array.isArray(record.pinDomains)) return false;
+	if (record.disableDomains !== void 0 && !Array.isArray(record.disableDomains)) return false;
+	return true;
+}
+/** Static skill_manage description; no dynamic domain list/count/tree. */
+const SKILL_MANAGE_DESCRIPTION = "Manage skill content. create may include an optional domain proposal when create-side domain cards are available; no proposal means unclassified. Domain assignment never blocks skill creation and is stored as a sidecar.";
+/** @returns recomputable behavior metrics; null means no denominator. */
+function computeBehaviorMetrics(observations) {
+	const total = observations.length;
+	const shown = observations.filter((item) => item.awarenessShown).length;
+	const searched = observations.filter((item) => item.searched).length;
+	const successes = observations.filter((item) => item.taskSuccess).length;
+	return {
+		awarenessRecall: shown === 0 ? null : observations.filter((item) => item.awarenessShown && item.awarenessRecalled).length / shown,
+		silentMissRate: shown === 0 ? null : observations.filter((item) => item.silentMiss).length / shown,
+		overSearchRate: searched === 0 ? null : observations.filter((item) => item.searched && item.overSearch).length / searched,
+		underSearchRate: searched === 0 ? null : observations.filter((item) => item.searched && item.underSearch).length / searched,
+		wrongLoadRate: searched === 0 ? null : observations.filter((item) => item.searched && item.wrongLoad).length / searched,
+		taskSuccess: total === 0 ? null : successes / total,
+		tokens: observations.reduce((sum, item) => sum + item.tokens, 0),
+		fallbackRate: searched === 0 ? null : observations.filter((item) => item.searched && item.fallback).length / searched,
+		total
+	};
+}
+//#endregion
+//#region lib/types/session-store.js
+/** Plugin-side session metadata; platform SessionHeader has no discovery fields. */
+var DiscoverySessionStore = 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: {}
+			};
+		}
+	}
+	/** @returns persisted metadata for one session. */
+	async get(sessionId) {
+		const entry = (await this.read()).sessions[sessionId];
+		return entry === void 0 ? void 0 : {
+			sessionId,
+			...entry
+		};
+	}
+	/** Persist one session's mode/epoch; later writes win. */
+	async put(record) {
+		const current = await this.read();
+		const previous = current.sessions[record.sessionId];
+		const projectionDigest = record.projectionDigest ?? previous?.projectionDigest;
+		const sessions = {
+			...current.sessions,
+			[record.sessionId]: {
+				discoveryMode: record.discoveryMode,
+				featureEpoch: record.featureEpoch,
+				...projectionDigest === void 0 ? {} : { projectionDigest }
+			}
+		};
+		await this.io.writeText(this.path, JSON.stringify({
+			schemaVersion: 1,
+			sessions
+		}));
+	}
+};
+/** @returns true only for a persisted enabled session in the current feature epoch. */
+async function shouldProjectPersistedSession(store, sessionId, currentFeatureEpoch) {
+	return shouldHideCatalog(await store.get(sessionId), currentFeatureEpoch);
+}
+//#endregion
+//#region lib/types/runtime.js
+/** G2 adapter provider wired from ports; no global platform dependency. */
+var DiscoveryRuntime = class {
+	ports;
+	constructor(ports) {
+		this.ports = ports;
+	}
+	/** @returns true only when persisted session metadata allows projection. */
+	async shouldProject(agent) {
+		return shouldEmitAwareness(await this.ports.sessionStore.get(agent.session.id), this.ports.featureEpoch);
+	}
+	/** @returns a complete projection for this agent's catalog entries. */
+	async project(input) {
+		const view = await new SkillIndex(this.ports.skillIndexSource).read({
+			cwd: input.agent.session.header.cwd ?? "",
+			scopeKey: String(input.agent.id),
+			scope: input.agent
+		});
+		const snapshot = await this.ports.map.read();
+		const estimatedTokens = Math.ceil(input.catalogEntries.reduce((sum, entry) => sum + entry.name.length + entry.description.length, 0) / 4);
+		const promoted = typeof this.ports.promoted === "function" ? this.ports.promoted() : this.ports.promoted === true;
+		const autoMode = this.ports.autoMode === true ? projectionBudgetMode(estimatedTokens, promoted) : this.ports.mode;
+		const result = buildDomainProjection({
+			entries: input.catalogEntries,
+			rows: view.rows,
+			complete: view.complete,
+			snapshot,
+			policy: this.ports.policy,
+			viewKey: view.viewKey,
+			scope: String(input.agent.id),
+			mapVersion: snapshot.mapVersion,
+			policyDigest: this.ports.policyDigest,
+			viewCatalogDigest: view.viewCatalogDigest,
+			adapterVersion: this.ports.adapterVersion,
+			projectionSchemaVersion: this.ports.projectionSchemaVersion,
+			discoveryMode: this.ports.autoMode === true ? autoMode ?? "shadow" : this.ports.discoveryMode,
+			maxCards: this.ports.maxCards,
+			tokenBudget: this.ports.tokenBudget,
+			staleAfterHours: this.ports.staleAfterHours,
+			maxVisibleDepth: this.ports.maxVisibleDepth,
+			now: Date.now(),
+			mode: autoMode,
+			mapStale: this.ports.mapStale,
+			searchAvailable: this.ports.searchAvailable
+		});
+		this.ports.onProjection?.(result);
+		return result;
+	}
+};
+//#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/search-judge.js
+/** Validate a judge packet without accepting partial query coverage. */
+function validateJudgeRecord(record, expectedQueryIds) {
+	const errors = [];
+	if (record.schemaVersion !== 1 || record.querySet !== "eval-010" || record.judgeKind !== "model" && record.judgeKind !== "human") errors.push("schema-invalid");
+	if (record.judgeId.trim().length === 0) errors.push("judge-id-missing");
+	const seen = /* @__PURE__ */ new Set();
+	for (const observation of record.observations) {
+		if (!expectedQueryIds.includes(observation.queryId)) errors.push("unknown-query:" + observation.queryId);
+		if (seen.has(observation.queryId)) errors.push("duplicate-query:" + observation.queryId);
+		seen.add(observation.queryId);
+	}
+	for (const id of expectedQueryIds) if (!seen.has(id)) errors.push("missing-query:" + id);
+	return errors;
+}
+/** @returns aggregate over model/human records; agreement only for shared queries. */
+function aggregateJudge(records, expectedQueryIds) {
+	const model = records.find((record) => record.judgeKind === "model");
+	const human = records.find((record) => record.judgeKind === "human");
+	const modelLabels = new Map(model?.observations.map((item) => [item.queryId, item.relevant]) ?? []);
+	const humanLabels = new Map(human?.observations.map((item) => [item.queryId, item.relevant]) ?? []);
+	const union = [...new Set([...modelLabels.keys(), ...humanLabels.keys()])];
+	const relevant = union.filter((id) => (modelLabels.get(id) ?? humanLabels.get(id)) === true).length;
+	const shared = [...modelLabels.keys()].filter((id) => humanLabels.has(id));
+	return {
+		queryCount: expectedQueryIds.length,
+		relevantRate: union.length === 0 ? null : relevant / union.length,
+		agreementRate: shared.length === 0 ? null : shared.filter((id) => modelLabels.get(id) === humanLabels.get(id)).length / shared.length,
+		hasModel: model !== void 0,
+		hasHuman: human !== void 0
+	};
+}
+//#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. */
+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/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/domain-bootstrap.js
+/**
+* Write an initial LLM domain proposal into the map. Code owns IDs and
+* validation; no embedding taxonomy and no skill body is read.
+* @param store - domain map owner.
+* @param proposal - validated 8–12 domain proposal.
+* @param skillKeys - evidence skill name -> stable skillKey.
+* @param expectedMapVersion - CAS precondition.
+* @returns committed snapshot.
+*/
+async function bootstrapDomainMap(store, proposal, skillKeys, expectedMapVersion) {
+	const checked = validateDomainGeneration({ skills: Object.keys(skillKeys).map((name) => ({
+		name,
+		description: name
+	})) }, proposal);
+	if (!checked.ok) throw new Error("invalid domain proposal: " + checked.errors.join("; "));
+	const now = Date.now();
+	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" },
+		quality: {}
+	}));
+	const primary = /* @__PURE__ */ new Set();
+	const edges = [];
+	for (const [domainIndex, domain] of checked.domains.entries()) for (const name of domain.evidenceSkillKeys) {
+		const skillKey = skillKeys[name];
+		if (skillKey === void 0) continue;
+		const role = primary.has(skillKey) ? "secondary" : "primary";
+		if (role === "primary") primary.add(skillKey);
+		edges.push({
+			skillKey,
+			domainId: checked.domains[domainIndex].id,
+			role,
+			confidence: 1,
+			source: "create",
+			skillHash: "bootstrap",
+			mapVersion: expectedMapVersion,
+			status: "active",
+			assignedAt: now
+		});
+	}
+	return store.commit(expectedMapVersion, {
+		mapVersion: String(Number(expectedMapVersion) + 1),
+		domains,
+		edges
+	});
+}
+//#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 the structured result.`;
+}
+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-service.js
+/**
+* Generate and persist the initial map only when the map has no domains.
+* @param store - map owner.
+* @param port - external LLM adapter.
+* @param skills - name/description/whenToUse facts.
+* @param skillKeys - evidence name -> stable key.
+* @param expectedMapVersion - CAS precondition.
+* @returns committed snapshot, or existing snapshot when already bootstrapped.
+*/
+async function initialDomainMap(store, port, skills, skillKeys, expectedMapVersion, signal, prompt = DOMAIN_GENERATION_PROMPT) {
+	const current = await store.read();
+	if (current.domains.length > 0) return current;
+	return bootstrapDomainMap(store, await port.generate({
+		skills,
+		prompt,
+		...signal === void 0 ? {} : { signal }
+	}), skillKeys, expectedMapVersion);
+}
+//#endregion
+//#region lib/types/shadow-evidence.js
+/** Durable shadow-run evidence; every complete shadow projection is one sample. */
+var ShadowEvidenceStore = class {
+	io;
+	path;
+	samples = 0;
+	recovered = 0;
+	hidden = 0;
+	silentMisses = 0;
+	loaded = false;
+	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 && Number.isSafeInteger(parsed.samples) && parsed.samples >= 0) {
+				this.samples = parsed.samples;
+				this.recovered = Number.isSafeInteger(parsed.recovered) && parsed.recovered >= 0 ? parsed.recovered : 0;
+				this.hidden = Number.isSafeInteger(parsed.hidden) && parsed.hidden >= 0 ? parsed.hidden : 0;
+				this.silentMisses = Number.isSafeInteger(parsed.silentMisses) && parsed.silentMisses >= 0 ? parsed.silentMisses : 0;
+			}
+		} catch {}
+	}
+	async record(result) {
+		if (result.shadowHiddenNames === void 0 || result.shadowHiddenNames.length === 0) return;
+		await this.load();
+		this.samples += 1;
+		this.hidden += result.shadowHiddenNames.length;
+		this.recovered += result.shadowRecoveredNames?.length ?? 0;
+		await this.io.writeText(this.path, JSON.stringify({
+			schemaVersion: 1,
+			samples: this.samples,
+			recovered: this.recovered,
+			hidden: this.hidden,
+			silentMisses: this.silentMisses
+		}));
+	}
+	evidence() {
+		return {
+			samples: this.samples,
+			hiddenRecoverableRate: this.hidden > 0 ? this.recovered / this.hidden : 0,
+			silentMisses: this.silentMisses
+		};
+	}
+	canPromote() {
+		return canPromoteShadow(this.evidence());
+	}
+};
+//#endregion
+//#region lib/types/plugin.js
+const name = "evolution-skill-discovery";
+const inject = [
+	"skills",
+	"evolutionIo",
+	"systemPrompt",
+	"tools"
+];
+var PlatformSkillIndexSource = class {
+	ctx;
+	library;
+	constructor(ctx, library) {
+		this.ctx = ctx;
+		this.library = library;
+	}
+	async snapshot(query) {
+		const snapshot = await this.ctx.skills.snapshot({
+			cwd: query.cwd,
+			...query.scope === void 0 ? {} : { scope: query.scope }
+		});
+		return {
+			skills: snapshot.skills,
+			complete: snapshot.complete
+		};
+	}
+	async managedSkillKeys() {
+		const summaries = await this.library.list();
+		return new Set(summaries.filter((summary) => summary.managed).map((summary) => skillKeyOf({
+			provider: "dsh-evolution",
+			source: "user-dsh",
+			name: summary.name
+		})));
+	}
+	async protectedSkillKeys() {
+		const summaries = await this.library.list();
+		return new Set(summaries.filter((summary) => summary.protectedBy !== null || summary.protectionUnknown).map((summary) => skillKeyOf({
+			provider: "dsh-evolution",
+			source: "user-dsh",
+			name: summary.name
+		})));
+	}
+	async pinnedSkillKeys() {
+		const summaries = await this.library.list();
+		return new Set(summaries.filter((summary) => summary.protectedBy === "pinned").map((summary) => skillKeyOf({
+			provider: "dsh-evolution",
+			source: "user-dsh",
+			name: summary.name
+		})));
+	}
+};
+/** Compose discovery services from platform ports; no catalog/provider replacement. */
+function apply(ctx, config) {
+	if (typeof config.featureEpoch !== "string" || config.featureEpoch.length === 0) throw new Error("evolution-skill-discovery: featureEpoch is required");
+	if (config.provisionalThreshold !== void 0 && (!Number.isSafeInteger(config.provisionalThreshold) || config.provisionalThreshold < 1)) throw new Error("evolution-skill-discovery: provisionalThreshold must be a positive integer");
+	const evolutionIo = ctx.evolutionIo;
+	const io = evolutionIoAdapter(() => evolutionIo.provider());
+	const source = new PlatformSkillIndexSource(ctx, newSkillLibrary({
+		config: {},
+		io,
+		ctx,
+		authority: authorityFrom({ origin: "foreground" })
+	}));
+	const dshHome = process.env.DSH_HOME ?? join(homedir(), ".dsh");
+	const map = new DomainMapFileStore(io, config.domainMapPath ?? join(dshHome, "evolution", "domain-map.json"));
+	if (config.domainGeneration !== void 0 && config.domainGenerationSkills !== void 0 && config.domainGenerationSkillKeys !== void 0) initialDomainMap(map, config.domainGeneration, config.domainGenerationSkills, config.domainGenerationSkillKeys, "0", void 0, buildDomainGenerationPrompt({
+		...config.domainMinDomains === void 0 ? {} : { minDomains: config.domainMinDomains },
+		...config.domainMaxDomains === void 0 ? {} : { maxDomains: config.domainMaxDomains }
+	})).catch(() => {});
+	if (config.bootstrapDomains !== void 0 && config.bootstrapSkillKeys !== void 0) bootstrapDomainMap(map, config.bootstrapDomains, config.bootstrapSkillKeys, "0").catch(() => {});
+	const sessions = new DiscoverySessionStore(io, config.sessionPath ?? join(dshHome, "evolution", "discovery-sessions.json"));
+	const policy = mergeDomainPolicy({
+		mode: config.mode === "shadow" || config.mode === void 0 || config.mode === "auto" ? "auto" : config.mode,
+		pinDomains: config.pinDomains,
+		disableDomains: config.disableDomains
+	});
+	const shadowStore = new ShadowEvidenceStore(io, config.shadowEvidencePath ?? join(dshHome, "evolution", "shadow-evidence.json"));
+	let promoted = config.shadowEvidence !== void 0 && canPromoteShadow(config.shadowEvidence);
+	shadowStore.load().then(() => {
+		if (shadowStore.canPromote()) promoted = true;
+	}).catch(() => {});
+	const policyDigest = policyDigestOf({
+		globalPolicyRevision: "config",
+		effectivePolicy: {
+			mode: policy.mode,
+			pinned: policy.pinned,
+			disabled: policy.disabled
+		}
+	});
+	const runtime = new DiscoveryRuntime({
+		skillIndexSource: source,
+		map,
+		policy,
+		sessionStore: sessions,
+		featureEpoch: config.featureEpoch,
+		mapVersion: "0",
+		policyDigest,
+		adapterVersion: "1",
+		projectionSchemaVersion: "1",
+		discoveryMode: config.mode === "auto" ? "shadow" : config.mode ?? "off",
+		maxCards: config.maxCards,
+		tokenBudget: config.tokenBudget ?? 1200,
+		staleAfterHours: config.staleAfterHours,
+		mode: config.mode === "auto" ? "shadow" : config.mode === "shadow" ? "shadow" : config.mode === "on" ? "on" : "off",
+		autoMode: config.mode === "auto",
+		promoted: () => promoted,
+		onProjection: (result) => {
+			shadowStore.record(result).then(() => {
+				if (shadowStore.canPromote()) promoted = true;
+			}).catch(() => {});
+		},
+		mapStale: config.mapStale ?? false,
+		searchAvailable: config.searchAvailable ?? true
+	});
+	ctx.on("agent/created", async ({ agent, source }) => {
+		try {
+			if (source === "startup") {
+				await sessions.put({
+					sessionId: String(agent.session.id),
+					discoveryMode: config.mode === "on" ? "on" : config.mode === "shadow" || config.mode === "auto" ? "shadow" : "off",
+					featureEpoch: config.featureEpoch
+				});
+				if (config.mode !== "off") installDiscoveryAwareness(agent.ctx);
+			} else if (shouldInstallAwarenessOnResume(await sessions.get(String(agent.session.id)), config.featureEpoch)) installDiscoveryAwareness(agent.ctx);
+		} catch {}
+	});
+	installCatalogProjection(ctx, runtime, {
+		async get(agentKey) {
+			return (await sessions.get(agentKey))?.projectionDigest;
+		},
+		async set(agentKey, digest) {
+			const record = await sessions.get(agentKey);
+			if (record !== void 0) await sessions.put({
+				...record,
+				projectionDigest: digest
+			});
+		}
+	});
+	const queue = new JsonAssignmentQueue(io, join(dshHome, "evolution", "assignment-queue.json"));
+	const assignment = new DomainAssignmentService(queue, map, {
+		createClassificationEnabled: config.createClassificationEnabled ?? false,
+		...config.provisionalThreshold === void 0 ? {} : { provisionalThreshold: config.provisionalThreshold },
+		now: Date.now
+	});
+	const worker = new AssignmentWorker(assignment, queue);
+	queue.load().then(() => worker.drain()).catch(() => {});
+	installAssignmentSidecar(ctx, assignment, { onSubmitted: () => {
+		worker.drain().catch(() => {});
+	} });
+	const commandRuntime = ctx.get("commands");
+	if (commandRuntime !== void 0) ctx.effect(() => commandRuntime.register({
+		name: "skill-domain",
+		description: "List provisional skill domains or confirm one by id.",
+		async handler({ rawInput }) {
+			const [action, domainId] = rawInput.trim().split(/\s+/);
+			if (action === "list" || action === void 0) {
+				const provisional = (await map.read()).domains.filter((node) => node.status === "provisional");
+				return {
+					kind: "success",
+					text: provisional.length === 0 ? "No provisional domains." : "Provisional domains:\n" + provisional.map((node) => "- " + node.id + ": " + node.name).join("\n")
+				};
+			}
+			if (action === "confirm" && domainId !== void 0) return await assignment.confirm(domainId) ? {
+				kind: "success",
+				text: "Confirmed domain " + domainId + "."
+			} : {
+				kind: "error",
+				text: "Unknown or non-provisional domain: " + domainId
+			};
+			return {
+				kind: "error",
+				text: "Usage: /skill-domain list | /skill-domain confirm <id>"
+			};
+		}
+	}));
+	const searchCache = new SkillSearchCache();
+	ctx.on("evolution/skill-mutated", () => {
+		searchCache.clear();
+	});
+	registerSkillSearchTool(ctx, {
+		async allowedSkillKeys(agent) {
+			const view = await new SkillIndex(source).read({
+				cwd: agent?.session.header.cwd ?? process.cwd(),
+				scopeKey: agent === void 0 ? "tool" : String(agent.id),
+				...agent === void 0 ? {} : { scope: agent }
+			});
+			const snapshot = await map.read();
+			const blocked = new Set(snapshot.edges.filter((edge) => edge.status === "active" && policy.disabled.has(edge.domainId)).map((edge) => edge.skillKey));
+			return new Set(view.rows.filter((row) => row.modelInvocable && !blocked.has(row.skillKey)).map((row) => row.skillKey));
+		},
+		async search(query, options, agent) {
+			const cwd = agent?.session.header.cwd ?? process.cwd();
+			const view = await new SkillIndex(source).read({
+				cwd,
+				scopeKey: agent === void 0 ? "tool" : String(agent.id),
+				...agent === void 0 ? {} : { scope: agent }
+			});
+			const cacheKey = {
+				viewKey: view.viewKey,
+				viewCatalogDigest: view.viewCatalogDigest,
+				policyDigest,
+				discoveryMode: config.mode ?? "auto"
+			};
+			const cached = await searchCache.get(cacheKey, view.rows);
+			if (cached === void 0) return {
+				results: [],
+				truncated: false,
+				degraded: true,
+				hint: "Skill search index is unavailable. Use skill(name) or the full catalog."
+			};
+			const result = await cached.index.search(query, options);
+			return result.stale || cached.stale ? {
+				...result,
+				stale: true
+			} : result;
+		}
+	});
+}
+//#endregion
+//#region lib/types/index.js
+function bySkillKey(left, right) {
+	return left.skillKey < right.skillKey ? -1 : left.skillKey > right.skillKey ? 1 : 0;
+}
+/** Read-only view model; it does not cache or own a provider. */
+var SkillIndex = class {
+	source;
+	constructor(source) {
+		this.source = source;
+	}
+	/**
+	* Read one view from the source.
+	* @param query - cwd/scope and cancellation for this observation.
+	* @returns normalized rows and completeness; incomplete data is not hidden.
+	*/
+	async read(query) {
+		const [snapshot, managed, protectedKeys, pinnedKeys] = await Promise.all([
+			this.source.snapshot(query),
+			this.source.managedSkillKeys(),
+			this.source.protectedSkillKeys?.() ?? Promise.resolve(/* @__PURE__ */ new Set()),
+			this.source.pinnedSkillKeys?.() ?? Promise.resolve(/* @__PURE__ */ new Set())
+		]);
+		const rows = snapshot.skills.map((summary) => skillIndexRowOf(summary, managed.has(skillKeyOf(summary)), protectedKeys.has(skillKeyOf(summary)), pinnedKeys.has(skillKeyOf(summary)))).sort(bySkillKey);
+		return {
+			viewKey: viewKeyOf(query),
+			catalogRevision: catalogRevisionOf(rows, snapshot.complete),
+			viewCatalogDigest: viewCatalogDigestOf(viewKeyOf(query), rows, snapshot.complete),
+			rows,
+			complete: snapshot.complete
+		};
+	}
+};
+//#endregion
+export { AssignmentWorker, DISCOVERY_AWARENESS, DISCOVERY_STAGES, DOMAIN_GENERATION_PROMPT, DOMAIN_GENERATION_PROMPT_HASH, DOMAIN_GENERATION_PROMPT_V1, DOMAIN_GENERATION_PROMPT_V2, DOMAIN_GENERATION_PROMPT_VERSION, DOMAIN_MAP_SCHEMA_VERSION, DiscoveryRuntime, DiscoverySessionStore, DomainAssignmentService, DomainMapCorruptError, DomainMapFileStore, DomainMapValidationError, DomainMapVersionConflict, DomainPolicyValidationError, JsonAssignmentQueue, MAINTENANCE_DEFAULTS, MemoryAssignmentQueue, SKILL_MANAGE_DESCRIPTION, SKILL_SEARCH_DESCRIPTION, SKILL_SEARCH_FIELDS, SKILL_SEARCH_INDEX_SCHEMA_VERSION, SKILL_SEARCH_TOKENIZER_VERSION, ShadowEvidenceStore, SkillIndex, SkillSearchCache, SkillSearchIndex, V0_DISCOVERY_FEATURES, aggregateJudge, apply, applyCatalogProjection, assignmentKey, auditDomainMap, bootstrapDomainMap, buildDomainGenerationPrompt, buildDomainProjection, canClassifyAtCreate, canPromoteShadow, catalogRevisionOf, coarsenCandidates, computeBehaviorMetrics, computeDomainMetrics, coveredByDomain, descriptionHashOf, descriptionIsServable, domainGenerationMode, domainViewCounts, evaluateDomainQuality, hiddenRecoverable, initialDomainMap, inject, installAssignmentSidecar, installCatalogProjection, installDiscoveryAwareness, isDiscoveryUserPolicy, isSkillSearch, mayAdvance, mergeDomainPolicy, mintDomainId, name, policyDigestOf, projectCatalog, projectionBudgetMode, projectionDigestOf, proposalDigest, registerSkillSearchTool, renderDomainDescription, sanitizeUntrustedText, searchIndexKeyOf, searchTerms, searchWithDegraded, shouldEmitAwareness, shouldEmitDigest, shouldHideCatalog, shouldInstallAwarenessOnResume, shouldProjectPersistedSession, shouldRegenerateDescription, skillIndexRowOf, skillKeyOf, splitCandidates, stageIndex, threeFieldHashOf, validateDomainGeneration, validateJudgeRecord, validateProposal, viewCatalogDigestOf, viewKeyOf };