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

package/lib/search-entry.js

@@ -1,88 +0,0 @@
-import { c as SkillSearchCache, d as SkillIndex, r as registerSkillSearchTool } from "./tool-CvUTwKvW.js";
-//#region lib/types/search-entry.js
-const name = "evolution-skill-discovery";
-const inject = [
-	"skills",
-	"workingDirectory",
-	"tools"
-];
-var PlatformSearchIndexSource = class {
-	ctx;
-	constructor(ctx) {
-		this.ctx = ctx;
-	}
-	async snapshot(query) {
-		const snapshot = await this.ctx.skills.snapshot({
-			cwd: query.cwd,
-			...query.scope === void 0 ? {} : { scope: query.scope }
-		});
-		return {
-			skills: snapshot.skills,
-			complete: snapshot.complete
-		};
-	}
-	async managedSkillKeys() {
-		return /* @__PURE__ */ new Set();
-	}
-	async protectedSkillKeys() {
-		return /* @__PURE__ */ new Set();
-	}
-	async pinnedSkillKeys() {
-		return /* @__PURE__ */ new Set();
-	}
-};
-function unavailable() {
-	return {
-		results: [],
-		truncated: false,
-		degraded: true,
-		hint: "Skill search is unavailable without a session working directory."
-	};
-}
-/**
-* Compose the search-only discovery surface.
-* @param ctx - plugin context with skills, workingDirectory, and tools.
-* @param config - search-only configuration.
-*/
-function apply(ctx, config) {
-	if (typeof config.featureEpoch !== "string" || config.featureEpoch.length === 0) throw new Error("evolution-skill-discovery: featureEpoch is required");
-	if (config.mode !== void 0 && config.mode !== "off") ctx.logger.warn("evolution-skill-discovery: mode=" + config.mode + " is temporarily search-only; domain/projection is disabled until its producer is installed");
-	if (config.searchEnabled === false) return;
-	const source = new PlatformSearchIndexSource(ctx);
-	const cache = new SkillSearchCache();
-	const index = new SkillIndex(source);
-	ctx.effect(() => registerSkillSearchTool(ctx, { async search(query, options, agent, signal) {
-		if (agent === void 0) return unavailable();
-		const workingDirectory = ctx.get("workingDirectory");
-		if (workingDirectory === void 0) return unavailable();
-		const cwd = await workingDirectory.ensure(agent, signal);
-		const view = await index.read({
-			cwd,
-			scopeKey: String(agent.id),
-			scope: agent,
-			signal
-		});
-		const cached = await cache.get({
-			viewKey: view.viewKey,
-			viewCatalogDigest: view.viewCatalogDigest,
-			policyDigest: "search-only",
-			discoveryMode: "off"
-		}, view.rows);
-		if (cached === void 0) return {
-			results: [],
-			truncated: false,
-			degraded: true,
-			hint: "Skill search index is unavailable. Use the full catalog or skill(name)."
-		};
-		const result = await cached.index.search(query, options);
-		return result.stale || cached.stale ? {
-			...result,
-			stale: true
-		} : result;
-	} }));
-	ctx.on("evolution/skill-mutated", () => {
-		cache.clear();
-	});
-}
-//#endregion
-export { apply, inject, name };

package/lib/tool-CvUTwKvW.js

@@ -1,446 +0,0 @@
-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/adapter.d.ts

@@ -1,48 +0,0 @@
-import type { Context } from '@deepseek-ai/cordis';
-import type { Agent, PreStepDecision } from '@deepseek-ai/dsh-agent';
-import type { ContextFormed } from '@deepseek-ai/dsh-llm';
-import type { CatalogEntry, ProjectionResult } from './projection.ts';
-declare module '@deepseek-ai/dsh-llm' {
-    interface MessageSourceMap {
-        'skill-catalog': {
-            readonly kind: 'skill-catalog';
-            readonly form: 'catalog';
-            readonly entries: readonly CatalogEntry[];
-        } & ContextFormed;
-        'evolution-skill-projection': {
-            readonly kind: 'evolution-skill-projection';
-            readonly entries: readonly CatalogEntry[];
-            readonly hiddenNames: readonly string[];
-            readonly digest: string;
-        } & ContextFormed;
-    }
-}
-/** Provider the plugin supplies from SkillIndex + DomainMap + policy. */
-export interface ProjectionDigestStore {
-    get(agentKey: string): Promise<string | undefined>;
-    set(agentKey: string, digest: string): Promise<void>;
-}
-export interface CatalogProjectionProvider {
-    /** Optional persisted-session gate; false keeps the full catalog. */
-    shouldProject?(agent: Agent): boolean | Promise<boolean>;
-    project(input: {
-        readonly agent: Agent;
-        readonly catalogEntries: readonly CatalogEntry[];
-    }): ProjectionResult | Promise<ProjectionResult>;
-}
-/**
- * Atomically replace one platform catalog message with the plugin projection.
- * @param decision - the waterfall decision; only enter decisions are changed.
- * @param result - a complete projection; incomplete results are ignored.
- * @returns a new decision, or the original when no safe replacement exists.
- */
-export declare function applyCatalogProjection(decision: PreStepDecision, result: ProjectionResult): PreStepDecision;
-/**
- * Install the thin pre-step adapter. The listener is outer; it always calls
- * next, only touches the platform catalog message, and fails open.
- * @param ctx - plugin context.
- * @param provider - projection provider backed by SkillIndex/DomainMap.
- * @returns disposer from ctx.on.
- */
-export declare function installCatalogProjection(ctx: Context, provider: CatalogProjectionProvider, digestStore?: ProjectionDigestStore): () => void;
-//# sourceMappingURL=adapter.d.ts.map

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

