dsh-mnemon 0.2.16 → 0.3.1

package/lib/types/packages/provider-sdk/src/index.d.ts

@@ -0,0 +1,19 @@
+import type { MemoryAdapterDescriptor } from '../../contracts/src/index.ts';
+export interface MemoryAdapterFactory<Id extends string, Context, Adapter extends {
+    readonly id: Id;
+}> {
+    readonly id: Id;
+    create(context: Context): Adapter;
+}
+/** Lifecycle-owned factory directory used by Provider plugins and the Host. */
+export declare class MemoryAdapterFactoryRegistry<Id extends string, Context, Adapter extends {
+    readonly id: Id;
+}> {
+    private readonly factories;
+    constructor(factories?: readonly MemoryAdapterFactory<Id, Context, Adapter>[]);
+    register(factory: MemoryAdapterFactory<Id, Context, Adapter>): () => void;
+    create(context: Context): Map<Id, Adapter>;
+    ids(): Id[];
+}
+export declare function defineMemoryAdapterDescriptor<T extends MemoryAdapterDescriptor>(descriptor: T): T;
+export type { MemoryAdapterDescriptor, MemoryAdapterLocality, MemoryAdapterScope, MemoryCapability, MemoryJsonValue, } from '../../contracts/src/index.ts';

package/lib/types/packages/strategy-default-three-tier/src/index.d.ts

@@ -0,0 +1,7 @@
+import type { MemoryCatalog, MemoryLayerRegistration, MemoryStrategyRegistration } from '../../kernel/src/index.ts';
+import type { MemoryLayerParticipation, MemoryTopologyDefinition } from '../../contracts/src/index.ts';
+export declare const BUILTIN_MEMORY_LAYERS: readonly [Readonly<import("../../contracts/src/index.ts").MemoryLayerDescriptor>, Readonly<import("../../contracts/src/index.ts").MemoryLayerDescriptor>, Readonly<import("../../contracts/src/index.ts").MemoryLayerDescriptor>];
+export declare const DEFAULT_LAYER_PARTICIPATION: Readonly<MemoryLayerParticipation>;
+export declare const DEFAULT_THREE_TIER_TOPOLOGY: Readonly<MemoryTopologyDefinition>;
+export declare const DEFAULT_THREE_TIER_STRATEGY: MemoryStrategyRegistration;
+export declare function registerDefaultMemorySystem(catalog: MemoryCatalog, layers?: Partial<Record<string, Omit<MemoryLayerRegistration, 'descriptor'>>>): () => void;

package/lib/types/packages/strategy-sdk/src/index.d.ts

@@ -0,0 +1,35 @@
+import type { MemoryPlanProposal, MemoryPlanRequest, MemorySystemDescriptor } from '../../contracts/src/index.ts';
+import type { MemoryStrategyRegistration } from '../../kernel/src/index.ts';
+export declare const MEMORY_STRATEGY_PLUGIN_API_VERSION: "dsh-mnemon/v1alpha1";
+export interface MemoryStrategyPluginManifest {
+    apiVersion: typeof MEMORY_STRATEGY_PLUGIN_API_VERSION;
+    kind: 'MemoryStrategyPlugin';
+    metadata: {
+        id: string;
+        version: string;
+        label: string;
+        description: string;
+    };
+    permissions: {
+        layerIds: string[];
+        adapterIds: string[];
+        capabilities: MemoryPlanRequest['capability'][];
+        maxSteps: number;
+    };
+}
+export interface MemoryStrategyPlugin {
+    manifest: MemoryStrategyPluginManifest;
+    strategy: MemoryStrategyRegistration;
+}
+/** Define an immutable, declarative strategy package; the Kernel remains authoritative. */
+export declare function defineMemoryStrategyPlugin(plugin: MemoryStrategyPlugin): Readonly<MemoryStrategyPlugin>;
+export interface MemoryStrategyReplayCase {
+    request: MemoryPlanRequest;
+    descriptor: MemorySystemDescriptor;
+    assert(proposal: MemoryPlanProposal): void | Promise<void>;
+}
+/** Deterministic replay primitive for generated and hand-written strategies. */
+export declare function replayMemoryStrategy(strategy: MemoryStrategyRegistration, cases: readonly MemoryStrategyReplayCase[]): Promise<void>;
+export declare function defineMemoryStrategy<T extends MemoryStrategyRegistration>(strategy: T): T;
+export type { MemoryPlanProposal, MemoryPlanRequest, MemoryStrategyDescriptor, MemoryStrategyHook, MemorySystemDescriptor, } from '../../contracts/src/index.ts';
+export type { MemoryStrategyContext, MemoryStrategyRegistration } from '../../kernel/src/index.ts';

package/lib/types/{client → src/client}/api.d.ts

