@lmzhen/dsh-evolution-skill-discovery 0.0.0 → 0.30.41

package/lib/types/identity.d.ts

@@ -0,0 +1,67 @@
+import type { SkillSummary } from '@deepseek-ai/dsh-skill';
+/** Stable identity for one winning skill: provider + source + name, JSON-encoded. */
+export type SkillKey = string;
+/** One view of the skill catalog: canonical cwd plus a stable scope key. */
+export interface ViewIdentityInput {
+    readonly cwd: string;
+    readonly scopeKey?: string | undefined;
+}
+/** One normalized skill row in the read model. */
+export interface SkillIndexRow {
+    readonly skillKey: SkillKey;
+    readonly name: string;
+    readonly description: string;
+    readonly whenToUse?: string | undefined;
+    readonly provider: string;
+    readonly source: string;
+    readonly managed: boolean;
+    readonly modelInvocable: boolean;
+    readonly protected: boolean;
+    readonly pinned: boolean;
+    readonly threeFieldHash: string;
+}
+/** Policy identity inputs; revisions are supplied by the owning policy store. */
+export interface PolicyDigestInput {
+    readonly globalPolicyRevision: string;
+    readonly workspaceOverlayRevision?: string | undefined;
+    readonly scopeOverlayRevision?: string | undefined;
+    readonly effectivePolicy: unknown;
+}
+/** Projection identity inputs. */
+export interface ProjectionDigestInput {
+    readonly viewKey: string;
+    readonly mapVersion: string;
+    readonly policyDigest: string;
+    readonly viewCatalogDigest: string;
+    readonly adapterVersion: string;
+    readonly projectionSchemaVersion: string;
+    readonly discoveryMode: string;
+}
+/** Search index identity inputs. */
+export interface SearchIndexKeyInput {
+    readonly viewKey: string;
+    readonly viewCatalogDigest: string;
+    readonly policyDigest: string;
+    readonly tokenizerVersion: string;
+    readonly indexSchemaVersion: string;
+    readonly discoveryMode: string;
+}
+/** @returns stable key for the winning provider/source/name tuple. */
+export declare function skillKeyOf(summary: Pick<SkillSummary, 'provider' | 'source' | 'name'>): SkillKey;
+/** @returns stable hash of the canonical cwd and optional scope key. */
+export declare function viewKeyOf(input: ViewIdentityInput): string;
+/** @returns hash of the three fields used by discovery/retrieval. */
+export declare function threeFieldHashOf(input: Pick<SkillSummary, 'name' | 'description' | 'whenToUse'>): string;
+/** @returns normalized row for one skill summary. */
+export declare function skillIndexRowOf(summary: SkillSummary, managed: boolean, protectedSkill?: boolean, pinned?: boolean): SkillIndexRow;
+/** @returns digest of the sorted rows plus completeness. */
+export declare function catalogRevisionOf(rows: readonly SkillIndexRow[], complete: boolean): string;
+/** @returns digest of a concrete per-view snapshot. */
+export declare function viewCatalogDigestOf(viewKey: string, rows: readonly SkillIndexRow[], complete: boolean): string;
+/** @returns digest of effective policy plus its revisions. */
+export declare function policyDigestOf(input: PolicyDigestInput): string;
+/** @returns view-cache identity for one projection. */
+export declare function projectionDigestOf(input: ProjectionDigestInput): string;
+/** @returns view-cache identity for one search index. */
+export declare function searchIndexKeyOf(input: SearchIndexKeyInput): string;
+//# sourceMappingURL=identity.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,74 @@
+import type { SkillSummary } from '@deepseek-ai/dsh-skill';
+import { type SkillIndexRow, type SkillKey } from './identity.ts';
+/** Query for one catalog view. */
+export interface SkillIndexQuery {
+    readonly cwd: string;
+    readonly scopeKey?: string | undefined;
+    readonly scope?: object | undefined;
+    readonly signal?: AbortSignal | undefined;
+}
+/** Raw observation supplied by the platform `ctx.skills` adapter. */
+export interface SkillIndexSourceSnapshot {
+    readonly skills: readonly SkillSummary[];
+    readonly complete: boolean;
+}
+/** Read-only source the plugin adapter implements with `ctx.skills` + SkillLibrary. */
+export interface SkillIndexSource {
+    snapshot(query: SkillIndexQuery): Promise<SkillIndexSourceSnapshot>;
+    managedSkillKeys(): Promise<ReadonlySet<SkillKey>>;
+    protectedSkillKeys?(): Promise<ReadonlySet<SkillKey>>;
+    pinnedSkillKeys?(): Promise<ReadonlySet<SkillKey>>;
+}
+/** One normalized per-view read model. */
+export interface SkillIndexSnapshot {
+    readonly viewKey: string;
+    readonly catalogRevision: string;
+    readonly viewCatalogDigest: string;
+    readonly rows: readonly SkillIndexRow[];
+    readonly complete: boolean;
+}
+/** Read-only view model; it does not cache or own a provider. */
+export declare class SkillIndex {
+    private readonly source;
+    constructor(source: SkillIndexSource);
+    /**
+     * 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.
+     */
+    read(query: SkillIndexQuery): Promise<SkillIndexSnapshot>;
+}
+export * from './identity.ts';
+export * from './domain-map.ts';
+export * from './projection.ts';
+export * from './adapter.ts';
+export * from './features.ts';
+export * from './stages.ts';
+export * from './search.ts';
+export * from './domain-map-store.ts';
+export * from './domain-view.ts';
+export * from './domain-policy.ts';
+export * from './domain-generation.ts';
+export * from './domain-description.ts';
+export * from './domain-quality.ts';
+export * from './domain-metrics.ts';
+export * from './domain-projection.ts';
+export * from './session-projection.ts';
+export * from './tool.ts';
+export * from './assignment.ts';
+export * from './maintenance.ts';
+export * from './ui.ts';
+export * from './security.ts';
+export * from './session-store.ts';
+export * from './runtime.ts';
+export * from './assignment-sidecar.ts';
+export * from './search-judge.ts';
+export * from './awareness.ts';
+export * from './plugin.ts';
+export * from './worker.ts';
+export * from './domain-bootstrap.ts';
+export * from './domain-generation-service.ts';
+export * from './assignment-queue.ts';
+export * from './domain-generation-prompt.ts';
+export * from './shadow-evidence.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/maintenance.d.ts

