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

package/lib/types/generation-composition.d.ts

@@ -0,0 +1,38 @@
+import type { DomainGenerationPort } from './domain-generation-service.ts';
+import { type LlmStreamService } from './domain-generation-llm.ts';
+import type { GenerationRequest } from './domain-generation-coordinator.ts';
+import type { SkillIndexRow } from './identity.ts';
+/** Inputs for the production generation port composition. */
+export interface GenerationCompositionInput {
+    readonly mode: 'off' | 'shadow' | 'on';
+    readonly llm?: LlmStreamService | undefined;
+    readonly provider: string;
+    readonly model: string;
+    readonly maxTokens?: number | undefined;
+    readonly timeoutMs?: number | undefined;
+    readonly attempts?: number | undefined;
+}
+/**
+ * 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.
+ */
+export declare function resolveGenerationPort(input: GenerationCompositionInput): DomainGenerationPort | undefined;
+/** Inputs for a map-scope generation request built from one live view. */
+export interface GenerationRequestInput {
+    readonly mapScope: string;
+    readonly sourceDigest: string;
+    readonly mapVersion: string;
+    readonly rows: readonly SkillIndexRow[];
+    readonly prompt: string;
+    readonly promptVersion: string;
+    readonly model: string;
+    readonly runId: string;
+}
+/**
+ * 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.
+ */
+export declare function buildGenerationRequest(input: GenerationRequestInput): GenerationRequest;
+//# sourceMappingURL=generation-composition.d.ts.map

package/lib/types/generation-input.d.ts

@@ -0,0 +1,9 @@
+import type { BootstrapSkillFact } from './domain-bootstrap.ts';
+import type { SkillIndexRow } from './identity.ts';
+/**
+ * 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.
+ */
+export declare function bootstrapFactsFromRows(rows: readonly SkillIndexRow[]): readonly BootstrapSkillFact[];
+//# sourceMappingURL=generation-input.d.ts.map

package/lib/types/index.d.ts

@@ -1,44 +1,16 @@
-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 './skill-index.ts';
+export * from './view-state.ts';
+export * from './domain-policy-store.ts';
+export * from './catalog-codec.ts';
+export * from './projection-journal.ts';
+export * from './projection-adapter.ts';
+export * from './projection-runtime.ts';
+export * from './view-snapshot-store.ts';
+export * from './domain-generation-coordinator.ts';
+export * from './domain-generation-llm.ts';
+export * from './generation-input.ts';
+export * from './generation-composition.ts';
 export * from './domain-map.ts';
 export * from './projection.ts';
 export * from './adapter.ts';
@@ -70,5 +42,4 @@ 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/main-entry.d.ts

@@ -0,0 +1,36 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { DomainPolicyLayer } from './domain-policy.ts';
+/** Main production config. */
+export interface Config {
+    readonly featureEpoch: string;
+    readonly mode?: 'off' | 'shadow' | 'on' | undefined;
+    readonly searchEnabled?: boolean | undefined;
+    readonly domainMapPath?: string | undefined;
+    readonly projectionJournalPath?: string | undefined;
+    readonly viewSnapshotPath?: string | undefined;
+    readonly assignmentQueuePath?: string | undefined;
+    readonly createClassificationEnabled?: boolean | undefined;
+    readonly provisionalThreshold?: number | undefined;
+    readonly mapReferenceCwd?: string | undefined;
+    readonly mapReferenceScope?: string | undefined;
+    readonly generationProvider?: string | undefined;
+    readonly generationModel?: string | undefined;
+    readonly generationTimeoutMs?: number | undefined;
+    readonly generationMaxTokens?: number | undefined;
+    readonly generationAttempts?: number | undefined;
+    readonly maxCards?: number | undefined;
+    readonly tokenBudget?: number | undefined;
+    readonly pinDomains?: readonly string[] | undefined;
+    readonly disableDomains?: readonly string[] | undefined;
+    readonly staleAfterHours?: number | undefined;
+    readonly descriptionStaleAfterHours?: number | undefined;
+    readonly workspacePolicy?: DomainPolicyLayer | undefined;
+    readonly scopePolicy?: DomainPolicyLayer | undefined;
+    readonly workspacePolicyPath?: string | undefined;
+    readonly scopePolicyPath?: string | undefined;
+}
+export declare const name = "evolution-skill-discovery";
+export declare const inject: string[];
+/** Apply the full production discovery composition. */
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=main-entry.d.ts.map

