dsh-mnemon 0.1.6 → 0.2.0

package/lib/types/client/settings.d.ts

@@ -2,10 +2,11 @@ import { type ClientConnectionHandle, type ClientSettingsScope, type ClientSetti
 export declare class MnemonSettingsScope<T extends object> implements ClientSettingsScope<T> {
     private readonly connection;
     private readonly namespace;
+    private readonly requestTimeoutMs;
     private snapshot;
     private readonly listeners;
     private tail;
-    constructor(connection: ClientConnectionHandle, namespace?: string);
+    constructor(connection: ClientConnectionHandle, namespace?: string, requestTimeoutMs?: number);
     getSnapshot: () => ClientSettingsSnapshot<T>;
     subscribe: (listener: () => void) => (() => void);
     set(field: string, value: unknown): Promise<void>;
@@ -17,5 +18,6 @@ export declare class MnemonSettingsScope<T extends object> implements ClientSett
     mutate(ops: SettingsOperation[]): Promise<void>;
     private load;
     private write;
+    private call;
     private publish;
 }

package/lib/types/contracts.d.ts

@@ -117,6 +117,7 @@ export interface HostAgent {
             origin?: 'subagent';
             delegationDepth?: number;
             cwd?: string;
+            agentPreset?: string;
         };
         events: readonly HostSessionEvent[];
     };
@@ -125,9 +126,29 @@ export interface HostAgent {
     steer(message: HostUserMessage): void;
     inject(message: HostUserMessage): void;
 }
+export interface HostAgentHandle {
+    agent: HostAgent;
+    dispose(): Promise<void>;
+}
+export interface CreateHostAgentOptions {
+    sessionId: string;
+    meta?: {
+        cwd?: string;
+        agentPreset?: string;
+    };
+    agentOptions?: {
+        provider?: string;
+        model?: string;
+        maxTokens?: number;
+    };
+    signal?: AbortSignal;
+    setup?: (agentCtx: HostAgentContext) => unknown | Promise<unknown>;
+}
 export interface HostAgentsService {
     get(id: string): HostAgent | undefined;
     roots(): HostAgent[];
+    /** DSH rc.6+ factory for an owned, clean top-level Agent. */
+    create?(options: CreateHostAgentOptions): Promise<HostAgentHandle>;
 }
 export interface HostWorkspace {
     readonly id: string;
@@ -187,16 +208,29 @@ export interface HostSubagentsService {
         persona?: string;
     }): Promise<HostSubagentRun>;
 }