@@ -0,0 +1,62 @@
+import type { DomainMapSnapshot } from './domain-map.ts';
+import type { SkillKey } from './identity.ts';
+/** Maintenance defaults from PLAN/MAP-009. */
+export declare const MAINTENANCE_DEFAULTS: Readonly<{
+    splitSkillThreshold: 25;
+    coarsenDomainCount: 12;
+    maxVisibleDepth: 3;
+    minChildren: 2;
+    minMembersPerChild: 3;
+    coarsenMinDomains: 3;
+    coarsenMaxDomains: 8;
+}>;
+/** Read-only per-domain audit; no coverage claim is fabricated. */
+export interface DomainAudit {
+    readonly domainId: string;
+    readonly definitionComplete: boolean;
+    readonly childCount: number;
+    readonly directSkillCount: number;
+    readonly indirectSkillCount: number;
+    readonly empty: boolean;
+    readonly orphan: boolean;
+    readonly lastUpdated: number;
+}
+/** Map-level audit. */
+export interface DomainMapAudit {
+    readonly domains: readonly DomainAudit[];
+    readonly domainCount: number;
+    readonly unclassifiedCount: number;
+}
+/** One split candidate; no domains/edges are created. */
+export interface SplitCandidate {
+    readonly domainId: string;
+    readonly directSkillCount: number;
+    readonly children: number;
+    readonly blockers: readonly string[];
+}
+/** One coarsen group; no edges are changed. */
+export interface CoarsenGroup {
+    readonly domainIds: readonly string[];
+}
+/**
+ * Audit domain definitions/structure without mutating the map.
+ * @param snapshot - domain facts.
+ * @param visibleSkillKeys - optional view skills for unclassified count.
+ * @returns per-domain audit plus map-level counts.
+ */
+export declare function auditDomainMap(snapshot: DomainMapSnapshot, visibleSkillKeys?: ReadonlySet<SkillKey>): DomainMapAudit;
+/**
+ * Find split candidates; no child domains are created and no skills are reassigned.
+ * @param snapshot - domain facts.
+ * @param threshold - minimum direct members to consider.
+ * @returns candidates with blockers.
+ */
+export declare function splitCandidates(snapshot: DomainMapSnapshot, threshold?: 25): readonly SplitCandidate[];
+/**
+ * Find coarsen groups; only structure candidates, never edge rewrites.
+ * @param snapshot - domain facts.
+ * @param maxDomains - above this count coarsening is considered.
+ * @returns groups of 3–8 domains, at least 2 groups.
+ */
+export declare function coarsenCandidates(snapshot: DomainMapSnapshot, maxDomains?: 12): readonly CoarsenGroup[];
+//# sourceMappingURL=maintenance.d.ts.map

