dsh-mnemon 0.2.16 → 0.3.1

package/lib/types/{shared → src/shared}/contracts.d.ts

@@ -1,4 +1,6 @@
 import type { ConnectionHandle as DshClientConnectionHandle } from '@deepseek-ai/dsh-client-connection/client';
+import type { MemoryLayerParticipation, MemorySystemDescriptor } from '../memory-system/contracts.ts';
+export type { MemoryLayerParticipation, MemoryParticipationChannel, MemoryParticipationMode, MemorySystemDescriptor, MemoryTopologyDefinition, } from '../memory-system/contracts.ts';
 export declare const MNEMON_READ_CHANNEL = "/dsh-mnemon-read";
 export declare const MNEMON_ACTIVATION_CHANNEL = "/dsh-mnemon-activation";
 export declare const MNEMON_WRITE_CHANNEL = "/dsh-mnemon-write";
@@ -63,6 +65,26 @@ export type SettingsOperation = {
     path: string[];
 };
 export type StorageScopeKind = 'global' | 'workspace' | 'custom';
+export interface MemoryLayerConfig {
+    enabled?: boolean;
+    participation?: Partial<MemoryLayerParticipation>;
+    adapterIds?: string[];
+}
+export interface MemoryTopologyConfig {
+    id?: string;
+    strategyId?: string;
+    layers?: Record<string, MemoryLayerConfig>;
+}
+export interface ResolvedMemoryLayerConfig {
+    enabled: boolean;
+    participation: MemoryLayerParticipation;
+    adapterIds: string[];
+}
+export interface ResolvedMemoryTopologyConfig {
+    id: string;
+    strategyId: string;
+    layers: Record<string, ResolvedMemoryLayerConfig>;
+}
 export interface CustomPackConfig {
     id: string;
     name: string;
@@ -97,6 +119,7 @@ export interface Config {
     store?: string;
     timeoutMs?: number;
     defaultRecallLimit?: number;
+    memoryTopology?: MemoryTopologyConfig;
     recallQuality?: RecallQualityConfig;
     routingGuidance?: boolean;
     displayMode?: 'sidebar' | 'buildin';
@@ -169,6 +192,7 @@ export interface ResolvedConfig {
     store?: string;
     timeoutMs: number;
     defaultRecallLimit: number;
+    memoryTopology: ResolvedMemoryTopologyConfig;
     recallQuality: ResolvedRecallQualityConfig;
     routingGuidance: boolean;
     displayMode: 'sidebar' | 'buildin';
@@ -818,6 +842,7 @@ export interface StatusView {
     memoryBodyDirectory: string;
     memoryBodies: MemoryBodyView[];
     providerServices?: MemoryProviderRuntimeStatus[];
+    memorySystem?: MemorySystemDescriptor;
     lifecycle?: LifecycleSnapshot;
     documents?: DocumentSnapshot;
     storage?: StorageScopeCatalog;

package/lib/types/{subagent.d.ts → src/subagent.d.ts}

@@ -1,17 +1,12 @@
 import type { HostAgent, HostSubagentsService, ToolDefinition } from './contracts.ts';
 import { type DocumentManager, type DocumentMutation, type DocumentMutationResult, type DocumentView } from './documents.ts';
 import { type RuntimeMemoryController, type RuntimeMemoryMutation, type RuntimeMemoryMutationResult } from './runtime-memory.ts';
-import type { Insight, MnemonService, RememberRequest, SearchRequest } from './service.ts';
+import { type EdgeType, type Insight, type RememberRequest, type SearchRequest } from './service.ts';
 import { type PreparedMemoryPlacement } from './provider-placement.ts';
 import type { MemoryBodyMetadataMaintenanceResult, MemoryPlacementDecision, SubagentCounters } from './shared/contracts.ts';
+import type { MnemonAgentRuntimeSource } from './live-runtime.ts';
 export type { SubagentCounters } from './shared/contracts.ts';
-interface AgentRuntimeSource {
-    forAgent(agent: HostAgent): {
-        service: MnemonService;
-        runtimeMemory: RuntimeMemoryController;
-        documents: DocumentManager;
-    };
-}
+type AgentRuntimeSource = Pick<MnemonAgentRuntimeSource, 'forAgent'>;
 interface HostToolRegistry {
     register(definition: ToolDefinition): unknown;
 }
@@ -21,18 +16,14 @@ interface HostResultToolRuntime {
 }
 /** Rejects schema keywords that DSH structured-output tools cannot compile. */
 export declare function assertDshOutputSchema(schema: unknown, path?: string): void;
-export interface DelegatedRecallResult {
+export interface RecallResult {
     query: string;
     mode: string;
     results: Insight[];
     hint?: string;
-    delegation: {
-        runId: string;
-        provider: string;
-        summary: string;
-        selectedMemoryBodyIds: string[];
-    };
 }
+/** Compatibility name for the v0.3 pre-release API. Recall no longer delegates. */
+export type DelegatedRecallResult = RecallResult;
 export interface DelegatedWriteResult {
     delegated: true;
     runId: string;
@@ -61,7 +52,6 @@ export interface DelegatedAnswerResult {
 }
 export type CoordinatedRuntimeMemoryResult = RuntimeMemoryMutationResult & {
     maintenance?: {
-        kind: 'mnemon-archive' | 'local-compaction';
         runId: string;
         provider: string;
         summary: string;
@@ -76,20 +66,33 @@ export declare class MnemonSubagentCoordinator {
     private readonly documents?;
     private readonly resultRuntime?;
     private readonly taskAgentModelResolver?;
-    private readonly serviceOrSource?;
     private readonly counters;
     private runtimeQueue;
     private documentQueue;
+    private readonly retrievalTurns;
     constructor(subagents: HostSubagentsService, runtimeMemoryOrSource?: (RuntimeMemoryController | AgentRuntimeSource) | undefined, documents?: DocumentManager | undefined, resultRuntime?: HostResultToolRuntime | undefined, taskAgentModelResolver?: (() => {
         provider: string;
         model: string;
-    } | undefined) | undefined, serviceOrSource?: (MnemonService | AgentRuntimeSource) | undefined);
+    } | undefined) | undefined);
     snapshot(): SubagentCounters;
     documentsSnapshot(parent: HostAgent): import("./documents.ts").DocumentSnapshot;
     documentGet(parent: HostAgent, id: string): DocumentView;
     documentSearch(parent: HostAgent, query: string, includeArchived?: boolean, limit?: number): Promise<import("./documents.ts").DocumentSearchResult>;
-    recall(parent: HostAgent, request: SearchRequest, signal: AbortSignal): Promise<DelegatedRecallResult>;
-    related(parent: HostAgent, id: string, memoryBodyId: string | undefined, signal: AbortSignal): Promise<DelegatedRecallResult>;
+    /** Admit at most one model-facing Documents query for one root turn. */
+    claimDocumentSearch(parent: HostAgent): boolean;
+    recall(parent: HostAgent, request: SearchRequest, signal: AbortSignal, options?: {
+        requirePinnedView?: boolean;
+    }): Promise<RecallResult>;
+    /** Bind a model read to the Source state pinned by its root turn. */
+    scopeRecallRequest(agent: HostAgent, request: SearchRequest, requirePinnedView?: boolean): SearchRequest;
+    private scopeRecallWithAuthority;
+    scopeRelatedMemoryBody(agent: HostAgent, memoryBodyId?: string, requirePinnedView?: boolean): string | undefined;
+    private scopeRelatedWithAuthority;
+    related(parent: HostAgent, id: string, memoryBodyId: string | undefined, signal: AbortSignal, options?: {
+        depth?: number;
+        edge?: EdgeType;
+        requirePinnedView?: boolean;
+    }): Promise<RecallResult>;
     placeProvider(parent: HostAgent, body: {
         name: string;
         description: string;
@@ -102,14 +105,19 @@ export declare class MnemonSubagentCoordinator {
     answer(parent: HostAgent, query: string, evidence: Insight[], signal: AbortSignal): Promise<DelegatedAnswerResult>;
     write(parent: HostAgent, operation: string, request: unknown, signal: AbortSignal): Promise<DelegatedWriteResult>;
     review(parent: HostAgent, signal: AbortSignal): Promise<DelegatedWriteResult>;
-    private recallResult;
     private documentLocked;
     private archiveDocumentLocked;
     private runtimeLocked;
     private compactUserAndCommit;
+    private archiveRuntimeEntry;
     private delegate;
     private provider;
+    private recallAuthority;
+    private turnAuthority;
+    private turnRetrievalState;
+    private recordRecall;
     private runtimeMemoryFor;
     private serviceFor;
+    private assertAutomaticMemoryWrite;
     private documentsFor;
 }

package/lib/types/{tools.d.ts → src/tools.d.ts}

@@ -1,17 +1,10 @@
 import type { HostContextShape } from './contracts.ts';
-import type { HostAgent } from './contracts.ts';
 import type { DocumentManager } from './documents.ts';
 import type { RuntimeMemoryController } from './runtime-memory.ts';
+import type { MnemonAgentRuntimeSource } from './live-runtime.ts';
 import { MnemonSubagentCoordinator } from './subagent.ts';
 import { type MnemonService } from './service.ts';
-interface AgentRuntimeSource {
-    readonly config: MnemonService['config'];
-    forAgent(agent: HostAgent): {
-        service: MnemonService;
-        runtimeMemory: RuntimeMemoryController;
-        documents: DocumentManager;
-    };
-}
+type AgentRuntimeSource = MnemonAgentRuntimeSource;
 /** Root calls delegate to a bounded child; memory-worker calls reach the deterministic service. */
 export declare function registerTools(ctx: HostContextShape, serviceOrSource: MnemonService | AgentRuntimeSource, coordinator: MnemonSubagentCoordinator, runtimeMemory?: RuntimeMemoryController, documents?: DocumentManager): void;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-mnemon",
-  "version": "0.2.16",
-  "description": "Three-tier memory control plane for DeepSeek Harness: persistent runtime context, searchable project documents, pluggable long-term memory, smart routing, supervised agent workflows, WebUI, and headless tools.",
+  "version": "0.3.1",
+  "description": "Composable three-tier memory control plane for DeepSeek Harness: persistent runtime context, searchable project documents, pluggable long-term memory, guarded strategies, WebUI, and headless tools.",
   "keywords": [
     "deepseek-harness",
     "deepseek-harness-plugin",
@@ -51,16 +51,52 @@
   },
   "type": "module",
   "main": "lib/index.js",
-  "types": "lib/types/index.d.ts",
+  "types": "lib/types/src/index.d.ts",
   "exports": {
     ".": {
-      "types": "./lib/types/index.d.ts",
+      "types": "./lib/types/src/index.d.ts",
       "default": "./lib/index.js"
     },
     "./client": {
-      "types": "./lib/types/client/index.d.ts",
+      "types": "./lib/types/src/client/index.d.ts",
       "default": "./lib/client.js"
     },
+    "./contracts": {
+      "types": "./lib/types/packages/contracts/src/index.d.ts",
+      "default": "./lib/contracts.js"
+    },
+    "./kernel": {
+      "types": "./lib/types/packages/kernel/src/index.d.ts",
+      "default": "./lib/kernel.js"
+    },
+    "./extension-sdk": {
+      "types": "./lib/types/packages/extension-sdk/src/index.d.ts",
+      "default": "./lib/extension-sdk.js"
+    },
+    "./provider-sdk": {
+      "types": "./lib/types/src/provider-sdk.d.ts",
+      "default": "./lib/provider-sdk.js"
+    },
+    "./strategy-sdk": {
+      "types": "./lib/types/packages/strategy-sdk/src/index.d.ts",
+      "default": "./lib/strategy-sdk.js"
+    },
+    "./strategy-default-three-tier": {
+      "types": "./lib/types/packages/strategy-default-three-tier/src/index.d.ts",
+      "default": "./lib/strategy-default-three-tier.js"
+    },
+    "./layers/runtime": {
+      "types": "./lib/types/packages/layer-runtime/src/index.d.ts",
+      "default": "./lib/layers/runtime.js"
+    },
+    "./layers/documents": {
+      "types": "./lib/types/packages/layer-documents/src/index.d.ts",
+      "default": "./lib/layers/documents.js"
+    },
+    "./layers/memory-spaces": {
+      "types": "./lib/types/packages/layer-memory-spaces/src/index.d.ts",
+      "default": "./lib/layers/memory-spaces.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -96,7 +132,7 @@
     "test": "vitest run",
     "verify:build": "node scripts/verify-deterministic-build.mjs",
     "verify:headless": "node scripts/verify-headless-profile.mjs",
-    "verify:package": "node scripts/verify-package-contents.mjs && pnpm run lint:package",
+    "verify:package": "node scripts/verify-package-contents.mjs && node scripts/verify-public-entries.mjs && pnpm run lint:package",
     "verify": "pnpm run typecheck && pnpm run test && pnpm run verify:build && pnpm run verify:headless && pnpm run verify:package"
   },
   "dependencies": {

package/lib/types/guidance.d.ts

@@ -1,11 +0,0 @@
-import type { HostAgent, HostContextShape } from './contracts.ts';
-import type { ResolvedConfig } from './config.ts';
-import type { RuntimeMemoryController } from './runtime-memory.ts';
-export declare const GUIDANCE_SECTION_NAME = "mnemon:routing";
-export declare const RUNTIME_MEMORY_CONTEXT_NAME = "mnemon:runtime-memory";
-export declare const ROUTING_GUIDANCE = "Use memory only by need. For substantial project records, search active Mnemon Documents before deep recall. Call mnemon_recall when durable history may matter or an exact prior detail is missing; never infer a missing historical rule. New explicit reusable facts normally go to mnemon_runtime_memory. A write completes only with a tool receipt.";
-export declare function registerGuidance(ctx: HostContextShape, config?: Pick<ResolvedConfig, 'routingGuidance'>): void;
-/** Project the latest committed USER.md/MEMORY.md as DSH's durable runtime-context snapshot. */
-export declare function registerRuntimeMemoryContext(ctx: HostContextShape, runtimeMemory: RuntimeMemoryController): void;
-/** Shadow the global fallback with the current Agent workspace's hot memory. */
-export declare function registerAgentRuntimeMemoryContext(agent: HostAgent, runtimeMemory: () => RuntimeMemoryController): () => void;