+export interface HostLlmService {
+    listProviders(): Array<{
+        id: string;
+        name: string;
+    }>;
+    listModels(provider: string): Promise<Array<{
+        id: string;
+        name: string;
+        description?: string;
+    }>>;
+}
 export interface HostContextShape {
     tools: {
         register(definition: ToolDefinition): unknown;
     };
     commands: CommandService;
     settings: HostSettingsService;
-    connection: HostConnectionHandle;
+    /** Web-only transport; absent from non-Web profiles such as Headless. */
+    connection?: HostConnectionHandle;
     agents: HostAgentsService;
     subagents: HostSubagentsService;
-    workspaceRegistry: HostWorkspaceRegistry;
+    /** Web workbench catalog; Agent execution routes by session cwd without it. */
+    workspaceRegistry?: HostWorkspaceRegistry;
     get(name: string): unknown;
     inject(services: string[], callback: (ctx: HostContextShape) => void): unknown;
     on(name: string, listener: (...args: never[]) => unknown): () => unknown;

package/lib/types/lifecycle.d.ts

@@ -6,7 +6,8 @@ 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 } from './shared/contracts.ts';
+import type { AssistantMessageText, LifecycleSnapshot, TaskAgentModelCatalog } from './shared/contracts.ts';
+import type { PreparedMemoryPlacement } from './provider-placement.ts';
 interface AgentRuntimeSource {
     forAgent(agent: HostAgent): {
         runtimeMemory: RuntimeMemoryController;
@@ -26,11 +27,16 @@ export declare class MnemonLifecycle {
     private readonly runtimeSource?;
     private readonly owners;
     private readonly counters;
+    /** Creation ids reserved before DSH publishes clean task-root Agents. */
+    private readonly taskAgentIds;
     /** Bounded process-local replay fence for finalized-message write actions. */
     private readonly supervisedWritebacks;
     constructor(ctx: HostContextShape, coordinator: MnemonSubagentCoordinator, config: ResolvedConfig, runtimeSource?: AgentRuntimeSource | undefined);
     start(): () => void;
-    snapshot(sessionId?: string): LifecycleSnapshot;
+    snapshot(sessionId?: string, workspaceRoot?: string): LifecycleSnapshot;
+    /** Provider/model directory used by Settings without requiring a live session. */
+    taskAgentModels(includeCatalog?: boolean): Promise<TaskAgentModelCatalog>;
+    private availableAgent;
     workspaceRoot(sessionId?: string): string | undefined;
     /** Settled memory-tool activity for all turns, resolved per session. */
     turnActivities(sessionId: string): TurnMemoryActivitySnapshot;
@@ -39,15 +45,36 @@ export declare class MnemonLifecycle {
     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>;
     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>;
     remember(sessionId: string, request: RememberRequest, signal?: AbortSignal): Promise<DelegatedWriteResult>;
     runtime(sessionId: string, request: RuntimeMemoryMutation, signal?: AbortSignal): Promise<import("./subagent.ts").CoordinatedRuntimeMemoryResult>;
     documents(sessionId: string): import("./documents.ts").DocumentSnapshot;
     document(sessionId: string, id: string): import("./documents.ts").DocumentView;
     searchDocuments(sessionId: string, query: string, includeArchived?: boolean, limit?: number): Promise<import("./documents.ts").DocumentSearchResult>;
     mutateDocument(sessionId: string, request: DocumentMutation, signal?: AbortSignal): Promise<import("./subagent.ts").CoordinatedDocumentResult>;
-    archiveDocument(sessionId: string, id: string, signal?: AbortSignal): Promise<import("./subagent.ts").CoordinatedDocumentResult>;
+    archiveDocument(sessionId: string, id: string, workspaceRoot?: string, signal?: AbortSignal): Promise<import("./subagent.ts").CoordinatedDocumentResult>;
     mutate(sessionId: string, operation: string, request: unknown, signal?: AbortSignal): Promise<DelegatedWriteResult>;
+    placeProvider(sessionId: string, body: {
+        name: string;
+        description: string;
+    }, prepared: PreparedMemoryPlacement, signal?: AbortSignal): Promise<import("./shared/contracts.ts").MemoryPlacementDecision>;
+    maintainMetadata(sessionId: string, memoryBodyIds: readonly string[], workspaceRoot?: string, signal?: AbortSignal): Promise<import("./shared/contracts.ts").MemoryBodyMetadataMaintenanceResult>;
     supervise(sessionId: string, content: string, idempotencyKey?: string, signal?: AbortSignal): Promise<SupervisedWritebackResult>;
+    /** Run a Web workbench distillation under a fresh top-level task Agent. */
+    superviseTask(sessionId: string, content: string, idempotencyKey?: string, workspaceRoot?: string, signal?: AbortSignal): Promise<SupervisedWritebackResult>;
+    private superviseResolved;
     private liveAgent;
+    /**
+     * Run session-independent maintenance under a fresh top-level Agent. Its cwd
+     * is the explicit Web workbench scope, so LiveMnemonRuntime resolves the same
+     * workspace graph without borrowing conversation history or ownership.
+     */
+    private runTaskAgent;
+    /** Resolve the same model route and preset composition as an ordinary fresh DSH Agent. */
+    private taskAgentCreation;
+    /** Resolve a complete task route for both status admission and actual creation. */
+    private taskAgentModelRoute;
+    private taskAgentModelOptions;
     private install;
 }

package/lib/types/memory-bodies.d.ts

@@ -1,12 +1,15 @@
 import type { MnemonRunner } from './runner.ts';
-import type { CreateMemoryBodyRequest, MemoryBody, UpdateMemoryBodyRequest } from './shared/contracts.ts';
+import type { MemoryPlacementCandidate } from './provider-placement.ts';
+import type { CreateMemoryBodyRequest, MemoryBody, MemoryPlacementDecision, MemoryProviderServiceCatalog, MemoryProviderServiceView, MemoryProviderConnection, MemoryProviderId, MemoryBodyMetadataUpdate, OpenVikingBodyConnection, UpdateMemoryBodyRequest } from './shared/contracts.ts';
+import type { ProviderMemorySpace } from './providers/provider.ts';
 export type { CreateMemoryBodyRequest, MemoryBody, UpdateMemoryBodyRequest } from './shared/contracts.ts';
 export declare function validateMemoryBodyId(value: string): string;
 /**
  * Persistent metadata layered over Mnemon's native named stores.
  *
- * The registry lives beside the store directories, while each body keeps using
- * Mnemon's stable `<dataDir>/data/<id>/mnemon.db` layout.
+ * Native metadata lives beside Store directories so existing Mnemon Packs stay
+ * compatible. External connection metadata lives under state and is never
+ * included in Memory Space Packs.
  */
 export declare class MemoryBodyRegistry {
     readonly runner: MnemonRunner;
@@ -14,13 +17,30 @@ export declare class MemoryBodyRegistry {
     private readonly now;
     readonly directory: string;
     readonly registryPath: string;
+    readonly providerRegistryPath: string;
     private bodies;
+    private services;
+    private serviceEnabled;
     constructor(runner: MnemonRunner, persistent?: boolean, now?: () => Date);
     list(): MemoryBody[];
     active(): MemoryBody[];
     get(id: string): MemoryBody;
-    create(request: CreateMemoryBodyRequest, signal?: AbortSignal): Promise<MemoryBody>;
+    openVikingConnection(id: string): OpenVikingBodyConnection;
+    providerConnection(id: string, expectedProviderId?: MemoryProviderId): MemoryProviderConnection;
+    providerServiceConfigured(providerId: MemoryProviderId): boolean;
+    providerServiceEnabled(providerId: MemoryProviderId): boolean;
+    providerServices(options?: {
+        includeSecrets?: boolean;
+    }): MemoryProviderServiceCatalog;
+    updateProviderService(providerId: MemoryProviderId, settings: MemoryProviderConnection, clearSecrets?: readonly string[], enabled?: boolean): MemoryProviderServiceView;
+    resolveProviderService(providerId: MemoryProviderId, settings: MemoryProviderConnection, clearSecrets?: readonly string[]): MemoryProviderConnection;
+    /** Atomically replace one provider's local projections after authoritative discovery. */
+    syncProviderService(providerId: MemoryProviderId, service: MemoryProviderConnection, discovered: readonly ProviderMemorySpace[]): MemoryProviderServiceView;
+    placementCandidates(request: Pick<CreateMemoryBodyRequest, 'connection' | 'providerConnections' | 'openViking'>): MemoryPlacementCandidate[];
+    create(request: CreateMemoryBodyRequest, signal?: AbortSignal, placement?: MemoryPlacementDecision): Promise<MemoryBody>;
     update(id: string, request: UpdateMemoryBodyRequest): MemoryBody;
+    /** Validate every model-authored update before committing the batch. */
+    updateMetadata(updates: readonly MemoryBodyMetadataUpdate[]): MemoryBody[];
     remove(id: string, signal?: AbortSignal): Promise<MemoryBody>;
     setActive(id: string, active: boolean): MemoryBody;
     /** Refresh metadata after an atomic Pack import replaced the data component. */
@@ -30,4 +50,5 @@ export declare class MemoryBodyRegistry {
     private nativeStoreIds;
     private view;
     private save;
+    private writeRegistry;
 }

package/lib/types/process.d.ts

@@ -4,9 +4,12 @@ export interface ProcessResult {
     exitCode: number | null;
 }
 export interface ProcessOptions {
-    signal?: AbortSignal;
+    signal?: AbortSignal | undefined;
     timeoutMs: number;
     maxOutputBytes?: number;
+    cwd?: string | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+    label?: string | undefined;
 }
 export type ProcessRunner = (command: string, args: readonly string[], options: ProcessOptions) => Promise<ProcessResult>;
 /** Spawn without a shell, with bounded output and cooperative cancellation. */

package/lib/types/provider-placement.d.ts

@@ -0,0 +1,26 @@
+import type { AutomaticMemoryPlacementRequest, MemoryPlacementDecision, MemoryProviderCapabilities, MemoryProviderId } from './shared/contracts.ts';
+export interface MemoryPlacementCandidate {
+    id: MemoryProviderId;
+    label: string;
+    kind: 'local' | 'remote';
+    configured: boolean;
+    summary: string;
+    capabilities: MemoryProviderCapabilities;
+}
+export interface PreparedMemoryPlacement {
+    prompt: string;
+    candidates: MemoryPlacementCandidate[];
+    appliedRules: string[];
+    selectorBrief: string;
+}
+export interface LlmMemoryPlacementSelection {
+    providerId: string;
+    reason: string;
+    confidence: string;
+}
+export declare function prepareMemoryPlacement(request: AutomaticMemoryPlacementRequest, candidates: readonly MemoryPlacementCandidate[]): PreparedMemoryPlacement;
+export declare function rulesOnlyPlacement(prepared: PreparedMemoryPlacement, now?: () => Date): MemoryPlacementDecision | undefined;
+export declare function finalizeLlmPlacement(prepared: PreparedMemoryPlacement, selection: LlmMemoryPlacementSelection, delegation: {
+    runId: string;
+    provider: string;
+}, now?: () => Date): MemoryPlacementDecision;

package/lib/types/providers/byterover.d.ts

@@ -0,0 +1,31 @@
+import type { JsonValue } from '../contracts.ts';
+import type { MemoryBodyRegistry } from '../memory-bodies.ts';
+import { type ProcessRunner } from '../process.ts';
+import type { Insight, MemoryBody, MemoryGraphSnapshot, MemoryListRequest, MemoryProviderConnection, RememberRequest, SearchRequest } from '../shared/contracts.ts';
+import type { MemoryProviderAdapter, ProviderBodyStatus, ProviderMemorySpace, ProviderSearchResult } from './provider.ts';
+interface ByteRoverProviderOptions {
+    process?: ProcessRunner;
+    queryTimeoutMs?: number;
+    curateTimeoutMs?: number;
+}
+export declare class ByteRoverProvider implements MemoryProviderAdapter {
+    private readonly memoryBodies;
+    readonly id: "byterover";
+    private readonly process;
+    private readonly queryTimeoutMs;
+    private readonly curateTimeoutMs;
+    private readonly statusCache;
+    private readonly statusInFlight;
+    constructor(memoryBodies: MemoryBodyRegistry, options?: ByteRoverProviderOptions);
+    discover(connection: MemoryProviderConnection): Promise<ProviderMemorySpace[]>;
+    status(body: MemoryBody, signal?: AbortSignal): Promise<ProviderBodyStatus>;
+    invalidateStatus(memoryBodyId?: string): void;
+    private checkStatus;
+    search(body: MemoryBody, request: SearchRequest, signal?: AbortSignal): Promise<ProviderSearchResult>;
+    graph(body: MemoryBody): Promise<MemoryGraphSnapshot>;
+    list(body: MemoryBody, request: MemoryListRequest, signal?: AbortSignal): Promise<Insight[]>;
+    remember(body: MemoryBody, request: RememberRequest, signal?: AbortSignal): Promise<JsonValue>;
+    private connection;
+    private run;
+}
+export {};

package/lib/types/providers/catalog.d.ts

@@ -0,0 +1,23 @@
+import type { MemoryProviderConfigField, MemoryProviderConnection, MemoryProviderDescriptor, MemoryProviderId } from '../shared/contracts.ts';
+export declare const MEMORY_PROVIDER_IDS: readonly ["mnemon-native", "openviking", "honcho", "mem0", "hindsight", "holographic", "retaindb", "byterover", "supermemory"];
+export declare const MEMORY_PROVIDER_ID_SET: Set<MemoryProviderId>;
+export declare const MEMORY_PROVIDER_CATALOG: readonly MemoryProviderDescriptor[];
+export declare function memoryProviderDescriptor(id: MemoryProviderId): MemoryProviderDescriptor;
+export declare function isMemoryProviderId(value: unknown): value is MemoryProviderId;
+export declare function providerServiceFields(providerId: MemoryProviderId): MemoryProviderConfigField[];
+export declare function providerMemoryFields(providerId: MemoryProviderId): MemoryProviderConfigField[];
+export declare function splitProviderConnection(providerId: MemoryProviderId, connection: MemoryProviderConnection | undefined): {
+    service: MemoryProviderConnection;
+    memory: MemoryProviderConnection;
+};
+export declare function normalizeProviderServiceConnection(providerId: MemoryProviderId, input: MemoryProviderConnection | undefined, previous?: MemoryProviderConnection, clearSecrets?: readonly string[]): MemoryProviderConnection;
+export declare function normalizeProviderMemoryConnection(providerId: MemoryProviderId, input: MemoryProviderConnection | undefined, previous?: MemoryProviderConnection): MemoryProviderConnection;
+export declare function normalizeProviderConnection(providerId: MemoryProviderId, input: MemoryProviderConnection | undefined, previous?: MemoryProviderConnection, clearSecrets?: readonly string[]): MemoryProviderConnection;
+export declare function publicScopedProviderConnection(providerId: MemoryProviderId, scope: MemoryProviderConfigField['scope'], connection: MemoryProviderConnection): {
+    settings: MemoryProviderConnection;
+    configuredSecrets: string[];
+};
+export declare function publicProviderConnection(providerId: MemoryProviderId, connection: MemoryProviderConnection): {
+    settings: MemoryProviderConnection;
+    configuredSecrets: string[];
+};

package/lib/types/providers/hindsight.d.ts

@@ -0,0 +1,19 @@
+import type { JsonValue } from '../contracts.ts';
+import type { MemoryBodyRegistry } from '../memory-bodies.ts';
+import type { EdgeType, Insight, MemoryBody, MemoryGraphSnapshot, MemoryListRequest, RememberRequest, SearchRequest } from '../shared/contracts.ts';
+import { HttpMemoryProvider, type HttpProviderOptions } from './http.ts';
+import type { MemoryProviderAdapter, ProviderBodyStatus, ProviderMemorySpace, ProviderSearchResult } from './provider.ts';
+export declare class HindsightProvider extends HttpMemoryProvider implements MemoryProviderAdapter {
+    readonly id: "hindsight";
+    constructor(memoryBodies: MemoryBodyRegistry, options?: HttpProviderOptions);
+    discover(connection: Record<string, string | number | boolean>, signal?: AbortSignal): Promise<ProviderMemorySpace[]>;
+    status(body: MemoryBody, signal?: AbortSignal): Promise<ProviderBodyStatus>;
+    search(body: MemoryBody, request: SearchRequest, signal?: AbortSignal): Promise<ProviderSearchResult>;
+    list(body: MemoryBody, request: MemoryListRequest, signal?: AbortSignal): Promise<Insight[]>;
+    graph(body: MemoryBody, signal?: AbortSignal): Promise<MemoryGraphSnapshot>;
+    related(body: MemoryBody, id: string, depth: number, _edge?: EdgeType, signal?: AbortSignal): Promise<Insight[]>;
+    remember(body: MemoryBody, request: RememberRequest, signal?: AbortSignal): Promise<JsonValue>;
+    forget(body: MemoryBody, id: string, signal?: AbortSignal): Promise<JsonValue>;
+    private bankPath;
+    private headers;
+}

package/lib/types/providers/holographic.d.ts

@@ -0,0 +1,22 @@
+import type { JsonValue } from '../contracts.ts';
+import type { MemoryBodyRegistry } from '../memory-bodies.ts';
+import type { Insight, MemoryBody, MemoryGraphSnapshot, MemoryListRequest, MemoryProviderConnection, RememberRequest, SearchRequest } from '../shared/contracts.ts';
+import type { MemoryProviderAdapter, ProviderBodyStatus, ProviderMemorySpace, ProviderSearchResult } from './provider.ts';
+export declare class HolographicProvider implements MemoryProviderAdapter {
+    private readonly memoryBodies;
+    readonly id: "holographic";
+    constructor(memoryBodies: MemoryBodyRegistry);
+    discover(connection: MemoryProviderConnection): Promise<ProviderMemorySpace[]>;
+    status(body: MemoryBody): Promise<ProviderBodyStatus>;
+    search(body: MemoryBody, request: SearchRequest): Promise<ProviderSearchResult>;
+    list(body: MemoryBody, request: MemoryListRequest): Promise<Insight[]>;
+    graph(body: MemoryBody): Promise<MemoryGraphSnapshot>;
+    related(body: MemoryBody, id: string, _depth: number): Promise<Insight[]>;
+    remember(body: MemoryBody, request: RememberRequest): Promise<JsonValue>;
+    forget(body: MemoryBody, id: string): Promise<JsonValue>;
+    private connection;
+    private path;
+    private load;
+    private save;
+    private stats;
+}

package/lib/types/providers/honcho.d.ts

@@ -0,0 +1,18 @@
+import type { JsonValue } from '../contracts.ts';
+import type { MemoryBodyRegistry } from '../memory-bodies.ts';
+import type { Insight, MemoryBody, MemoryListRequest, RememberRequest, SearchRequest } from '../shared/contracts.ts';
+import { HttpMemoryProvider, type HttpProviderOptions } from './http.ts';
+import type { MemoryProviderAdapter, ProviderBodyStatus, ProviderMemorySpace, ProviderSearchResult } from './provider.ts';
+export declare class HonchoProvider extends HttpMemoryProvider implements MemoryProviderAdapter {
+    readonly id: "honcho";
+    constructor(memoryBodies: MemoryBodyRegistry, options?: HttpProviderOptions);
+    discover(connection: Record<string, string | number | boolean>, signal?: AbortSignal): Promise<ProviderMemorySpace[]>;
+    status(body: MemoryBody, signal?: AbortSignal): Promise<ProviderBodyStatus>;
+    search(body: MemoryBody, request: SearchRequest, signal?: AbortSignal): Promise<ProviderSearchResult>;
+    list(body: MemoryBody, request: MemoryListRequest, signal?: AbortSignal): Promise<Insight[]>;
+    remember(body: MemoryBody, request: RememberRequest, signal?: AbortSignal): Promise<JsonValue>;
+    forget(body: MemoryBody, id: string, signal?: AbortSignal): Promise<JsonValue>;
+    private basePath;
+    private scope;
+    private headers;
+}

package/lib/types/providers/http.d.ts

@@ -0,0 +1,32 @@
+import type { JsonValue } from '../contracts.ts';
+import type { MemoryBodyRegistry } from '../memory-bodies.ts';
+import type { Insight, MemoryBody, MemoryGraphSnapshot, MemoryListRequest, MemoryProviderConnection, MemoryProviderId } from '../shared/contracts.ts';
+export interface HttpProviderOptions {
+    fetch?: typeof fetch;
+    requestTimeoutMs?: number;
+}
+export interface JsonRequestOptions {
+    method?: string;
+    headers?: HeadersInit;
+    json?: JsonValue;
+    signal?: AbortSignal | undefined;
+    timeoutMs?: number;
+}
+export declare function jsonObject(value: unknown): Record<string, unknown> | undefined;
+export declare function jsonString(value: unknown): string | undefined;
+export declare function jsonNumber(value: unknown): number | undefined;
+export declare function jsonArray(value: unknown): unknown[];
+export declare function firstArray(value: unknown, ...keys: string[]): unknown[];
+/** Shared timeout, cancellation, error, and projection behavior for HTTP providers. */
+export declare abstract class HttpMemoryProvider {
+    protected readonly memoryBodies: MemoryBodyRegistry;
+    abstract readonly id: MemoryProviderId;
+    protected readonly requestFetch: typeof fetch;
+    protected readonly requestTimeoutMs: number;
+    constructor(memoryBodies: MemoryBodyRegistry, options?: HttpProviderOptions);
+    abstract list(body: MemoryBody, request: MemoryListRequest, signal?: AbortSignal): Promise<Insight[]>;
+    graph(body: MemoryBody, signal?: AbortSignal): Promise<MemoryGraphSnapshot>;
+    protected connection(body: MemoryBody): MemoryProviderConnection;
+    protected request(body: MemoryBody, path: string, options?: JsonRequestOptions): Promise<unknown>;
+    protected requestConnection(connection: MemoryProviderConnection, path: string, options?: JsonRequestOptions): Promise<unknown>;
+}

package/lib/types/providers/mem0.d.ts

@@ -0,0 +1,17 @@
+import type { JsonValue } from '../contracts.ts';
+import type { MemoryBodyRegistry } from '../memory-bodies.ts';
+import type { Insight, MemoryBody, MemoryListRequest, RememberRequest, SearchRequest } from '../shared/contracts.ts';
+import { HttpMemoryProvider, type HttpProviderOptions } from './http.ts';
+import type { MemoryProviderAdapter, ProviderBodyStatus, ProviderMemorySpace, ProviderSearchResult } from './provider.ts';
+export declare class Mem0Provider extends HttpMemoryProvider implements MemoryProviderAdapter {
+    readonly id: "mem0";
+    constructor(memoryBodies: MemoryBodyRegistry, options?: HttpProviderOptions);
+    discover(connection: Record<string, string | number | boolean>, signal?: AbortSignal): Promise<ProviderMemorySpace[]>;
+    status(body: MemoryBody, signal?: AbortSignal): Promise<ProviderBodyStatus>;
+    search(body: MemoryBody, request: SearchRequest, signal?: AbortSignal): Promise<ProviderSearchResult>;
+    list(body: MemoryBody, request: MemoryListRequest, signal?: AbortSignal): Promise<Insight[]>;
+    remember(body: MemoryBody, request: RememberRequest, signal?: AbortSignal): Promise<JsonValue>;
+    forget(body: MemoryBody, id: string, signal?: AbortSignal): Promise<JsonValue>;
+    private filters;
+    private headers;
+}

package/lib/types/providers/openviking.d.ts

@@ -0,0 +1,31 @@
+import type { JsonValue } from '../contracts.ts';
+import type { MemoryBodyRegistry } from '../memory-bodies.ts';
+import type { Insight, MemoryBody, MemoryGraphSnapshot, MemoryListRequest, MemoryProviderConnection, RememberRequest, SearchRequest } from '../shared/contracts.ts';
+import type { MemoryProviderAdapter, ProviderBodyStatus, ProviderMemorySpace, ProviderSearchResult } from './provider.ts';
+interface OpenVikingProviderOptions {
+    fetch?: typeof fetch;
+    requestTimeoutMs?: number;
+    settlementTimeoutMs?: number;
+    pollIntervalMs?: number;
+}
+export declare class OpenVikingProvider implements MemoryProviderAdapter {
+    private readonly memoryBodies;
+    readonly id: "openviking";
+    private readonly requestFetch;
+    private readonly requestTimeoutMs;
+    private readonly settlementTimeoutMs;
+    private readonly pollIntervalMs;
+    constructor(memoryBodies: MemoryBodyRegistry, options?: OpenVikingProviderOptions);
+    discover(connection: MemoryProviderConnection, signal?: AbortSignal): Promise<ProviderMemorySpace[]>;
+    status(body: MemoryBody, signal?: AbortSignal): Promise<ProviderBodyStatus>;
+    search(body: MemoryBody, request: SearchRequest, signal?: AbortSignal): Promise<ProviderSearchResult>;
+    graph(body: MemoryBody, signal?: AbortSignal): Promise<MemoryGraphSnapshot>;
+    list(body: MemoryBody, request: MemoryListRequest, signal?: AbortSignal): Promise<Insight[]>;
+    remember(body: MemoryBody, request: RememberRequest, signal?: AbortSignal): Promise<JsonValue>;
+    forget(body: MemoryBody, id: string, signal?: AbortSignal): Promise<JsonValue>;
+    private connection;
+    private settleTask;
+    private request;
+    private requestConnection;
+}
+export {};

package/lib/types/providers/provider.d.ts

@@ -0,0 +1,38 @@
+import type { JsonValue } from '../contracts.ts';
+import type { EdgeType, Insight, MemoryBody, MemoryBodyStats, MemoryGraphSnapshot, MemoryListRequest, MemoryProviderConnection, RememberRequest, SearchRequest } from '../shared/contracts.ts';
+export interface ProviderBodyStatus {
+    healthy: boolean;
+    error?: string;
+    stats?: MemoryBodyStats;
+}
+export interface ProviderSearchResult {
+    results: Insight[];
+    hint?: string;
+}
+/** One provider-owned namespace projected into DSH as a Memory Space. */
+export interface ProviderMemorySpace {
+    /** Stable identifier owned by the provider, never a DSH-generated title. */
+    externalId: string;
+    name: string;
+    description: string;
+    connection: MemoryProviderConnection;
+}
+/**
+ * Third-layer memory data plane. DSH owns routing and lifecycle; adapters own
+ * only one body's persistence and retrieval semantics.
+ */
+export interface MemoryProviderAdapter {
+    readonly id: MemoryBody['provider']['id'];
+    /** Enumerate the complete set of namespaces visible to this service connection. */
+    discover?(connection: MemoryProviderConnection, signal?: AbortSignal): Promise<ProviderMemorySpace[]>;
+    /** Drop a short-lived health result before an explicit user reconnect. */
+    invalidateStatus?(memoryBodyId?: string): void;
+    status(body: MemoryBody, signal?: AbortSignal): Promise<ProviderBodyStatus>;
+    search(body: MemoryBody, request: SearchRequest, signal?: AbortSignal): Promise<ProviderSearchResult>;
+    graph(body: MemoryBody, signal?: AbortSignal): Promise<MemoryGraphSnapshot>;
+    list(body: MemoryBody, request: MemoryListRequest, signal?: AbortSignal): Promise<Insight[]>;
+    remember(body: MemoryBody, request: RememberRequest, signal?: AbortSignal): Promise<JsonValue>;
+    related?(body: MemoryBody, id: string, depth: number, edge?: EdgeType, signal?: AbortSignal): Promise<Insight[]>;
+    link?(body: MemoryBody, sourceId: string, targetId: string, type: EdgeType, weight: number, reason?: string, signal?: AbortSignal): Promise<JsonValue>;
+    forget?(body: MemoryBody, id: string, signal?: AbortSignal): Promise<JsonValue>;
+}

package/lib/types/providers/retaindb.d.ts

@@ -0,0 +1,16 @@
+import type { JsonValue } from '../contracts.ts';
+import type { MemoryBodyRegistry } from '../memory-bodies.ts';
+import type { Insight, MemoryBody, MemoryListRequest, RememberRequest, SearchRequest } from '../shared/contracts.ts';
+import { HttpMemoryProvider, type HttpProviderOptions } from './http.ts';
+import type { MemoryProviderAdapter, ProviderBodyStatus, ProviderMemorySpace, ProviderSearchResult } from './provider.ts';
+export declare class RetainDbProvider extends HttpMemoryProvider implements MemoryProviderAdapter {
+    readonly id: "retaindb";
+    constructor(memoryBodies: MemoryBodyRegistry, options?: HttpProviderOptions);
+    discover(connection: Record<string, string | number | boolean>, signal?: AbortSignal): Promise<ProviderMemorySpace[]>;
+    status(body: MemoryBody, signal?: AbortSignal): Promise<ProviderBodyStatus>;
+    search(body: MemoryBody, request: SearchRequest, signal?: AbortSignal): Promise<ProviderSearchResult>;
+    list(body: MemoryBody, request: MemoryListRequest, signal?: AbortSignal): Promise<Insight[]>;
+    remember(body: MemoryBody, request: RememberRequest, signal?: AbortSignal): Promise<JsonValue>;
+    forget(body: MemoryBody, id: string, signal?: AbortSignal): Promise<JsonValue>;
+    private headers;
+}

package/lib/types/providers/supermemory.d.ts

@@ -0,0 +1,16 @@
+import type { JsonValue } from '../contracts.ts';
+import type { MemoryBodyRegistry } from '../memory-bodies.ts';
+import type { Insight, MemoryBody, MemoryListRequest, RememberRequest, SearchRequest } from '../shared/contracts.ts';
+import { HttpMemoryProvider, type HttpProviderOptions } from './http.ts';
+import type { MemoryProviderAdapter, ProviderBodyStatus, ProviderMemorySpace, ProviderSearchResult } from './provider.ts';
+export declare class SupermemoryProvider extends HttpMemoryProvider implements MemoryProviderAdapter {
+    readonly id: "supermemory";
+    constructor(memoryBodies: MemoryBodyRegistry, options?: HttpProviderOptions);
+    discover(connection: Record<string, string | number | boolean>, signal?: AbortSignal): Promise<ProviderMemorySpace[]>;
+    status(body: MemoryBody, signal?: AbortSignal): Promise<ProviderBodyStatus>;
+    search(body: MemoryBody, request: SearchRequest, signal?: AbortSignal): Promise<ProviderSearchResult>;
+    list(body: MemoryBody, request: MemoryListRequest, signal?: AbortSignal): Promise<Insight[]>;
+    remember(body: MemoryBody, request: RememberRequest, signal?: AbortSignal): Promise<JsonValue>;
+    forget(body: MemoryBody, id: string, signal?: AbortSignal): Promise<JsonValue>;
+    private headers;
+}

package/lib/types/rpc.d.ts

@@ -11,6 +11,6 @@ type RuntimeInput = MnemonService | LiveMnemonRuntime;
 export declare function createReadHandler(input: RuntimeInput, lifecycle?: MnemonLifecycle, runtimeMemory?: RuntimeMemoryController, storage?: StorageScopeInspector, versions?: VersionUpdateManager): HostRpcHandler;
 export declare function createWriteHandler(input: RuntimeInput, lifecycle?: MnemonLifecycle, runtimeMemory?: RuntimeMemoryController, versions?: VersionUpdateManager): HostRpcHandler;
 /** Backup payloads contain private memory and therefore remain loopback-only. */
-export declare function createPackHandler(manager: MnemonPackManager, writeEnabled?: boolean | (() => boolean)): HostRpcHandler;
+export declare function createPackHandler(input: MnemonPackManager | LiveMnemonRuntime, writeEnabled?: boolean | (() => boolean)): HostRpcHandler;
 /** Read operations are available to trusted Web hosts; local mutations stay loopback-only. */
 export declare function registerRpc(connection: HostConnectionHandle, input: RuntimeInput, lifecycle?: MnemonLifecycle, runtimeMemory?: RuntimeMemoryController, storage?: StorageScopeInspector, packs?: MnemonPackManager, versions?: VersionUpdateManager): void;