package/lib/types/plugin.d.ts

@@ -0,0 +1,37 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { DomainGenerationProposal, GenerationSkillFact } from './domain-generation.ts';
+import { type DomainGenerationPort } from './domain-generation-service.ts';
+/** Plugin config; paths are supplied by the composition, never guessed. */
+export interface Config {
+    readonly domainMapPath?: string | undefined;
+    readonly sessionPath?: string | undefined;
+    readonly featureEpoch: string;
+    readonly mode?: 'off' | 'shadow' | 'on' | 'auto';
+    readonly pinDomains?: readonly string[];
+    readonly disableDomains?: readonly string[];
+    readonly tokenBudget?: number;
+    readonly staleAfterHours?: number;
+    readonly mapStale?: boolean;
+    readonly searchAvailable?: boolean;
+    readonly shadowEvidencePath?: string | undefined;
+    readonly domainMinDomains?: number;
+    readonly domainMaxDomains?: number;
+    readonly provisionalThreshold?: number;
+    readonly shadowEvidence?: {
+        readonly samples: number;
+        readonly hiddenRecoverableRate: number;
+        readonly silentMisses: number;
+    };
+    readonly maxCards?: number;
+    readonly createClassificationEnabled?: boolean;
+    readonly bootstrapDomains?: DomainGenerationProposal;
+    readonly bootstrapSkillKeys?: Readonly<Record<string, string>>;
+    readonly domainGeneration?: DomainGenerationPort;
+    readonly domainGenerationSkills?: readonly GenerationSkillFact[];
+    readonly domainGenerationSkillKeys?: Readonly<Record<string, string>>;
+}
+export declare const name = "evolution-skill-discovery";
+export declare const inject: string[];
+/** Compose discovery services from platform ports; no catalog/provider replacement. */
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=plugin.d.ts.map

package/lib/types/projection.d.ts

@@ -0,0 +1,58 @@
+import { type SkillIndexRow, type SkillKey } from './identity.ts';
+/** One skill entry from the platform catalog message. */
+export interface CatalogEntry {
+    readonly name: string;
+    readonly description: string;
+}
+/** One model-visible L1 domain card. */
+export interface DomainCard {
+    readonly id: string;
+    readonly title: string;
+    readonly purpose: string;
+    readonly triggers: readonly string[];
+    readonly descriptionStatus: 'fresh' | 'stale' | 'failed';
+    readonly managedModelInvocableCount: number;
+    readonly externalCatalogCount: number;
+    readonly managedCount: number;
+    readonly externalCount: number;
+    readonly pendingCount: number;
+    readonly state: 'active' | 'provisional';
+    readonly asOf: string;
+    readonly mapVersion: string;
+    readonly mapStale: boolean;
+}
+/** Input of the pure catalog projection contract. */
+export interface ProjectionInput {
+    readonly entries: readonly CatalogEntry[];
+    readonly rows: readonly SkillIndexRow[];
+    readonly activeManagedSkillKeys: ReadonlySet<SkillKey>;
+    readonly cards: readonly DomainCard[];
+    readonly viewKey: string;
+    readonly scope: string;
+    readonly mapVersion: string;
+    readonly policyDigest: string;
+    readonly viewCatalogDigest: string;
+    readonly adapterVersion: string;
+    readonly projectionSchemaVersion: string;
+    readonly discoveryMode: string;
+    readonly complete: boolean;
+}
+/** Output of the pure catalog projection contract. */
+export interface ProjectionResult {
+    readonly catalogEntries: readonly CatalogEntry[];
+    readonly context: string;
+    readonly hiddenNames: readonly string[];
+    readonly shadowHiddenNames?: readonly string[];
+    readonly shadowRecoveredNames?: readonly string[];
+    readonly scope: string;
+    readonly digest: string;
+    readonly complete: boolean;
+}
+/**
+ * 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.
+ */
+export declare function projectCatalog(input: ProjectionInput): ProjectionResult;
+//# sourceMappingURL=projection.d.ts.map

