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

package/lib/tool-CvUTwKvW.js

@@ -0,0 +1,446 @@
+import { resolve } from "node:path";
+import { createHash } from "node:crypto";
+import MiniSearch from "minisearch";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+//#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(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([resolve(input.cwd), input.scopeKey ?? null]);
+}
+/** @returns hash of the three fields used by discovery/retrieval. */
+function threeFieldHashOf(input) {
+	return digest([
+		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([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([viewKey, catalogRevisionOf(rows, complete)]);
+}
+/** @returns digest of effective policy plus its revisions. */
+function policyDigestOf(input) {
+	return digest([
+		input.globalPolicyRevision,
+		input.workspaceOverlayRevision ?? null,
+		input.scopeOverlayRevision ?? null,
+		input.effectivePolicy
+	]);
+}
+/** @returns view-cache identity for one projection. */
+function projectionDigestOf(input) {
+	return digest([
+		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([
+		input.viewKey,
+		input.viewCatalogDigest,
+		input.policyDigest,
+		input.tokenizerVersion,
+		input.indexSchemaVersion,
+		input.discoveryMode
+	]);
+}
+//#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/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))
+				};
+			}
+		}
+	}));
+}
+/** @returns true only for a search implementation; used by composition wiring. */
+function isSkillSearch(value) {
+	return typeof value === "object" && value !== null && typeof value.search === "function";
+}
+//#endregion
+export { skillKeyOf as _, SKILL_SEARCH_FIELDS as a, viewKeyOf as b, SkillSearchCache as c, SkillIndex as d, catalogRevisionOf as f, skillIndexRowOf as g, searchIndexKeyOf as h, searchWithDegraded as i, SkillSearchIndex as l, projectionDigestOf as m, isSkillSearch as n, SKILL_SEARCH_INDEX_SCHEMA_VERSION as o, policyDigestOf as p, registerSkillSearchTool as r, SKILL_SEARCH_TOKENIZER_VERSION as s, SKILL_SEARCH_DESCRIPTION as t, searchTerms as u, threeFieldHashOf as v, viewCatalogDigestOf as y };

package/lib/types/assignment-queue.d.ts