package/lib/types/plugin.d.ts

@@ -13,15 +13,9 @@ export interface Config {
     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;

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

@@ -0,0 +1,60 @@
+import type { PreStepDecision } from '@deepseek-ai/dsh-agent';
+import type { ContextFormed, UserMessage } from '@deepseek-ai/dsh-llm';
+import type { ProjectionResult } from './projection.ts';
+import { type CatalogCapture } from './catalog-codec.ts';
+declare module '@deepseek-ai/dsh-llm' {
+    interface MessageSourceMap {
+        'evolution-skill-projection': {
+            readonly kind: 'evolution-skill-projection';
+            readonly entries: readonly CatalogEntry[];
+            readonly hiddenNames: readonly string[];
+            readonly digest: string;
+        } & ContextFormed;
+    }
+}
+import type { CatalogEntry } from './projection.ts';
+/** @returns the first platform catalog message in the current decision. */
+export declare function findCatalogMessage(decision: PreStepDecision): UserMessage | undefined;
+/**
+ * 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.
+ */
+export declare function applyCapturedProjection(decision: PreStepDecision, capture: CatalogCapture, entries: readonly CatalogEntry[]): PreStepDecision;
+/**
+ * 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.
+ */
+export declare function restoreCapturedProjection(decision: PreStepDecision, capture: CatalogCapture): PreStepDecision;
+/**
+ * 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.
+ */
+export declare function applyReplacementDecision(decision: PreStepDecision, sourceEntries: readonly CatalogEntry[], result: ProjectionResult): PreStepDecision;
+/**
+ * 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.
+ */
+export declare function applyRestoreUpdate(decision: PreStepDecision, capture: CatalogCapture): PreStepDecision;
+/** @returns captured current catalog or undefined when the shape is unknown. */
+export declare function captureDecisionCatalog(decision: PreStepDecision): CatalogCapture | undefined;
+/** @returns a model-visible projection context message, or undefined when empty. */
+export declare function renderProjectionContext(result: ProjectionResult): UserMessage | undefined;
+/**
+ * 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.
+ */
+export declare function applyProjectedDecision(decision: PreStepDecision, capture: CatalogCapture, result: ProjectionResult): PreStepDecision;
+//# sourceMappingURL=projection-adapter.d.ts.map

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

@@ -0,0 +1,32 @@
+import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
+import type { CatalogCapture } from './catalog-codec.ts';
+/** Durable record of one projection so it can be restored after restart. */
+export interface ProjectionJournalRecord {
+    readonly sessionId: string;
+    readonly viewKey: string;
+    readonly projectionDigest: string;
+    readonly codecVersion: string;
+    readonly mapVersion: string;
+    readonly policyDigest: string;
+    readonly base: CatalogCapture;
+    readonly createdAt: number;
+}
+/** Durable projection journal; no base means restore must fail closed. */
+export declare class ProjectionJournal {
+    private readonly io;
+    private readonly path;
+    private readonly maxRecords;
+    constructor(io: EvolutionIoLike, path: string, options?: {
+        readonly maxRecords?: number | undefined;
+    });
+    private read;
+    /** Persist one projection record; later records with the same key win. */
+    put(record: ProjectionJournalRecord): Promise<void>;
+    /** @returns the exact projection record for one view/digest/codec, if present. */
+    get(sessionId: string, viewKey: string, projectionDigest: string, codecVersion: string): Promise<ProjectionJournalRecord | undefined>;
+    /** @returns newest record for a view, used when leaving ready without a known digest. */
+    latest(sessionId: string, viewKey: string, codecVersion: string): Promise<ProjectionJournalRecord | undefined>;
+    /** Delete one record after a successful restore. */
+    remove(sessionId: string, viewKey: string, projectionDigest: string, codecVersion: string): Promise<void>;
+}
+//# sourceMappingURL=projection-journal.d.ts.map

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

@@ -0,0 +1,63 @@
+import type { Agent, PreStepDecision } from '@deepseek-ai/dsh-agent';
+import type { DomainMapStore } from './domain-map.ts';
+import type { DomainPolicyStore } from './domain-policy-store.ts';
+import { type SkillIndexSource } from './skill-index.ts';
+import { ProjectionJournal } from './projection-journal.ts';
+import { type ViewState } from './view-state.ts';
+/** Working-directory port; supplied by the platform composition. */
+export interface WorkingDirectoryPort {
+    ensure(agent: Agent, signal?: AbortSignal | undefined): Promise<string>;
+}
+/** Inputs for the per-view projection runtime. */
+export interface ProjectionRuntimePorts {
+    readonly skillIndexSource: SkillIndexSource;
+    readonly map: DomainMapStore;
+    readonly policy: DomainPolicyStore;
+    readonly policyFor?: ((cwd: string) => Promise<DomainPolicyStore>) | undefined;
+    readonly journal: ProjectionJournal;
+    readonly workingDirectory: WorkingDirectoryPort;
+    readonly featureEpoch: string;
+    readonly codecVersion: string;
+    readonly adapterVersion: string;
+    readonly projectionSchemaVersion: string;
+    readonly mode: 'off' | 'shadow' | 'on';
+    readonly maxCards?: number | undefined;
+    readonly tokenBudget?: number | undefined;
+    readonly searchAvailable?: (() => boolean) | undefined;
+    readonly staleAfterHours?: number | undefined;
+    readonly descriptionStaleAfterHours?: number | undefined;
+    readonly isFrozen?: ((agent: Agent) => boolean | Promise<boolean>) | undefined;
+}
+/** Last projection action, for diagnostics and current-request assertions. */
+export interface ProjectionReport {
+    readonly action: 'none' | 'applied' | 'restored' | 'blocked';
+    readonly digest: string;
+    readonly content?: string | undefined;
+    readonly at: number;
+}
+/** Per-view projection runtime; no global readiness and no history edits. */
+export declare class ProjectionRuntime {
+    private readonly ports;
+    private readonly states;
+    private last;
+    private readonly lastByAgent;
+    constructor(ports: ProjectionRuntimePorts);
+    /** @returns last action for one agent, or the latest process-wide action. */
+    report(agent?: Agent | undefined): ProjectionReport;
+    private mark;
+    /** @returns current state for diagnostics, if this process has seen the view. */
+    stateFor(viewKey: string, mapVersion: string, policyDigest: string): ViewState | undefined;
+    private restore;
+    private readState;
+    /** @returns current per-view state without projecting; used by diagnostic commands. */
+    inspect(agent: Agent, signal?: AbortSignal | undefined): Promise<ViewState>;
+    /**
+     * 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.
+     */
+    project(agent: Agent, decision: PreStepDecision, signal?: AbortSignal | undefined): Promise<PreStepDecision>;
+}
+//# sourceMappingURL=projection-runtime.d.ts.map

package/lib/types/projection.d.ts

@@ -16,6 +16,7 @@ export interface DomainCard {
     readonly managedCount: number;
     readonly externalCount: number;
     readonly pendingCount: number;
+    readonly unclassifiedCount?: number | undefined;
     readonly state: 'active' | 'provisional';
     readonly asOf: string;
     readonly mapVersion: string;
@@ -42,8 +43,6 @@ 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;

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

@@ -0,0 +1,19 @@
+import type { Context } from '@deepseek-ai/cordis';
+/** Search-only composition config. Domain/projection config is intentionally absent. */
+export interface Config {
+    /** Stable feature epoch used by later projection phases; required for config compatibility. */
+    readonly featureEpoch: string;
+    /** Register the model-visible skill_search tool. Defaults to true. */
+    readonly searchEnabled?: boolean | undefined;
+    /** Legacy discovery mode; search-only accepts only off and warns otherwise. */
+    readonly mode?: 'off' | 'shadow' | 'on' | 'auto' | undefined;
+}
+export declare const name = "evolution-skill-discovery";
+export declare const inject: string[];
+/**
+ * Compose the search-only discovery surface.
+ * @param ctx - plugin context with skills, workingDirectory, and tools.
+ * @param config - search-only configuration.
+ */
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=search-entry.d.ts.map

package/lib/types/skill-index.d.ts

@@ -0,0 +1,41 @@
+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>;
+}
+//# sourceMappingURL=skill-index.d.ts.map

package/lib/types/tool.d.ts

@@ -5,14 +5,14 @@ import type { SkillSearch, SkillSearchQuery, SkillSearchResponse } from './searc
 export interface SkillSearchProvider {
     search(query: SkillSearchQuery, options?: {
         readonly allowedSkillKeys?: ReadonlySet<string> | undefined;
-    }, agent?: Agent | undefined): Promise<SkillSearchResponse>;
+    }, agent?: Agent | undefined, signal?: AbortSignal | undefined): Promise<SkillSearchResponse>;
     /** Optional current-view policy filter; called per tool call. */