package/lib/types/runtime.d.ts

@@ -0,0 +1,42 @@
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { DomainMapStore } from './domain-map.ts';
+import type { EffectiveDomainPolicy } from './domain-policy.ts';
+import { type SkillIndexSource } from './index.ts';
+import type { CatalogEntry, ProjectionResult } from './projection.ts';
+import type { DiscoverySessionStore } from './session-store.ts';
+/** Injectable composition ports; the platform adapter supplies concrete I/O. */
+export interface DiscoveryRuntimePorts {
+    readonly skillIndexSource: SkillIndexSource;
+    readonly map: DomainMapStore;
+    readonly policy: EffectiveDomainPolicy;
+    readonly sessionStore: DiscoverySessionStore;
+    readonly featureEpoch: string;
+    readonly mapVersion: string;
+    readonly policyDigest: string;
+    readonly adapterVersion: string;
+    readonly projectionSchemaVersion: string;
+    readonly discoveryMode: string;
+    readonly maxCards?: number | undefined;
+    readonly tokenBudget?: number | undefined;
+    readonly autoMode?: boolean | undefined;
+    readonly promoted?: boolean | (() => boolean) | undefined;
+    readonly onProjection?: ((result: ProjectionResult) => void) | undefined;
+    readonly staleAfterHours?: number | undefined;
+    readonly maxVisibleDepth?: number | undefined;
+    readonly mode?: 'off' | 'shadow' | 'on' | undefined;
+    readonly mapStale?: boolean | undefined;
+    readonly searchAvailable?: boolean | undefined;
+}
+/** G2 adapter provider wired from ports; no global platform dependency. */
+export declare class DiscoveryRuntime {
+    private readonly ports;
+    constructor(ports: DiscoveryRuntimePorts);
+    /** @returns true only when persisted session metadata allows projection. */
+    shouldProject(agent: Agent): Promise<boolean>;
+    /** @returns a complete projection for this agent's catalog entries. */
+    project(input: {
+        readonly agent: Agent;
+        readonly catalogEntries: readonly CatalogEntry[];
+    }): Promise<ProjectionResult>;
+}
+//# sourceMappingURL=runtime.d.ts.map

package/lib/types/search-judge.d.ts

@@ -0,0 +1,26 @@
+/** One independent judge's EVAL-010 labels. */
+export interface JudgeObservation {
+    readonly queryId: string;
+    readonly relevant: boolean;
+    readonly note?: string | undefined;
+}
+export interface JudgeRecord {
+    readonly schemaVersion: 1;
+    readonly querySet: 'eval-010';
+    readonly judgeKind: 'model' | 'human';
+    readonly judgeId: string;
+    readonly observations: readonly JudgeObservation[];
+}
+/** Validate a judge packet without accepting partial query coverage. */
+export declare function validateJudgeRecord(record: JudgeRecord, expectedQueryIds: readonly string[]): readonly string[];
+/** Aggregate two independent judges; no label is rewritten. */
+export interface JudgeAggregate {
+    readonly queryCount: number;
+    readonly relevantRate: number | null;
+    readonly agreementRate: number | null;
+    readonly hasModel: boolean;
+    readonly hasHuman: boolean;
+}
+/** @returns aggregate over model/human records; agreement only for shared queries. */
+export declare function aggregateJudge(records: readonly JudgeRecord[], expectedQueryIds: readonly string[]): JudgeAggregate;
+//# sourceMappingURL=search-judge.d.ts.map

package/lib/types/search.d.ts