@@ -3,7 +3,7 @@ import type { AssignmentQueue, AssignmentQueueEntry, AssignmentSubmission } from
 /** Durable assignment queue; process-local cache over one JSON file. */
 export declare class JsonAssignmentQueue implements AssignmentQueue {
     private readonly entries;
-    private loaded;
+    private loadPromise;
     private readonly io;
     private readonly path;
     constructor(io: EvolutionIoLike, path: string);

package/lib/types/catalog-codec.d.ts

@@ -0,0 +1,35 @@
+import type { UserMessage } from '@deepseek-ai/dsh-llm';
+import type { CatalogEntry } from './projection.ts';
+interface CatalogSource {
+    readonly kind: 'skill-catalog';
+    readonly form: 'catalog';
+    readonly update?: true;
+    readonly entries: readonly CatalogEntry[];
+}
+/** Captured platform catalog; base text and source are kept verbatim. */
+export interface CatalogCapture {
+    readonly text: string;
+    readonly source: CatalogSource;
+    readonly entries: readonly CatalogEntry[];
+    readonly update: boolean;
+}
+/** @returns captured catalog when text has the known available_skills block. */
+export declare function captureCatalog(message: UserMessage): CatalogCapture | undefined;
+/**
+ * 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.
+ */
+export declare function renderCatalog(capture: CatalogCapture, entries: readonly CatalogEntry[]): UserMessage;
+/**
+ * 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.
+ */
+export declare function renderCatalogUpdate(sourceEntries: readonly CatalogEntry[], entries: readonly CatalogEntry[]): UserMessage;
+/** @returns the exact platform message captured before projection. */
+export declare function restoreCatalog(capture: CatalogCapture): UserMessage;
+export {};
+//# sourceMappingURL=catalog-codec.d.ts.map

package/lib/types/description-refresh.d.ts

@@ -0,0 +1,8 @@
+import type { DomainMapStore } from './domain-map.ts';
+/**
+ * Re-render stale domain descriptions from their definition fields.
+ * @param store - domain map store.
+ * @returns number of refreshed domains.
+ */
+export declare function refreshStaleDescriptions(store: DomainMapStore): Promise<number>;
+//# sourceMappingURL=description-refresh.d.ts.map

package/lib/types/domain-bootstrap.d.ts

@@ -1,14 +1,32 @@
 import type { DomainMapSnapshot, DomainMapStore } from './domain-map.ts';
-import { type DomainGenerationProposal } from './domain-generation.ts';
+import type { DomainGenerationProposal, GenerationSkillFact } from './domain-generation.ts';
 import type { SkillKey } from './identity.ts';
+/** Real fact used by the production initial-map writer. */
+export interface BootstrapSkillFact extends GenerationSkillFact {
+    readonly skillKey: SkillKey;
+    readonly threeFieldHash: string;
+}
+/** Provenance persisted with generated domains and edges. */
+export interface BootstrapProvenance {
+    readonly promptVersion: string;
+    readonly sourceDigest: string;
+    readonly model: string;
+    readonly runId: string;
+}
 /**
- * Write an initial LLM domain proposal into the map. Code owns IDs and
- * validation; no embedding taxonomy and no skill body is read.
- * @param store - domain map owner.
- * @param proposal - validated 8–12 domain proposal.
- * @param skillKeys - evidence skill name -> stable skillKey.
+ * 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.
  */
+export declare function bootstrapDomainMapWithFacts(store: DomainMapStore, proposal: DomainGenerationProposal, facts: readonly BootstrapSkillFact[], expectedMapVersion: string, provenance: BootstrapProvenance): Promise<DomainMapSnapshot>;
+/**
+ * Legacy fallback for callers that only have a name -> key mapping.
+ * Production must use bootstrapDomainMapWithFacts.
+ */
 export declare function bootstrapDomainMap(store: DomainMapStore, proposal: DomainGenerationProposal, skillKeys: Readonly<Record<string, SkillKey>>, expectedMapVersion: string): Promise<DomainMapSnapshot>;
 //# sourceMappingURL=domain-bootstrap.d.ts.map

package/lib/types/domain-generation-coordinator.d.ts

@@ -0,0 +1,33 @@
+import type { DomainMapSnapshot, DomainMapStore } from './domain-map.ts';
+import { type BootstrapSkillFact } from './domain-bootstrap.ts';
+import type { DomainGenerationPort } from './domain-generation-service.ts';
+/** Input for one initial map generation from a live skill view. */
+export interface GenerationRequest {
+    readonly mapScope: string;
+    readonly sourceDigest: string;
+    readonly expectedMapVersion: string;
+    readonly facts: readonly BootstrapSkillFact[];
+    readonly prompt: string;
+    readonly promptVersion: string;
+    readonly model: string;
+    readonly runId: string;
+    readonly signal?: AbortSignal | undefined;
+}
+/** Single-flight initial map generation; mapVersion CAS is the final arbiter. */
+export declare class DomainGenerationCoordinator {
+    private readonly store;
+    private readonly port;
+    private readonly inflight;
+    private epoch;
+    constructor(store: DomainMapStore, port: DomainGenerationPort);
+    /** @returns current map version; increment makes older requests stale. */
+    get currentEpoch(): number;
+    /**
+     * 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.
+     */
+    ensure(request: GenerationRequest): Promise<DomainMapSnapshot>;
+    private run;
+}
+//# sourceMappingURL=domain-generation-coordinator.d.ts.map

package/lib/types/domain-generation-llm.d.ts

@@ -0,0 +1,56 @@
+import { BlockAssembler } from '@deepseek-ai/dsh-llm';
+import type { ContextFormed, UserMessage } from '@deepseek-ai/dsh-llm';
+import { type DomainGenerationProposal, type GenerationSkillFact } from './domain-generation.ts';
+import { DOMAIN_GENERATION_PROMPT_VERSION } from './domain-generation-prompt.ts';
+import type { DomainGenerationPort } from './domain-generation-service.ts';
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        'evolution-skill-generation': {
+            readonly kind: 'evolution-skill-generation';
+            readonly form: 'notice';
+            readonly summary: string;
+        } & ContextFormed;
+    }
+}
+/** Typed failure from LLM transport/parse/validation. */
+export declare class DomainGenerationError extends Error {
+    readonly code: 'llm-unavailable' | 'timeout' | 'invalid-output' | 'invalid-proposal';
+    constructor(code: DomainGenerationError['code'], message: string);
+}
+type LlmChunk = Parameters<BlockAssembler['push']>[0];
+/** Minimal platform LLM service used by the generation port. */
+export interface LlmStreamService {
+    stream(options: {
+        readonly provider: string;
+        readonly model: string;
+        readonly messages: readonly UserMessage[];
+        readonly maxTokens: number;
+        readonly signal?: AbortSignal | undefined;
+    }): AsyncIterable<LlmChunk>;
+}
+/** @returns parsed proposal with the caller's skill set; throws on malformed/empty output. */
+export declare function parseDomainGenerationProposal(text: string, skills: readonly GenerationSkillFact[]): DomainGenerationProposal;
+/** Production LLM adapter; validates before returning, never writes the map. */
+export declare class LlmDomainGenerationPort implements DomainGenerationPort {
+    private readonly llm;
+    private readonly options;
+    constructor(llm: LlmStreamService, options: {
+        readonly provider: string;
+        readonly model: string;
+        readonly maxTokens?: number | undefined;
+        readonly timeoutMs?: number | undefined;
+        readonly attempts?: number | undefined;
+    });
+    /**
+     * Generate one validated domain proposal.
+     * @param input - live facts, prompt, and cancellation.
+     * @returns validated proposal with 8–12 domains and known evidence.
+     */
+    generate(input: {
+        readonly skills: readonly GenerationSkillFact[];
+        readonly prompt: string;
+        readonly signal?: AbortSignal | undefined;
+    }): Promise<DomainGenerationProposal>;
+}
+export { DOMAIN_GENERATION_PROMPT_VERSION };
+//# sourceMappingURL=domain-generation-llm.d.ts.map