-    allowedSkillKeys?(agent: Agent | undefined): ReadonlySet<string> | Promise<ReadonlySet<string>> | undefined;
+    allowedSkillKeys?(agent: Agent | undefined, signal?: AbortSignal | undefined): ReadonlySet<string> | undefined | 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>;
+export declare function searchWithDegraded(provider: SkillSearchProvider | undefined, query: SkillSearchQuery, allowedSkillKeys?: ReadonlySet<string> | undefined, agent?: Agent | undefined, signal?: AbortSignal | undefined): Promise<SkillSearchResponse>;
 /**
  * Register skill_search on the optional tools service. The description/schema are static; the
  * provider is the only dynamic dependency.

package/lib/types/view-snapshot-store.d.ts

@@ -0,0 +1,30 @@
+import type { EvolutionIoLike } from '@lmzhen/dsh-evolution-core';
+/** Frozen view identity captured when a session is created. */
+export interface ViewSnapshot {
+    readonly sessionId: string;
+    readonly viewKey: string;
+    readonly cwd: string;
+    readonly viewCatalogDigest: string;
+    readonly mapVersion: string;
+    readonly configDigest: string;
+    readonly featureEpoch: string;
+    readonly createdAt: number;
+}
+/** Durable per-session view snapshot; old epochs stay frozen. */
+export declare class ViewSnapshotStore {
+    private readonly io;
+    private readonly path;
+    constructor(io: EvolutionIoLike, path: string);
+    private read;
+    /** Persist one session snapshot; first writer wins unless overwrite is explicit. */
+    put(snapshot: ViewSnapshot, options?: {
+        readonly overwrite?: boolean | undefined;
+    }): Promise<void>;
+    /** @returns frozen snapshot for one session, if recorded. */
+    get(sessionId: string): Promise<ViewSnapshot | undefined>;
+    /**
+     * @returns true for legacy sessions without a snapshot and for older feature epochs.
+     */
+    isFrozen(sessionId: string, currentFeatureEpoch: string): Promise<boolean>;
+}
+//# sourceMappingURL=view-snapshot-store.d.ts.map

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