@@ -0,0 +1,84 @@
+import { type SkillIndexRow } from './identity.ts';
+/** Tokenizer version; changing the algorithm requires rebuilding indexes. */
+export declare const SKILL_SEARCH_TOKENIZER_VERSION = "cjk-bigram-v1";
+/** Fields indexed by skill search; no body/path. */
+export declare const SKILL_SEARCH_FIELDS: readonly ["name", "description", "whenToUse"];
+/** Index schema version; bump when indexed fields/options change. */
+export declare const SKILL_SEARCH_INDEX_SCHEMA_VERSION = "skill-search-v1";
+/** One lexical search request. */
+export interface SkillSearchQuery {
+    readonly query: string;
+    readonly limit?: number | undefined;
+}
+/** One lexical search hit; the model loads the body separately. */
+export interface SkillSearchHit {
+    readonly name: string;
+    readonly description: string;
+    readonly whenToUse?: string | undefined;
+    readonly matchedBy?: string | undefined;
+}
+/** Independent search read service. */
+export interface SkillSearchResponse {
+    readonly results: readonly SkillSearchHit[];
+    readonly truncated: boolean;
+    readonly fallback?: boolean | undefined;
+    readonly stale?: boolean | undefined;
+    readonly degraded?: boolean | undefined;
+    readonly hint?: string | undefined;
+}
+export interface SkillSearch {
+    search(query: SkillSearchQuery, options?: {
+        readonly allowedSkillKeys?: ReadonlySet<string> | undefined;
+    }): Promise<SkillSearchResponse>;
+}
+/**
+ * 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.
+ */
+export declare function searchTerms(text: string): string[];
+/** Per-view MiniSearch index; no global engine and no projection-only filtering. */
+export declare class SkillSearchIndex implements SkillSearch {
+    private engine;
+    private staleState;
+    readonly viewKey: string;
+    private constructor();
+    /** @returns an index over every modelInvocable row in this view. */
+    static fromRows(viewKey: string, rows: readonly SkillIndexRow[]): SkillSearchIndex;
+    /** Mark the current index stale before a rebuild finishes. */
+    markStale(): void;
+    /** Rebuild from this view's full rows; a failed rebuild keeps the old engine stale. */
+    rebuild(rows: readonly SkillIndexRow[]): Promise<boolean>;
+    /** @returns hits, truncation, and whether the index is stale. */
+    search(query: SkillSearchQuery, options?: {
+        readonly allowedSkillKeys?: ReadonlySet<string> | undefined;
+    }): Promise<SkillSearchResponse>;
+}
+/** Identity inputs for one per-view search index. */
+export interface SearchIndexCacheKey {
+    readonly viewKey: string;
+    readonly viewCatalogDigest: string;
+    readonly policyDigest: string;
+    readonly discoveryMode: string;
+}
+/** Per-view cache keyed by searchIndexKey; never shares one engine across views. */
+export declare class SkillSearchCache {
+    private readonly entries;
+    /**
+     * 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.
+     */
+    get(key: SearchIndexCacheKey, rows: readonly SkillIndexRow[]): Promise<{
+        index: SkillSearchIndex;
+        stale: boolean;
+    } | undefined>;
+    /** Drop every index for one view. */
+    invalidate(viewKey: string): void;
+    /** Drop every cached view index. */
+    clear(): void;
+}
+//# sourceMappingURL=search.d.ts.map

package/lib/types/security.d.ts

@@ -0,0 +1,14 @@
+/** One sanitized untrusted string. */
+export interface SanitizedText {
+    readonly text: string;
+    readonly truncated: boolean;
+}
+/**
+ * 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.
+ */
+export declare function sanitizeUntrustedText(value: string, limit?: number): SanitizedText;
+//# sourceMappingURL=security.d.ts.map

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

@@ -0,0 +1,19 @@
+/** Persisted discovery metadata used to keep old sessions full-catalog. */
+export interface DiscoverySessionMeta {
+    readonly discoveryMode?: 'off' | 'shadow' | 'on' | undefined;
+    readonly featureEpoch?: string | undefined;
+}
+/** @returns true only for a new, fully-enabled session in the current epoch. */
+export declare function shouldHideCatalog(meta: DiscoverySessionMeta | undefined, currentFeatureEpoch: string): boolean;
+/** @returns true when awareness may be emitted (shadow or on). */
+export declare function shouldEmitAwareness(meta: DiscoverySessionMeta | undefined, currentFeatureEpoch: string): boolean;
+/** @returns false when the same digest was already emitted in this session. */
+export declare function shouldEmitDigest(previousDigest: string | undefined, nextDigest: string): boolean;
+/** @returns off at <=2200 tokens, on at >=3000, shadow between. */
+export declare function projectionBudgetMode(catalogTokens: number, promoted?: boolean): 'off' | 'shadow' | 'on';
+/** @returns true when a resumed session already enabled discovery. */
+export declare function shouldInstallAwarenessOnResume(record: {
+    readonly discoveryMode: 'off' | 'shadow' | 'on';
+    readonly featureEpoch: string;
+} | undefined, featureEpoch: string): boolean;
+//# sourceMappingURL=session-projection.d.ts.map