@@ -1,4 +1,4 @@
-import { type AssistantMessageText, type CreateMemoryBodyRequest, type ClientConnectionHandle, type DocumentMutation, type DocumentMutationResult, type DocumentSearchResult, type DocumentSnapshot, type DocumentView, type EntityView, type Insight, type MemoryBody, type MemoryBodyView, type MemoryBodyMetadataMaintenanceResult, type MemoryBodyCatalog, type MemoryProviderServiceCatalog, type MemoryProviderServiceView, type MemoryGraphSnapshot, type MemoryListRequest, type MemoryListView, type MemoryReadSource, type MnemonPackExport, type MnemonPackImportResult, type MnemonPackPreview, type RememberRequest, type RuntimeMemoryImportance, type RuntimeMemoryMutationResult, type RuntimeMemorySnapshot, type RuntimeMemoryTarget, type SearchRequest, type StatusView, type TaskAgentModelCatalog, type TurnMemoryActivity, type UpdateMemoryBodyRequest, type UpdateMemoryProviderServiceRequest, type VersionComponentId, type VersionStatus, type VersionUpdateResult } from '../shared/contracts.ts';
+import { type AssistantMessageText, type CreateMemoryBodyRequest, type ClientConnectionHandle, type DocumentMutation, type DocumentMutationResult, type DocumentSearchResult, type DocumentSnapshot, type DocumentView, type EntityView, type Insight, type MemoryBody, type MemoryBodyView, type MemoryBodyMetadataMaintenanceResult, type MemoryBodyCatalog, type MemoryProviderServiceCatalog, type MemoryProviderServiceView, type MemoryGraphSnapshot, type MemoryListRequest, type MemoryListView, type MemorySystemDescriptor, type MemoryReadSource, type MnemonPackExport, type MnemonPackImportResult, type MnemonPackPreview, type RememberRequest, type RuntimeMemoryImportance, type RuntimeMemoryMutationResult, type RuntimeMemorySnapshot, type RuntimeMemoryTarget, type SearchRequest, type StatusView, type TaskAgentModelCatalog, type TurnMemoryActivity, type UpdateMemoryBodyRequest, type UpdateMemoryProviderServiceRequest, type VersionComponentId, type VersionStatus, type VersionUpdateResult } from '../shared/contracts.ts';
 export interface SearchResponse {
     query: string;
     mode: string;
@@ -24,6 +24,7 @@ export declare class MnemonClient {
     private scoped;
     status(): Promise<StatusView>;
     statusSummary(): Promise<StatusView>;
+    memorySystem(): Promise<MemorySystemDescriptor>;
     taskAgentModels(includeCatalog?: boolean): Promise<TaskAgentModelCatalog>;
     versions(): Promise<VersionStatus>;
     updateVersion(component: VersionComponentId): Promise<VersionUpdateResult>;

package/lib/types/{client → src/client}/locales.d.ts

@@ -485,7 +485,9 @@ export declare const zh: {
     'entities.action': string;
     'entities.top': string;
     'entities.frequency': string;
+    'entities.filterHint': string;
     'entities.emptyRail': string;
+    'entities.filterEmpty': string;
     'entities.loading': string;
     'entities.selectTitle': string;
     'entities.selectText': string;
@@ -704,6 +706,23 @@ export declare const zh: {
     'config.customHintShort': string;
     'config.customSelected': string;
     'config.globalScopeHint': string;
+    'config.topologyTitle': string;
+    'config.topologyDescription': string;
+    'config.topologyLoading': string;
+    'config.topologyUnavailable': string;
+    'config.topologyEnabled': string;
+    'config.topologyDisabled': string;
+    'config.topologyLayerToggle': string;
+    'layers.runtimeLabel': string;
+    'layers.runtimeDescription': string;
+    'layers.documentsLabel': string;
+    'layers.documentsDescription': string;
+    'layers.memorySpacesLabel': string;
+    'layers.memorySpacesDescription': string;
+    'layers.disabledBadge': string;
+    'layers.disabledTitle': string;
+    'layers.disabledDescription': string;
+    'layers.disabledText': string;
     'config.providersTitle': string;
     'config.providersDescription': string;
     'config.nativeSummary': string;
@@ -1344,7 +1363,9 @@ export declare const en: {
     'entities.action': string;
     'entities.top': string;
     'entities.frequency': string;
+    'entities.filterHint': string;
     'entities.emptyRail': string;
+    'entities.filterEmpty': string;
     'entities.loading': string;
     'entities.selectTitle': string;
     'entities.selectText': string;
@@ -1563,6 +1584,23 @@ export declare const en: {
     'config.customHintShort': string;
     'config.customSelected': string;
     'config.globalScopeHint': string;
+    'config.topologyTitle': string;
+    'config.topologyDescription': string;
+    'config.topologyLoading': string;
+    'config.topologyUnavailable': string;
+    'config.topologyEnabled': string;
+    'config.topologyDisabled': string;
+    'config.topologyLayerToggle': string;
+    'layers.runtimeLabel': string;
+    'layers.runtimeDescription': string;
+    'layers.documentsLabel': string;
+    'layers.documentsDescription': string;
+    'layers.memorySpacesLabel': string;
+    'layers.memorySpacesDescription': string;
+    'layers.disabledBadge': string;
+    'layers.disabledTitle': string;
+    'layers.disabledDescription': string;
+    'layers.disabledText': string;
     'config.providersTitle': string;
     'config.providersDescription': string;
     'config.nativeSummary': string;

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

@@ -145,6 +145,7 @@ export interface HostAgent {
     session: {
         header?: {
             origin?: 'subagent';
+            parentSession?: string;
             delegationDepth?: number;
             cwd?: string;
             agentPreset?: string;
@@ -266,6 +267,8 @@ export interface HostContextShape {
     /** Web workbench catalog; Agent execution routes by session cwd without it. */
     workspaceRegistry?: HostWorkspaceRegistry;
     get(name: string): unknown;
+    /** Cordis service publication; optional only for narrow test/headless shims. */
+    provide?(name: string, value?: unknown, check?: () => boolean): unknown;
     inject(services: string[], callback: (ctx: HostContextShape) => void): unknown;
     on(name: string, listener: (...args: never[]) => unknown): () => unknown;
     effect(callback: () => (() => unknown) | void, label?: string): () => unknown;

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

@@ -1,5 +1,7 @@
 import type { HostAgent } from './contracts.ts';
 import type { DocumentMutation, DocumentMutationResult, DocumentRecord, DocumentSearchResult, DocumentSnapshot, DocumentView } from './shared/contracts.ts';
+import type { AuthorityCommitRecorder } from './memory-receipts.ts';
+import type { MemoryMigrationLineage } from '../packages/contracts/src/index.ts';
 export type { DocumentMutation, DocumentMutationResult, DocumentRecord, DocumentSearchResult, DocumentSnapshot, DocumentStatus, DocumentView } from './shared/contracts.ts';
 export declare const DOCUMENTS_VERSION = 1;
 export declare const DOCUMENTS_ACTIVE_LIMIT_BYTES: number;
@@ -22,6 +24,7 @@ export declare class DocumentConflictError extends Error {
 export declare class DocumentController {
     readonly limitBytes: number;
     private readonly now;
+    private readonly recordCommit?;
     readonly workspaceRoot: string;
     readonly storageRoot: string;
     readonly directory: string;
@@ -31,7 +34,7 @@ export declare class DocumentController {
     readonly lockPath: string;
     private readonly managedRelativePrefix;
     private queue;
-    constructor(workspaceRoot: string, limitBytes?: number, now?: () => Date, storageRoot?: string);
+    constructor(workspaceRoot: string, limitBytes?: number, now?: () => Date, storageRoot?: string, recordCommit?: AuthorityCommitRecorder | undefined);
     snapshot(): DocumentSnapshot;
     get(id: string): DocumentView;
     capacityPlan(request: DocumentMutation): DocumentCapacityPlan;
@@ -43,6 +46,7 @@ export declare class DocumentController {
     archive(id: string, expectedRevision: number, details: {
         summary: string;
         memoryBodyIds: string[];
+        lineage?: readonly MemoryMigrationLineage[];
     }): Promise<DocumentMutationResult>;
     private mutateLocked;
     private initialize;
@@ -65,8 +69,9 @@ export declare class DocumentManager {
     private readonly limitBytes;
     private readonly now;
     private readonly storageRoot?;
+    private readonly recordCommit?;
     private readonly controllers;
-    constructor(limitBytes?: number, now?: () => Date, storageRoot?: (() => string) | undefined);
+    constructor(limitBytes?: number, now?: () => Date, storageRoot?: (() => string) | undefined, recordCommit?: AuthorityCommitRecorder | undefined);
     forWorkspace(workspaceRoot: string): DocumentController;
     forAgent(agent: HostAgent): DocumentController;
 }

package/lib/types/src/guidance.d.ts

@@ -0,0 +1,23 @@
+import type { HostAgent, HostContextShape } from './contracts.ts';
+import type { ResolvedConfig } from './config.ts';
+import type { RuntimeMemoryController } from './runtime-memory.ts';
+import type { MemoryWake } from '../packages/contracts/src/index.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 when needed. Search Mnemon Documents for substantial project records. Call mnemon_recall for durable history or exact prior details; never infer a missing historical rule. Put only new user facts or explicit save/correction requests in mnemon_runtime_memory; never cache retrieved evidence. A write exists only after its receipt.";
+/** Replace the already-materialized Agent context with the Wake pinned during assembly. */
+export declare function applyAgentMemoryViewWake<T extends {
+    contexts: Array<{
+        name: string;
+        text: string;
+    }>;
+}>(assembly: T, wake: MemoryWake | undefined): T;
+/** Register the non-recursive escape used by both legacy Runtime and View Wake contexts. */
+export declare function registerMemoryPromptInterpolation(ctx: HostContextShape): void;
+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, enabled?: () => boolean): void;
+/** Shadow the global fallback with the current Agent workspace's hot memory. */
+export declare function registerAgentRuntimeMemoryContext(agent: HostAgent, runtimeMemory: () => RuntimeMemoryController, enabled?: () => boolean): () => void;
+/** Project only the immutable Wake pinned by the root Agent lifecycle. */
+export declare function registerAgentMemoryViewContext(agent: HostAgent, wake: () => MemoryWake | undefined): () => void;

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

@@ -9,11 +9,13 @@ import { MnemonSubagentCoordinator } from './subagent.ts';
 import { StorageScopeInspector } from './storage-scope.ts';
 import { MnemonPackManager } from './pack.ts';
 import { VersionUpdateManager } from './version-updates.ts';
+import { MemoryBoot, MemoryExtensionHost } from '../packages/extension-sdk/src/index.ts';
 export { BALANCED_RECALL_QUALITY_POLICY, EXHAUSTIVE_RECALL_QUALITY_POLICY, RecallQualityPolicyRegistry, STRICT_RECALL_QUALITY_POLICY, recallQualityPolicies, registerRecallQualityPolicy, } from './recall-quality/index.ts';
 export type { RecallQualityCandidate, RecallQualityDecision, RecallQualityPolicy, RecallQualityPolicyContext, } from './recall-quality/index.ts';
 export declare const name = "dsh-mnemon";
+export declare const provide: string[];
 export declare const inject: string[];
-export { Config, InteractionConfig, resolveConfig, resolveInteractionConfig, DocumentManager, LiveMnemonRuntime, MnemonLifecycle, MnemonService, MnemonSubagentCoordinator, RuntimeMemoryController, StorageScopeInspector, MnemonPackManager, VersionUpdateManager, createRunner, createRuntimeGraph };
+export { Config, InteractionConfig, resolveConfig, resolveInteractionConfig, DocumentManager, LiveMnemonRuntime, MemoryBoot, MemoryExtensionHost, MnemonLifecycle, MnemonService, MnemonSubagentCoordinator, RuntimeMemoryController, StorageScopeInspector, MnemonPackManager, VersionUpdateManager, createRunner, createRuntimeGraph };
 export type { MnemonConfig };
 /** Mount native model tools on every DSH surface and UI RPC only when Web connection exists. */
 export declare function apply(rawContext: unknown, config?: MnemonConfig): void;

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

@@ -1,18 +1,14 @@
 import type { ResolvedConfig } from './config.ts';
-import type { HostAgent, HostContextShape } from './contracts.ts';
+import type { HostContextShape } from './contracts.ts';
 import type { Insight, RememberRequest, SearchRequest } from './service.ts';
 import type { RuntimeMemoryMutation } from './runtime-memory.ts';
 import type { DocumentMutation } from './documents.ts';
 import { MnemonSubagentCoordinator, type DelegatedWriteResult } from './subagent.ts';
 import { type TurnMemoryActivitySnapshot } from './activity.ts';
-import type { RuntimeMemoryController } from './runtime-memory.ts';
 import type { AssistantMessageText, LifecycleSnapshot, TaskAgentModelCatalog } from './shared/contracts.ts';
 import type { PreparedMemoryPlacement } from './provider-placement.ts';
-interface AgentRuntimeSource {
-    forAgent(agent: HostAgent): {
-        runtimeMemory: RuntimeMemoryController;
-    };
-}
+import type { MnemonAgentRuntimeSource } from './live-runtime.ts';
+type AgentRuntimeSource = Pick<MnemonAgentRuntimeSource, 'forAgent' | 'bindAgentRuntime'>;
 export type { TurnMemoryActivity, TurnMemoryActivitySnapshot } from './activity.ts';
 export type { AssistantMessageText, LifecycleAgentSnapshot, LifecycleCounters, LifecyclePhase, LifecycleSnapshot } from './shared/contracts.ts';
 export declare const MNEMON_PLUGIN_SOURCE = "dsh-mnemon";
@@ -42,8 +38,8 @@ export declare class MnemonLifecycle {
     turnActivities(sessionId: string): TurnMemoryActivitySnapshot;
     /** Plain text of one finalized assistant message, resolved per session; null while absent. */
     assistantMessage(sessionId: string, messageId: string): AssistantMessageText | null;
-    recall(sessionId: string, request: SearchRequest, signal?: AbortSignal): Promise<import("./subagent.ts").DelegatedRecallResult>;
-    related(sessionId: string, id: string, memoryBodyId?: string, signal?: AbortSignal): Promise<import("./subagent.ts").DelegatedRecallResult>;
+    recall(sessionId: string, request: SearchRequest, signal?: AbortSignal): Promise<import("./subagent.ts").RecallResult>;
+    related(sessionId: string, id: string, memoryBodyId?: string, signal?: AbortSignal): Promise<import("./subagent.ts").RecallResult>;
     answer(sessionId: string, query: string, evidence: Insight[], signal?: AbortSignal): Promise<import("./subagent.ts").DelegatedAnswerResult>;
     /** Synthesize a Web Agent Query without borrowing a conversation Agent or its history. */
     answerTask(sessionId: string, query: string, evidence: Insight[], workspaceRoot?: string, signal?: AbortSignal): Promise<import("./subagent.ts").DelegatedAnswerResult>;

package/lib/types/{live-runtime.d.ts → src/live-runtime.d.ts}

@@ -6,6 +6,11 @@ import { type MnemonRunner } from './runner.ts';
 import { RuntimeMemoryController } from './runtime-memory.ts';
 import { MnemonService } from './service.ts';
 import { StorageScopeInspector } from './storage-scope.ts';
+import { MemoryCatalog } from './memory-system/catalog.ts';
+import { MemoryKernel } from './memory-system/kernel.ts';
+import { MemoryTopologyManager } from './memory-system/topology.ts';
+import type { MemoryBoot } from '../packages/extension-sdk/src/index.ts';
+import type { MemoryTurnViewManager } from '../packages/kernel/src/index.ts';
 export interface MnemonRuntimeGraph {
     config: ResolvedConfig;
     runner: MnemonRunner;
@@ -14,24 +19,39 @@ export interface MnemonRuntimeGraph {
     documents: DocumentManager;
     storage: StorageScopeInspector;
     packs: MnemonPackManager;
+    memoryCatalog: MemoryCatalog;
+    memoryTopology: MemoryTopologyManager;
+    memoryKernel: MemoryKernel;
+    memoryViews: MemoryTurnViewManager;
+    /** Detach this generation from future Host-global extension changes. */
+    dispose(): void;
+}
+export interface MnemonAgentRuntimeSource {
+    readonly config: ResolvedConfig;
+    forAgent(agent: HostAgent): MnemonRuntimeGraph;
+    /** Pin every tool in one Agent turn to the same immutable runtime generation. */
+    bindAgentRuntime(agentId: string, graph: MnemonRuntimeGraph): () => void;
 }
 /**
  * Build a complete generation before it can become visible. Constructors also
  * validate and initialize the selected storage root, so a failed candidate is
  * rejected by DSH settings validation without disturbing the active graph.
  */
-export declare function createRuntimeGraph(config: ResolvedConfig, workspaceRoot?: string): MnemonRuntimeGraph;
+export declare function createRuntimeGraph(config: ResolvedConfig, workspaceRoot?: string, extensions?: MemoryBoot): MnemonRuntimeGraph;
 /**
  * Stable faces handed to DSH registrations. `swap` is synchronous and contains
  * no user code, so all faces move to the same prevalidated generation in one
  * JavaScript turn. A method obtained before the swap stays bound to its old
  * generation until that invocation settles.
  */
-export declare class LiveMnemonRuntime {
+export declare class LiveMnemonRuntime implements MnemonAgentRuntimeSource {
     private readonly workspaceRegistry?;
     private readonly agents?;
+    private readonly extensions?;
     private current;
     private readonly workspaceGraphs;
+    private readonly agentGraphs;
+    private closed;
     readonly config: ResolvedConfig;
     readonly runner: MnemonRunner;
     readonly service: MnemonService;
@@ -39,9 +59,15 @@ export declare class LiveMnemonRuntime {
     readonly documents: DocumentManager;
     readonly storage: StorageScopeInspector;
     readonly packs: MnemonPackManager;
-    constructor(initial: MnemonRuntimeGraph, workspaceRegistry?: HostWorkspaceRegistry | undefined, agents?: HostAgentsService | undefined);
+    readonly memoryCatalog: MemoryCatalog;
+    readonly memoryTopology: MemoryTopologyManager;
+    readonly memoryKernel: MemoryKernel;
+    readonly memoryViews: MemoryTurnViewManager;
+    constructor(initial: MnemonRuntimeGraph, workspaceRegistry?: HostWorkspaceRegistry | undefined, agents?: HostAgentsService | undefined, extensions?: MemoryBoot | undefined);
     swap(next: MnemonRuntimeGraph): void;
     snapshot(): MnemonRuntimeGraph;
+    bindAgentRuntime(agentId: string, graph: MnemonRuntimeGraph): () => void;
+    dispose(): void;
     /** Resolve the runtime that must serve one Agent execution. */
     forAgent(agent: HostAgent): MnemonRuntimeGraph;
     /** Resolve an authorized DSH workspace selected by the Web workbench. */
@@ -59,6 +85,7 @@ export declare class LiveMnemonRuntime {
         aligned: boolean;
     };
     private forWorkspacePath;
+    private assertOpen;
     private agent;
     private requireWorkspace;
     private workspaceForPath;

package/lib/types/{memory-bodies.d.ts → src/memory-bodies.d.ts}

@@ -43,11 +43,14 @@ export declare class MemoryBodyRegistry {
     updateMetadata(updates: readonly MemoryBodyMetadataUpdate[]): MemoryBody[];
     remove(id: string, signal?: AbortSignal): Promise<MemoryBody>;
     setActive(id: string, active: boolean): MemoryBody;
+    /** Advance the safe catalog checkpoint after provider-backed content changes. */
+    touch(id: string): MemoryBody;
     /** Refresh metadata after an atomic Pack import replaced the data component. */
     reload(): void;
     private loadAndReconcile;
     private reconcileDiscoveredStores;
     private nativeStoreIds;
+    private nextTimestamp;
     private view;
     private save;
     private writeRegistry;

package/lib/types/src/memory-receipts.d.ts

@@ -0,0 +1,21 @@
+import type { MemoryCapability, MemoryJsonValue, MemoryReceipt } from '../packages/contracts/src/index.ts';
+import type { MemoryKernel, MemoryReceiptSink } from '../packages/kernel/src/index.ts';
+import type { MemoryTurnViewManager } from '../packages/kernel/src/index.ts';
+export interface CommittedAuthorityOperation {
+    layerId: string;
+    capability: MemoryCapability;
+    operation: string;
+    adapterId?: string;
+    checkpoint?: MemoryJsonValue;
+}
+export type AuthorityCommitRecorder = (operation: CommittedAuthorityOperation) => MemoryReceipt;
+/** Converts already-committed compatibility-controller writes into the one receipt contract. */
+export declare class MemoryReceiptBridge implements MemoryReceiptSink {
+    private readonly kernel;
+    private readonly views;
+    private readonly now;
+    private readonly id;
+    constructor(kernel: Pick<MemoryKernel, 'descriptor' | 'guardGeneration'>, views: Pick<MemoryTurnViewManager, 'apply'>, now?: () => Date, id?: () => string);
+    append(receipt: MemoryReceipt): void;
+    record(operation: CommittedAuthorityOperation): MemoryReceipt;
+}

package/lib/types/src/memory-system/access.d.ts

@@ -0,0 +1,2 @@
+/** @deprecated Internal compatibility facade. Import from `dsh-mnemon/kernel`. */
+export * from '../../packages/kernel/src/access.ts';

package/lib/types/src/memory-system/catalog.d.ts

@@ -0,0 +1,2 @@
+/** @deprecated Internal compatibility facade. Import from `dsh-mnemon/kernel`. */
+export * from '../../packages/kernel/src/catalog.ts';

package/lib/types/src/memory-system/contracts.d.ts

@@ -0,0 +1,2 @@
+/** @deprecated Internal compatibility facade. Import public contracts from `dsh-mnemon/contracts`. */
+export * from '../../packages/contracts/src/index.ts';

package/lib/types/src/memory-system/defaults.d.ts

@@ -0,0 +1,6 @@
+/** @deprecated Internal compatibility facade. Import from `dsh-mnemon/strategy-default-three-tier`. */
+export * from '../../packages/layer-runtime/src/index.ts';
+export * from '../../packages/layer-documents/src/index.ts';
+export * from '../../packages/layer-memory-spaces/src/index.ts';
+export * from '../../packages/strategy-default-three-tier/src/index.ts';
+export { participationChannel } from '../../packages/kernel/src/index.ts';

package/lib/types/src/memory-system/index.d.ts

@@ -0,0 +1,7 @@
+export * from './contracts.ts';
+export * from './catalog.ts';
+export * from './topology.ts';
+export * from './defaults.ts';
+export * from './access.ts';
+export * from './kernel.ts';
+export * from './view.ts';

package/lib/types/src/memory-system/kernel.d.ts

@@ -0,0 +1,2 @@
+/** @deprecated Internal compatibility facade. Import from `dsh-mnemon/kernel`. */
+export * from '../../packages/kernel/src/kernel.ts';

package/lib/types/src/memory-system/topology.d.ts

@@ -0,0 +1,2 @@
+/** @deprecated Internal compatibility facade. Import from `dsh-mnemon/kernel`. */
+export * from '../../packages/kernel/src/topology.ts';

package/lib/types/src/memory-system/view.d.ts

@@ -0,0 +1,2 @@
+/** @deprecated Internal compatibility facade. Import from `dsh-mnemon/kernel`. */
+export * from '../../packages/kernel/src/view.ts';

package/lib/types/src/memory-view.d.ts

@@ -0,0 +1,15 @@
+import { MemoryTurnViewManager } from '../packages/kernel/src/index.ts';
+import type { DocumentManager } from './documents.ts';
+import type { MemoryKernel } from './memory-system/kernel.ts';
+import type { RuntimeMemoryController } from './runtime-memory.ts';
+import type { MnemonService } from './service.ts';
+export interface DefaultMemorySources {
+    runtimeMemory: RuntimeMemoryController;
+    documents: DocumentManager;
+    service: MnemonService;
+}
+/** Compatibility name for the v0.3 pre-release API. */
+export type DefaultMemoryViewSources = DefaultMemorySources;
+export declare function createDefaultMemoryTurnViewManager(kernel: MemoryKernel, sources: DefaultMemorySources): MemoryTurnViewManager;
+/** Compatibility name for the v0.3 pre-release API. */
+export declare const createDefaultMemoryViewManager: typeof createDefaultMemoryTurnViewManager;

package/lib/types/src/provider-sdk.d.ts

@@ -0,0 +1,4 @@
+export * from '../packages/provider-sdk/src/index.ts';
+export { MemoryProviderAdapterRegistry, createBuiltinMemoryProviderAdapterRegistry, memoryProviderAdapterFactories, registerMemoryProviderAdapterFactory, } from './providers/registry.ts';
+export type { MemoryProviderAdapterFactory, MemoryProviderAdapterFactoryContext } from './providers/registry.ts';
+export type { MemoryProviderAdapter, ProviderBodyStatus, ProviderMemorySpace, ProviderScoreSemantics, ProviderSearchResult, } from './providers/provider.ts';

package/lib/types/src/providers/memory-system.d.ts

@@ -0,0 +1,6 @@
+import type { MemoryCatalog } from '../memory-system/catalog.ts';
+import type { MemoryAdapterDescriptor, MemoryCapability } from '../memory-system/contracts.ts';
+import type { MemoryProviderDescriptor } from '../shared/contracts.ts';
+export declare function providerMemoryCapabilities(provider: MemoryProviderDescriptor): MemoryCapability[];
+export declare function providerMemoryAdapterDescriptor(provider: MemoryProviderDescriptor): MemoryAdapterDescriptor;
+export declare function registerBuiltinMemoryAdapters(catalog: MemoryCatalog): () => void;

package/lib/types/src/providers/registry.d.ts

@@ -0,0 +1,23 @@
+import type { ResolvedConfig } from '../config.ts';
+import type { MemoryBodyRegistry } from '../memory-bodies.ts';
+import type { MemoryProviderAdapter } from './provider.ts';
+import { MemoryAdapterFactoryRegistry, type MemoryAdapterFactory } from '../../packages/provider-sdk/src/index.ts';
+export interface MemoryProviderAdapterFactoryContext {
+    memoryBodies: MemoryBodyRegistry;
+    config: Pick<ResolvedConfig, 'timeoutMs'>;
+    nativeAdapter: MemoryProviderAdapter;
+}
+export interface MemoryProviderAdapterFactory extends MemoryAdapterFactory<MemoryProviderAdapter['id'], MemoryProviderAdapterFactoryContext, MemoryProviderAdapter> {
+}
+/**
+ * Runtime adapter factory seam. The control plane owns registration and
+ * provider implementations own construction; MnemonService depends only on
+ * the resulting adapter contract.
+ */
+export declare class MemoryProviderAdapterRegistry extends MemoryAdapterFactoryRegistry<MemoryProviderAdapter['id'], MemoryProviderAdapterFactoryContext, MemoryProviderAdapter> {
+}
+export declare const BUILTIN_MEMORY_PROVIDER_ADAPTER_FACTORIES: readonly MemoryProviderAdapterFactory[];
+export declare function createBuiltinMemoryProviderAdapterRegistry(): MemoryProviderAdapterRegistry;
+/** Global extension registry sampled when a runtime generation is constructed. */
+export declare const memoryProviderAdapterFactories: MemoryProviderAdapterRegistry;
+export declare function registerMemoryProviderAdapterFactory(factory: MemoryProviderAdapterFactory): () => void;

package/lib/types/{runtime-memory.d.ts → src/runtime-memory.d.ts}

@@ -1,4 +1,6 @@
 import type { MnemonRunner } from './runner.ts';
+import type { AuthorityCommitRecorder } from './memory-receipts.ts';
+import type { MemoryMigrationLineage } from '../packages/contracts/src/index.ts';
 import type { RuntimeMemoryAction, RuntimeMemoryCompactedEntry, RuntimeMemoryEntry, RuntimeMemoryMutation, RuntimeMemoryMutationResult, RuntimeMemorySnapshot, RuntimeMemoryTarget } from './shared/contracts.ts';
 export type { RuntimeMemoryAction, RuntimeMemoryCompactedEntry, RuntimeMemoryEntry, RuntimeMemoryImportance, RuntimeMemoryMutation, RuntimeMemoryMutationResult, RuntimeMemorySnapshot, RuntimeMemoryTarget, RuntimeMemoryTargetView, RuntimeMemoryUsage, } from './shared/contracts.ts';
 export declare const RUNTIME_MEMORY_VERSION = 1;
@@ -7,7 +9,11 @@ export declare const RUNTIME_MEMORY_LIMITS: {
     readonly memory: number;
     readonly user: number;
 };
-/** Host-only plan for capacity maintenance; this is not a Tool or RPC action. */
+export interface RuntimeMemoryContextProjection {
+    revision: string;
+    text: string;
+}
+/** Host-only plan for capacity maintenance; this is not exposed as a Tool or RPC action. */
 export interface RuntimeMemoryMaintenancePlan {
     revision: string;
     action: RuntimeMemoryAction;
@@ -36,22 +42,25 @@ export declare class RuntimeMemoryConflictError extends Error {
  */
 export declare class RuntimeMemoryController {
     private readonly now;
+    private readonly recordCommit?;
     readonly directory: string;
     readonly sourcePath: string;
     readonly memoryPath: string;
     readonly userPath: string;
     readonly lockPath: string;
     private queue;
-    constructor(runner: Pick<MnemonRunner, 'effectiveDataDir'>, now?: () => Date);
+    constructor(runner: Pick<MnemonRunner, 'effectiveDataDir'>, now?: () => Date, recordCommit?: AuthorityCommitRecorder | undefined);
     snapshot(): RuntimeMemorySnapshot;
     contextText(): string;
+    /** Read the exact Runtime revision and its prompt projection under one lock. */
+    contextProjection(): RuntimeMemoryContextProjection;
     mutate(request: RuntimeMemoryMutation): Promise<RuntimeMemoryMutationResult>;
     /** Resolve exactly which committed entries survive a blocked mutation and are safe to compact. */
     planMaintenance(request: RuntimeMemoryMutation): Promise<RuntimeMemoryMaintenancePlan>;
-    /** Commit LLM compaction and the original mutation together, or leave every local file unchanged. */
-    compactAndMutate(expectedRevision: string, request: RuntimeMemoryMutation, compacted: RuntimeMemoryCompactedEntry[], maxCompactedBytes?: number): Promise<RuntimeMemoryMutationResult>;
+    /** Commit semantic compaction and the original mutation together, or leave every local file unchanged. */
+    compactAndMutate(expectedRevision: string, request: RuntimeMemoryMutation, compacted: RuntimeMemoryCompactedEntry[], maxCompactedBytes?: number, lineage?: readonly MemoryMigrationLineage[]): Promise<RuntimeMemoryMutationResult>;
     /** Apply an LLM-produced compaction only to the exact snapshot it reviewed. */
-    compactTarget(expectedRevision: string, target: RuntimeMemoryTarget, compacted: RuntimeMemoryCompactedEntry[], maxBytes?: number): Promise<RuntimeMemorySnapshot>;
+    compactTarget(expectedRevision: string, target: RuntimeMemoryTarget, compacted: RuntimeMemoryCompactedEntry[], maxBytes?: number, lineage?: readonly MemoryMigrationLineage[]): Promise<RuntimeMemorySnapshot>;
     private initialize;
     private mutateLocked;
     private result;

package/lib/types/src/search-tokens.d.ts

@@ -0,0 +1,5 @@
+/** Small deterministic tokenizer shared by local Document and Native recovery. */
+export declare function lexicalSearchTokens(value: string, maximum?: number): string[];
+export declare function lexicalTokenMatchCount(value: string, tokens: readonly string[]): number;
+/** Require broader coverage only after a query is focused enough to support it. */
+export declare function lexicalRequiredMatchCount(tokens: readonly string[]): number;

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

@@ -2,7 +2,9 @@ import type { JsonValue } from './contracts.ts';
 import type { ResolvedConfig } from './config.ts';
 import { MemoryBodyRegistry, type CreateMemoryBodyRequest, type MemoryBody, type UpdateMemoryBodyRequest } from './memory-bodies.ts';
 import type { MnemonRunner } from './runner.ts';
+import type { AuthorityCommitRecorder } from './memory-receipts.ts';
 import { type LlmMemoryPlacementSelection, type PreparedMemoryPlacement } from './provider-placement.ts';
+import { type MemoryProviderAdapterRegistry } from './providers/registry.ts';
 import { type RecallQualityPolicyRegistry } from './recall-quality/index.ts';
 import { type EdgeType, type EntityView, type Insight, type MemoryBodyCatalog, type MemoryBodyMetadataUpdate, type MemoryBodyView, type MemoryGraphSnapshot, type MemoryListRequest, type MemoryListView, type MemoryPlacementDecision, type MemoryReadSource, type RememberRequest, type SearchRequest, type StatusView } from './shared/contracts.ts';
 export { CATEGORIES, EDGE_TYPES, INTENTS, SOURCES } from './shared/contracts.ts';
@@ -18,19 +20,24 @@ export interface MemoryBodyMetadataSample {
 }
 /** Parse the official Mnemon vis.js export without executing its HTML or loading its CDN script. */
 export declare function parseMemoryGraph(html: string, now?: Date): MemoryGraphSnapshot;
+/** A provider mutation is authoritative only after it reports an explicit durable terminal state. */
+export declare function mutationResultCommitted(result: unknown): boolean;
 export declare class MnemonService {
     readonly runner: MnemonRunner;
     readonly config: ResolvedConfig;
+    private readonly recordCommit?;
     readonly memoryBodies: MemoryBodyRegistry;
     private readonly providers;
     private readonly recallQualityPolicy;
     private bodiesInFlight;
-    constructor(runner: MnemonRunner, config: ResolvedConfig, memoryBodies?: MemoryBodyRegistry, recallQualityPolicyRegistry?: RecallQualityPolicyRegistry);
+    constructor(runner: MnemonRunner, config: ResolvedConfig, memoryBodies?: MemoryBodyRegistry, recallQualityPolicyRegistry?: RecallQualityPolicyRegistry, providerAdapterRegistry?: MemoryProviderAdapterRegistry, recordCommit?: AuthorityCommitRecorder | undefined);
     bodies(signal?: AbortSignal): Promise<MemoryBodyCatalog>;
     /** Coalesce simultaneous Status/Memory-page probes without caching mutations. */
     private collectBodies;
     /** Return the control-plane directory without waiting for provider I/O. */
     bodyDirectory(): MemoryBodyCatalog;
+    /** Stable, secret-free checkpoint for the projected Memory Space authority. */
+    memoryRevision(): string;
     /** Return a usable system snapshot without waiting for any Provider I/O. */
     statusSummary(): StatusView;
     status(signal?: AbortSignal): Promise<StatusView>;
@@ -91,5 +98,6 @@ export declare class MnemonService {
     private annotate;
     private annotateResult;
     private activateAfterWrite;
+    private recordMemoryCommit;
     private assertWritable;
 }