@@ -0,0 +1,59 @@
+/** Per-view projection state; one instance per (workspace, scope, revision). */
+export type ProjectionPhase = 'off' | 'unavailable' | 'bootstrapping' | 'ready' | 'degraded';
+export type MapState = 'empty' | 'ready' | 'stale' | 'corrupt';
+export type SearchState = 'ready' | 'degraded';
+export type PolicyState = 'ready' | 'degraded';
+/** Observable state for one view; never a global readiness flag. */
+export interface ViewState {
+    readonly viewKey: string;
+    readonly phase: ProjectionPhase;
+    readonly map: MapState;
+    readonly search: SearchState;
+    readonly policy: PolicyState;
+    readonly reasons: readonly string[];
+    readonly mapVersion: string;
+    readonly policyDigest: string;
+    readonly viewCatalogDigest: string;
+}
+/** Inputs used to derive one view state. */
+export interface ViewStateInput {
+    readonly viewKey: string;
+    readonly mode: 'off' | 'shadow' | 'on';
+    readonly map: MapState;
+    readonly search: SearchState;
+    readonly policy: PolicyState;
+    readonly catalogComplete: boolean;
+    readonly mapVersion: string;
+    readonly policyDigest: string;
+    readonly viewCatalogDigest: string;
+    readonly reasons?: readonly string[];
+}
+/**
+ * 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.
+ */
+export declare function deriveViewState(input: ViewStateInput): ViewState;
+/** @returns true only when this view may hide catalog entries. */
+export declare function canHide(state: ViewState): boolean;
+/** @returns true when this view may render cards, even if hiding is blocked. */
+export declare function canProject(state: ViewState): boolean;
+/** Bounded view-state cache keyed by view identity and codec version. */
+export declare class ViewStateRegistry {
+    private readonly entries;
+    private readonly limit;
+    private readonly ttlMs;
+    private readonly now;
+    constructor(options?: {
+        readonly limit?: number | undefined;
+        readonly ttlMs?: number | undefined;
+        readonly now?: (() => number) | undefined;
+    });
+    /** @returns cache key including all identity components that can change a view. */
+    key(state: Pick<ViewState, 'viewKey' | 'mapVersion' | 'policyDigest'>, codecVersion: string): string;
+    set(state: ViewState, codecVersion: string): void;
+    get(viewKey: string, mapVersion: string, policyDigest: string, codecVersion: string): ViewState | undefined;
+    deleteView(viewKey: string): void;
+    prune(): void;
+}
+//# sourceMappingURL=view-state.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-skill-discovery",
   "description": "Read model and view identity for evolution skill discovery (community build)",