package/lib/types/session-store.d.ts

@@ -0,0 +1,22 @@
+import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
+/** One persisted session's discovery mode. */
+export interface DiscoverySessionRecord {
+    readonly sessionId: string;
+    readonly discoveryMode: 'off' | 'shadow' | 'on';
+    readonly featureEpoch: string;
+    readonly projectionDigest?: string | undefined;
+}
+/** Plugin-side session metadata; platform SessionHeader has no discovery fields. */
+export declare class DiscoverySessionStore {
+    private readonly io;
+    private readonly path;
+    constructor(io: EvolutionIoLike, path: string);
+    private read;
+    /** @returns persisted metadata for one session. */
+    get(sessionId: string): Promise<DiscoverySessionRecord | undefined>;
+    /** Persist one session's mode/epoch; later writes win. */
+    put(record: DiscoverySessionRecord): Promise<void>;
+}
+/** @returns true only for a persisted enabled session in the current feature epoch. */
+export declare function shouldProjectPersistedSession(store: DiscoverySessionStore, sessionId: string, currentFeatureEpoch: string): Promise<boolean>;
+//# sourceMappingURL=session-store.d.ts.map

package/lib/types/shadow-evidence.d.ts

@@ -0,0 +1,22 @@
+import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
+import type { ProjectionResult } from './projection.ts';
+/** Durable shadow-run evidence; every complete shadow projection is one sample. */
+export declare class ShadowEvidenceStore {
+    private readonly io;
+    private readonly path;
+    private samples;
+    private recovered;
+    private hidden;
+    private silentMisses;
+    private loaded;
+    constructor(io: EvolutionIoLike, path: string);
+    load(): Promise<void>;
+    record(result: ProjectionResult): Promise<void>;
+    evidence(): {
+        samples: number;
+        hiddenRecoverableRate: number;
+        silentMisses: number;
+    };
+    canPromote(): boolean;
+}
+//# sourceMappingURL=shadow-evidence.d.ts.map

package/lib/types/stages.d.ts

@@ -0,0 +1,6 @@
+/** Ordered implementation stages from PLAN-DISC-001. */
+export declare const DISCOVERY_STAGES: readonly ["G0-projection", "G1-domain", "G2-projection", "G3-search", "G4-assignment", "G5-maintenance", "G6-ui", "G7-migration", "G8-release"];
+export type DiscoveryStage = (typeof DISCOVERY_STAGES)[number];
+export declare function stageIndex(stage: DiscoveryStage): number;
+export declare function mayAdvance(current: DiscoveryStage, next: DiscoveryStage): boolean;
+//# sourceMappingURL=stages.d.ts.map

package/lib/types/tool.d.ts

@@ -0,0 +1,27 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { SkillSearch, SkillSearchQuery, SkillSearchResponse } from './search.ts';
+/** Search dependency supplied by the composition; absent search degrades. */
+export interface SkillSearchProvider {
+    search(query: SkillSearchQuery, options?: {
+        readonly allowedSkillKeys?: ReadonlySet<string> | undefined;
+    }, agent?: Agent | undefined): Promise<SkillSearchResponse>;
+    /** Optional current-view policy filter; called per tool call. */
+    allowedSkillKeys?(agent: Agent | undefined): ReadonlySet<string> | Promise<ReadonlySet<string>> | undefined;
+}
+/** Static model-facing description; no dynamic domain list/tree. */
+export declare 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. */
+export declare function searchWithDegraded(provider: SkillSearchProvider | undefined, query: SkillSearchQuery, allowedSkillKeys?: ReadonlySet<string> | undefined, agent?: Agent | undefined): Promise<SkillSearchResponse>;
+/**
+ * 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.
+ */
+export declare function registerSkillSearchTool(ctx: Context, provider: SkillSearchProvider | undefined): () => void;
+/** @returns true only for a search implementation; used by composition wiring. */
+export declare function isSkillSearch(value: unknown): value is SkillSearch;
+//# sourceMappingURL=tool.d.ts.map

