@lmzhen/dsh-evolution-skill-discovery 0.31.1 → 0.32.1

package/lib/main-entry.js

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