-  "version": "0.30.42",
+  "version": "0.31.0",
   "publishConfig": {
     "access": "public"
   },
@@ -11,10 +11,18 @@
     "directory": "packages/evolution-skill-discovery"
   },
   "type": "module",
-  "main": "lib/index.js",
-  "types": "lib/types/index.d.ts",
+  "main": "lib/main-entry.js",
+  "types": "lib/types/main-entry.d.ts",
   "exports": {
     ".": {
+      "types": "./lib/types/main-entry.d.ts",
+      "default": "./lib/main-entry.js"
+    },
+    "./search": {
+      "types": "./lib/types/search-entry.d.ts",
+      "default": "./lib/search-entry.js"
+    },
+    "./domain": {
       "types": "./lib/types/index.d.ts",
       "default": "./lib/index.js"
     },
@@ -33,8 +41,8 @@
     "@deepseek-ai/dsh-session": "^0.2.1-rc.2",
     "@deepseek-ai/dsh-tools": "^0.2.1-rc.2",
     "@deepseek-ai/dsh-system-prompt": "^0.2.1-rc.2",
-    "@lmzhen/dsh-evolution-core": "^0.30.42",
-    "@lmzhen/dsh-evolution-io": "^0.30.42"
+    "@lmzhen/dsh-evolution-core": "^0.31.0",
+    "@lmzhen/dsh-evolution-io": "^0.31.0"
   },
   "devDependencies": {
     "@deepseek-ai/dsh-skill": "^0.2.1-rc.2",
@@ -47,13 +55,12 @@
     "@deepseek-ai/dsh-tools": "^0.2.1-rc.2",
     "@deepseek-ai/dsh-skill-filesystem": "^0.2.1-rc.2",
     "@deepseek-ai/dsh-tool-skill": "^0.2.1-rc.2",
-    "@lmzhen/dsh-evolution-core": "^0.30.42",
-    "@lmzhen/dsh-evolution-io": "^0.30.42"
+    "@lmzhen/dsh-evolution-core": "^0.31.0",
+    "@lmzhen/dsh-evolution-io": "^0.31.0"
   },
   "dependencies": {
     "@deepseek-ai/dsh-llm": "^0.2.1-rc.2",
-    "minisearch": "^7.2.0",
-    "@deepseek-ai/dsh-tools": "^0.2.1-rc.2"
+    "minisearch": "^7.2.0"
   },
   "engines": {
     "dsh": ">=0.2.1-rc.2 <0.2.2-0"

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

@@ -1,22 +0,0 @@
-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