package/lib/types/ui.d.ts

@@ -0,0 +1,69 @@
+/** Read-only card projection for UI; counts are intentionally separate. */
+export interface DiscoveryCardView {
+    readonly id: string;
+    readonly title: string;
+    readonly purpose: string;
+    readonly descriptionStatus: 'fresh' | 'stale' | 'failed';
+    readonly triggers: readonly string[];
+    readonly managedModelInvocableCount: number;
+    readonly externalCatalogCount: number;
+    readonly pendingCount: number;
+    readonly mapStale: boolean;
+    readonly asOf: string;
+}
+/** Read-only product state; no L1/L2 tree or task view. */
+export interface DiscoveryUiState {
+    readonly cards: readonly DiscoveryCardView[];
+    readonly unclassifiedCount: number;
+    readonly mapStale: boolean;
+    readonly completeness: 'complete' | 'partial' | 'unavailable';
+    readonly asOf: string;
+    readonly searchEnabled: boolean;
+}
+/** Allowed user policy fields; anything else is rejected. */
+export interface DiscoveryUserPolicy {
+    readonly mode?: 'auto' | 'off' | 'on' | undefined;
+    readonly maxCards?: number | undefined;
+    readonly tokenBudget?: number | undefined;
+    readonly staleAfterHours?: number | undefined;
+    readonly pinDomains?: readonly string[] | undefined;
+    readonly disableDomains?: readonly string[] | undefined;
+}
+/** @returns true when the policy only edits supported fields. */
+export declare function isDiscoveryUserPolicy(value: unknown): value is DiscoveryUserPolicy;
+/** Static skill_manage description; no dynamic domain list/count/tree. */
+export declare const SKILL_MANAGE_DESCRIPTION = "Manage skill content. create may include an optional domain proposal when create-side domain cards are available; no proposal means unclassified. Domain assignment never blocks skill creation and is stored as a sidecar.";
+/** Future skill_domains contract; NOT a search parameter and not implemented in v0. */
+export interface SkillDomainsContract {
+    readonly action: 'list' | 'expand';
+    readonly domainId?: string | undefined;
+    readonly depth?: 1 | 2 | undefined;
+}
+/** Replayable behavior metrics; no prompt sentence lock. */
+export interface DiscoveryBehaviorObservation {
+    readonly awarenessShown: boolean;
+    readonly awarenessRecalled: boolean;
+    readonly silentMiss: boolean;
+    readonly searched: boolean;
+    readonly overSearch: boolean;
+    readonly underSearch: boolean;
+    readonly wrongLoad: boolean;
+    readonly taskSuccess: boolean;
+    readonly tokens: number;
+    readonly fallback: boolean;
+}
+/** Behavior metrics for one fixture/replay batch. */
+export interface DiscoveryBehaviorMetrics {
+    readonly awarenessRecall: number | null;
+    readonly silentMissRate: number | null;
+    readonly overSearchRate: number | null;
+    readonly underSearchRate: number | null;
+    readonly wrongLoadRate: number | null;
+    readonly taskSuccess: number | null;
+    readonly tokens: number;
+    readonly fallbackRate: number | null;
+    readonly total: number;
+}
+/** @returns recomputable behavior metrics; null means no denominator. */
+export declare function computeBehaviorMetrics(observations: readonly DiscoveryBehaviorObservation[]): DiscoveryBehaviorMetrics;
+//# sourceMappingURL=ui.d.ts.map

package/lib/types/worker.d.ts

@@ -0,0 +1,14 @@
+import type { AssignmentQueueEntry, DomainAssignmentService } from './assignment.ts';
+/** Queue view needed by the worker. */
+export interface AssignmentQueueReader {
+    list(): readonly AssignmentQueueEntry[];
+}
+/** Drivable worker; the composition may call drain on a schedule. */
+export declare class AssignmentWorker {
+    private readonly service;
+    private readonly queue;
+    constructor(service: DomainAssignmentService, queue: AssignmentQueueReader);
+    /** Process queued entries once; returns processed count. */
+    drain(limit?: number): Promise<number>;
+}
+//# sourceMappingURL=worker.d.ts.map