package/lib/types/domain-policy-store.d.ts

@@ -0,0 +1,24 @@
+import { type DomainPolicyLayer, type EffectiveDomainPolicy } from './domain-policy.ts';
+/** Inputs for one policy resolution. */
+export interface PolicyStoreInput {
+    readonly global: DomainPolicyLayer;
+    readonly workspace?: DomainPolicyLayer | undefined;
+    readonly scope?: DomainPolicyLayer | undefined;
+    readonly knownDomainIds?: ReadonlySet<string> | undefined;
+}
+/** Resolves global/workspace/scope policy without touching DomainMap or mapVersion. */
+export declare class DomainPolicyStore {
+    private readonly input;
+    constructor(input: PolicyStoreInput);
+    /**
+     * @param knownDomainIds - optional live id set; overrides the construction-time set.
+     * @returns effective policy with unknown ids reported as degraded.
+     */
+    resolve(knownDomainIds?: ReadonlySet<string> | undefined): EffectiveDomainPolicy;
+    /**
+     * @param knownDomainIds - optional live id set used for the effective policy.
+     * @returns stable digest of effective policy and all layer revisions.
+     */
+    digest(knownDomainIds?: ReadonlySet<string> | undefined): string;
+}
+//# sourceMappingURL=domain-policy-store.d.ts.map

package/lib/types/domain-projection.d.ts

@@ -24,6 +24,7 @@ export interface DomainProjectionInput {
     readonly tokenBudget?: number | undefined;
     readonly now?: number | undefined;
     readonly staleAfterHours?: number | undefined;
+    readonly descriptionStaleAfterHours?: number | undefined;
     readonly maxVisibleDepth?: number | undefined;
 }
 /**
@@ -34,10 +35,4 @@ export interface DomainProjectionInput {
  */
 export declare function hiddenRecoverable(hiddenNames: readonly string[], searchResultNames: ReadonlySet<string>): boolean;
 export declare function buildDomainProjection(input: DomainProjectionInput): ProjectionResult;
-/** @returns true when shadow evidence is sufficient to promote to on. */
-export declare function canPromoteShadow(input: {
-    readonly samples: number;
-    readonly hiddenRecoverableRate: number;
-    readonly silentMisses: number;
-}): boolean;
 //# sourceMappingURL=domain-projection.d.ts.map