@@ -1,41 +0,0 @@
-import type { DomainMapSnapshot } from './domain-map.ts';
-import type { SkillKey } from './identity.ts';
-/** Optional labels for assignment accuracy; absent means unmeasured. */
-export interface DomainMetricLabels {
-    readonly expectedBySkill: Readonly<Record<SkillKey, string>>;
-    readonly predictedBySkill: Readonly<Record<SkillKey, string>>;
-    readonly newDomainIds?: readonly string[] | undefined;
-    readonly predictedNewDomainIds?: readonly string[] | undefined;
-}
-/** Recomputable domain/assignment metrics; no sentence locking. */
-export interface DomainMetricCounters {
-    readonly descriptionRewritten?: number | undefined;
-    readonly descriptionEligible?: number | undefined;
-    readonly refusedAssignments?: number | undefined;
-    readonly assignmentAttempts?: number | undefined;
-    readonly maxDomainsPerSkill?: number | undefined;
-}
-/** Recomputable domain/assignment metrics; no sentence locking. */
-export interface DomainMetrics {
-    readonly measured: boolean;
-    readonly visibleSkills: number;
-    readonly coverage: number | null;
-    readonly unclassifiedRatio: number | null;
-    readonly emptyDomainCount: number;
-    readonly crossDomainRatio: number | null;
-    readonly pendingRate: number | null;
-    readonly assignmentAccuracy: number | null;
-    readonly newDomainPrecision: number | null;
-    readonly descriptionRewriteRate: number | null;
-    readonly staleDescriptionRatio: number | null;
-    readonly overAssignmentRate: number | null;
-    readonly refusalRate: number | null;
-}
-/**
- * @param snapshot - domain facts.
- * @param visibleSkillKeys - skills visible in this view.
- * @param labels - optional assignment labels.
- * @returns metrics; null means the denominator is zero/unmeasured.
- */
-export declare function computeDomainMetrics(snapshot: DomainMapSnapshot, visibleSkillKeys: ReadonlySet<SkillKey>, labels?: DomainMetricLabels, counters?: DomainMetricCounters): DomainMetrics;
-//# sourceMappingURL=domain-metrics.d.ts.map

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

@@ -1,15 +0,0 @@
-import type { DomainMapSnapshot } from './domain-map.ts';
-import type { SkillKey } from './identity.ts';
-/** Per-view membership counts; unclassified is virtual, never a domain id. */
-export interface DomainViewCounts {
-    readonly byDomain: ReadonlyMap<string, number>;
-    readonly unclassified: number;
-}
-/**
- * Count visible skills by active domain membership.
- * @param snapshot - global domain facts.
- * @param visibleSkillKeys - skill keys visible in this view.
- * @returns per-domain member counts plus the unclassified virtual count.
- */
-export declare function domainViewCounts(snapshot: DomainMapSnapshot, visibleSkillKeys: ReadonlySet<SkillKey>): DomainViewCounts;
-//# sourceMappingURL=domain-view.d.ts.map

package/lib/types/features.d.ts

@@ -1,11 +0,0 @@
-/** Discovery feature gates; v0 defaults everything off. */
-export type DiscoveryMode = 'off' | 'shadow' | 'on';
-export interface DiscoveryFeatureConfig {
-    readonly projectionEnabled: boolean;
-    readonly searchEnabled: boolean;
-    readonly createClassificationEnabled: boolean;
-    readonly discoveryMode: DiscoveryMode;
-}
-export declare const V0_DISCOVERY_FEATURES: DiscoveryFeatureConfig;
-export declare function canClassifyAtCreate(config: DiscoveryFeatureConfig, hasCreateDomainCards: boolean): boolean;
-//# sourceMappingURL=features.d.ts.map