dsh-mnemon 0.1.5 → 0.2.0

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

@@ -1,11 +1,12 @@
-import type { ClientConnectionHandle, ClientSettingsScope, ClientSettingsSnapshot, SettingsOperation } from '../contracts.ts';
+import { type ClientConnectionHandle, type ClientSettingsScope, type ClientSettingsSnapshot, type SettingsOperation } from '../shared/contracts.ts';
 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,6 +18,6 @@ export declare class MnemonSettingsScope<T extends object> implements ClientSett
     mutate(ops: SettingsOperation[]): Promise<void>;
     private load;
     private write;
+    private call;
     private publish;
 }
-//# sourceMappingURL=settings.d.ts.map

package/lib/types/client/sidebar-entry.d.ts

@@ -3,4 +3,3 @@ import type { MnemonWorkspaceController } from './workspace-controller.ts';
 export declare const MNEMON_ENTRY_SELECTOR = "[data-dsh-mnemon-entry]";
 /** Mount a self-healing official-style entry under the New Session row. */
 export declare function mountMnemonSidebarEntry(controller: MnemonWorkspaceController, t: MnemonTranslate, subscribeLocale?: (listener: () => void) => () => void): () => void;
-//# sourceMappingURL=sidebar-entry.d.ts.map

package/lib/types/client/workspace-controller.d.ts

@@ -12,4 +12,3 @@ export declare class MnemonWorkspaceController {
     toggle(): void;
     private setOpen;
 }
-//# sourceMappingURL=workspace-controller.d.ts.map

package/lib/types/client/workspace-mount.d.ts

@@ -1,8 +1,6 @@
-import type { Config } from '../config.ts';
-import type { ClientSettingsScope } from '../contracts.ts';
+import type { ClientSettingsScope, Config } from '../shared/contracts.ts';
 import type { MnemonClientContext } from './dsh-compat.ts';
 import type { MnemonTranslate } from './locales.ts';
 export declare const MNEMON_VIEW_SELECTOR = "[data-dsh-mnemon-view]";
 /** Mount the sidebar row and its stateful center-column workspace as one unit. */
 export declare function mountMnemonWorkspace(ctx: MnemonClientContext, settings: ClientSettingsScope<Config>, t: MnemonTranslate): () => void;
-//# sourceMappingURL=workspace-mount.d.ts.map

package/lib/types/commands.d.ts

@@ -11,4 +11,3 @@ interface AgentServiceSource {
 export declare function createMnemonCommand(service: MnemonService | AgentServiceSource, coordinator: MnemonSubagentCoordinator): CommandDefinition;
 export declare function registerCommands(commands: CommandService, service: MnemonService | AgentServiceSource, coordinator: MnemonSubagentCoordinator): void;
 export {};
-//# sourceMappingURL=commands.d.ts.map

package/lib/types/config-values.d.ts

@@ -1,4 +1,3 @@
 export declare const DEFAULT_TIMEOUT_MS = 10000;
 export declare const DEFAULT_RECALL_LIMIT = 10;
 export declare const DEFAULT_IDLE_REVIEW_MS = 30000;
-//# sourceMappingURL=config-values.d.ts.map

package/lib/types/config.d.ts

@@ -1,86 +1,12 @@
 import z from 'schemastery';
+import type { Config as SharedConfig, CustomPackConfig as SharedCustomPackConfig, InteractionConfig as SharedInteractionConfig, ResolvedConfig as SharedResolvedConfig, ResolvedInteractionConfig as SharedResolvedInteractionConfig } from './shared/contracts.ts';
 export { DEFAULT_IDLE_REVIEW_MS, DEFAULT_RECALL_LIMIT, DEFAULT_TIMEOUT_MS } from './config-values.ts';
-/** User-facing configuration mounted from the DSH profile patch. */
-export interface Config {
-    /** Storage domain selected in DSH plugin settings. Changes apply live after save. */
-    storageScope?: 'global' | 'workspace' | 'custom';
-    /** Explicit `mnemon` executable. Omit to resolve MNEMON_CLI_PATH, PATH, then common install locations. */
-    cliPath?: string;
-    /** Custom Mnemon base directory; also retained as a legacy dataDir-only scope selection. */
-    dataDir?: string;
-    /** @deprecated Migration-only selector from the former named-Pack settings UI. */
-    customPackId?: string;
-    /** @deprecated Migration-only roots from the former named-Pack settings UI. */
-    customPacks?: CustomPackConfig[];
-    /** Legacy store hint used to bootstrap or discover the initial Memory Space. */
-    store?: string;
-    /** Hard deadline for one CLI process. */
-    timeoutMs?: number;
-    /** Default number of recall results exposed to the agent and Web workspace. */
-    defaultRecallLimit?: number;
-    /** Add conservative recall/writeback guidance to the DSH system prompt. */
-    routingGuidance?: boolean;
-    /** Choose where the DSH Web memory workspace is mounted. */
-    displayMode?: 'sidebar' | 'buildin';
-    /** Register the configured DSH Web memory workspace. */
-    tabEnabled?: boolean;
-    /** Allow remember/link/forget mutations. Recall and status remain available when false. */
-    writeEnabled?: boolean;
-    /** Enable DSH agent lifecycle integration (Prime plus recall/remember cues). */
-    lifecycleEnabled?: boolean;
-    /** Recall behavior at the first step of each DSH turn. */
-    recallMode?: 'guided' | 'off';
-    /** Enable the short remember cue and the scored, debounced full-checkpoint review. */
-    writebackMode?: 'guided' | 'off';
-    /** Continuous root-agent idle time after the QoderWork activity gate is met. */
-    idleReviewMs?: number;
-    /** @deprecated Migration source for pre-0.2 settings; new writes use the live `mnemon-ui` namespace. */
-    conversationInteraction?: {
-        /** @deprecated Removed. Mnemon now uses DSH's standard tool presentation. */
-        toolviews?: boolean;
-        /** Per-turn memory activity bar under completed turns. */
-        turnBar?: boolean;
-        /** Save-to-memory action on finalized assistant messages. */
-        saveAction?: boolean;
-    };
-}
-export interface CustomPackConfig {
-    id: string;
-    name: string;
-    dataDir: string;
-}
-/** Browser-only interaction settings, registered live under `mnemon-ui`. */
-export interface InteractionConfig {
-    turnBar?: boolean;
-    saveAction?: boolean;
-}
+export type Config = SharedConfig;
+export type CustomPackConfig = SharedCustomPackConfig;
+export type InteractionConfig = SharedInteractionConfig;
+export type ResolvedConfig = SharedResolvedConfig;
+export type ResolvedInteractionConfig = SharedResolvedInteractionConfig;
 export declare const InteractionConfig: z<InteractionConfig>;
 export declare const Config: z<Config>;
-export interface ResolvedConfig {
-    storageScope: 'global' | 'workspace' | 'custom';
-    cliPath?: string;
-    dataDir?: string;
-    store?: string;
-    timeoutMs: number;
-    defaultRecallLimit: number;
-    routingGuidance: boolean;
-    displayMode: 'sidebar' | 'buildin';
-    tabEnabled: boolean;
-    writeEnabled: boolean;
-    lifecycleEnabled: boolean;
-    recallMode: 'guided' | 'off';
-    writebackMode: 'guided' | 'off';
-    idleReviewMs: number;
-    conversationInteraction: {
-        toolviews: boolean;
-        turnBar: boolean;
-        saveAction: boolean;
-    };
-}
-export interface ResolvedInteractionConfig {
-    turnBar: boolean;
-    saveAction: boolean;
-}
 export declare function resolveInteractionConfig(config?: InteractionConfig): ResolvedInteractionConfig;
 export declare function resolveConfig(config?: Config): ResolvedConfig;
-//# sourceMappingURL=config.d.ts.map

package/lib/types/contracts.d.ts

@@ -1,35 +1,5 @@
-import type { ConnectionHandle as DshClientConnectionHandle } from '@deepseek-ai/dsh-client-connection/client';
-export type JsonPrimitive = string | number | boolean | null;
-export type JsonValue = JsonPrimitive | JsonValue[] | {
-    [key: string]: JsonValue;
-};
-/** Plugin RPC failures use only error branches accepted by DSH's closed wire schema. */
-export type RpcError = {
-    code: 'bad-request';
-    message: string;
-    details: {
-        issues: JsonValue[];
-    };
-} | {
-    code: 'settings-rejected';
-    message: string;
-    details: {
-        ns: string;
-    };
-} | {
-    code: 'internal';
-    message: string;
-    details: Record<string, never>;
-};
-export type RpcResult<T = JsonValue> = {
-    ok: true;
-    value: T;
-} | {
-    ok: false;
-    error: RpcError;
-};
-/** Public DSH browser RPC face; the plugin intentionally consumes no other connection state. */
-export type ClientConnectionHandle = Pick<DshClientConnectionHandle, 'rpc'>;
+import type { RpcResult, SettingsOperation } from './shared/contracts.ts';
+export type { ClientConnectionHandle, ClientSettingsScope, ClientSettingsSnapshot, JsonPrimitive, JsonValue, RpcError, RpcResult, SettingsOperation, } from './shared/contracts.ts';
 export type HostRpcHandler = (endpoint: string, payload: unknown) => Promise<RpcResult<unknown>>;
 export interface HostConnectionHandle {
     rpc: {
@@ -147,6 +117,7 @@ export interface HostAgent {
             origin?: 'subagent';
             delegationDepth?: number;
             cwd?: string;
+            agentPreset?: string;
         };
         events: readonly HostSessionEvent[];
     };
@@ -155,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;
@@ -217,46 +208,31 @@ 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;
     effect(callback: () => (() => unknown) | void, label?: string): () => unknown;
 }
-export interface ClientSettingsSnapshot<T> {
-    status: 'loading' | 'ready' | 'unavailable';
-    value?: T;
-    base?: unknown;
-    user?: unknown;
-    revision?: number;
-    writable: boolean;
-    mode: 'host' | 'memory';
-}
-export interface ClientSettingsScope<T> {
-    getSnapshot(): ClientSettingsSnapshot<T>;
-    subscribe(listener: () => void): () => void;
-    set(field: string, value: unknown): Promise<void>;
-    unset(field: string): Promise<void>;
-    setPath(path: string[], value: unknown): Promise<void>;
-    unsetPath(path: string[]): Promise<void>;
-    /** Commit one namespace mutation behind a single revision fence. */
-    mutate?(ops: SettingsOperation[]): Promise<void>;
-}
-export type SettingsOperation = {
-    op: 'set';
-    path: string[];
-    value: unknown;
-} | {
-    op: 'unset';
-    path: string[];
-};
-//# sourceMappingURL=contracts.d.ts.map

package/lib/types/documents.d.ts

@@ -1,84 +1,8 @@
 import type { HostAgent } from './contracts.ts';
+import type { DocumentMutation, DocumentMutationResult, DocumentRecord, DocumentSearchResult, DocumentSnapshot, DocumentView } from './shared/contracts.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;
-export type DocumentStatus = 'active' | 'archived';
-export interface DocumentRecord {
-    id: string;
-    title: string;
-    description: string;
-    status: DocumentStatus;
-    filename: string;
-    relativePath: string;
-    sourcePaths: string[];
-    sessionIds: string[];
-    createdAt: string;
-    updatedAt: string;
-    lastAccessedAt: string;
-    revision: number;
-    contentHash: string;
-    sizeBytes: number;
-    archivedAt?: string;
-    archiveSummary?: string;
-    memoryBodyIds: string[];
-}
-export interface DocumentView extends DocumentRecord {
-    content: string;
-}
-export interface DocumentSnapshot {
-    workspaceRoot: string;
-    directory: string;
-    indexPath: string;
-    generatedAt: string;
-    revision: string;
-    limitBytes: number;
-    activeBytes: number;
-    activeCount: number;
-    archivedCount: number;
-    total: number;
-    documents: Array<DocumentRecord & {
-        healthy: boolean;
-        excerpt: string;
-    }>;
-}
-export interface DocumentSearchResult {
-    query: string;
-    includeArchived: boolean;
-    total: number;
-    generatedAt: string;
-    results: Array<DocumentView & {
-        score: number;
-        excerpt: string;
-    }>;
-}
-export type DocumentMutation = {
-    action: 'create';
-    title: string;
-    description?: string;
-    content: string;
-    sourcePaths?: string[];
-    sessionIds?: string[];
-} | {
-    action: 'update';
-    id: string;
-    title?: string;
-    description?: string;
-    content?: string;
-    sourcePaths?: string[];
-    sessionIds?: string[];
-};
-export interface DocumentMutationResult {
-    success: true;
-    action: 'created' | 'updated' | 'archived';
-    document: DocumentView;
-    snapshot: DocumentSnapshot;
-    maintenance?: {
-        runId: string;
-        provider: string;
-        summary: string;
-        memoryBodyIds: string[];
-        archivedDocumentIds: string[];
-    };
-}
 export interface DocumentCapacityPlan {
     projected: number;
     limit: number;
@@ -146,4 +70,3 @@ export declare class DocumentManager {
     forWorkspace(workspaceRoot: string): DocumentController;
     forAgent(agent: HostAgent): DocumentController;
 }
-//# sourceMappingURL=documents.d.ts.map

package/lib/types/guidance.d.ts

@@ -9,4 +9,3 @@ export declare function registerGuidance(ctx: HostContextShape, config?: Pick<Re
 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;
-//# sourceMappingURL=guidance.d.ts.map

package/lib/types/index.d.ts

@@ -15,4 +15,3 @@ export { Config, InteractionConfig, resolveConfig, resolveInteractionConfig, Doc
 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;
-//# sourceMappingURL=index.d.ts.map

package/lib/types/lifecycle.d.ts

@@ -3,62 +3,22 @@ import type { HostAgent, 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, type SubagentCounters } from './subagent.ts';
-import { type ReviewActivityScore } from './review-activity.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;
     };
 }
 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";
-export type LifecyclePhase = 'idle' | 'prime' | 'recall' | 'writeback' | 'review' | 'supervised' | 'error';
-export interface LifecycleCounters {
-    primes: number;
-    recallCues: number;
-    writebackCues: number;
-    supervisedRequests: number;
-    failures: number;
-}
-export interface LifecycleAgentSnapshot {
-    sessionId: string;
-    status: 'idle' | 'running';
-    startSource: 'startup' | 'resume' | 'clear' | 'compact' | 'adopted';
-    primePending: boolean;
-    guidedTurns: number;
-    memoryToolCalls: number;
-    idleReviewPending: boolean;
-    reviewRunning: boolean;
-    reviewActivity: ReviewActivityScore;
-    lastPhase: LifecyclePhase;
-    lastReviewAt?: string;
-    lastReviewAction?: string;
-    lastReviewScore?: number;
-    lastReviewDocumentIds?: string[];
-    lastAt?: string;
-    lastError?: string;
-}
-export interface LifecycleSnapshot {
-    enabled: boolean;
-    recallMode: ResolvedConfig['recallMode'];
-    writebackMode: ResolvedConfig['writebackMode'];
-    idleReviewMs: number;
-    activeAgents: number;
-    sessionAvailable: boolean;
-    counters: LifecycleCounters;
-    subagents: SubagentCounters;
-    current?: LifecycleAgentSnapshot;
-}
 export interface SupervisedWritebackResult extends DelegatedWriteResult {
     sessionId: string;
 }
-/** Extracted plain text of one finalized assistant message, when present in the session log. */
-export interface AssistantMessageText {
-    messageId: string;
-    text: string;
-}
 /** DSH-native owner for per-agent Mnemon lifecycle hooks and UI-triggered LLM work. */
 export declare class MnemonLifecycle {
     private readonly ctx;
@@ -67,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;
@@ -80,16 +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;
 }
-//# sourceMappingURL=lifecycle.d.ts.map

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

@@ -63,4 +63,3 @@ export declare class LiveMnemonRuntime {
     private requireWorkspace;
     private workspaceForPath;
 }
-//# sourceMappingURL=live-runtime.d.ts.map

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

@@ -1,29 +1,15 @@
 import type { MnemonRunner } from './runner.ts';
-export interface MemoryBody {
-    id: string;
-    name: string;
-    description: string;
-    active: boolean;
-    dbPath: string;
-    createdAt: string;
-    updatedAt: string;
-}
-export interface CreateMemoryBodyRequest {
-    name: string;
-    description: string;
-    active?: boolean;
-}
-export interface UpdateMemoryBodyRequest {
-    name?: string;
-    description?: string;
-    active?: boolean;
-}
+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;
@@ -31,20 +17,38 @@ 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. */
     reload(): void;
     private loadAndReconcile;
     private reconcileDiscoveredStores;
+    private nativeStoreIds;
     private view;
     private save;
+    private writeRegistry;
 }
-//# sourceMappingURL=memory-bodies.d.ts.map

package/lib/types/pack.d.ts

@@ -1,56 +1,12 @@
 import type { ResolvedConfig } from './config.ts';
 import type { MnemonRunner } from './runner.ts';
+import type { MnemonPackComponent, MnemonPackExport, MnemonPackImportMode, MnemonPackImportResult, MnemonPackPreview, MnemonPackScope } from './shared/contracts.ts';
+export type { MnemonPackComponent, MnemonPackComponentSummary, MnemonPackExport, MnemonPackImportMode, MnemonPackImportResult, MnemonPackManifest, MnemonPackPreview, MnemonPackScope } from './shared/contracts.ts';
 export declare const MNEMON_PACK_FORMAT = "mnemonpack";
 export declare const MNEMON_PACK_VERSION = 1;
 export declare const MNEMON_PACK_MIME = "application/zip";
 export declare const MNEMON_PACK_MAX_ARCHIVE_BYTES: number;
 export declare const MNEMON_PACK_MAX_EXPANDED_BYTES: number;
-declare const COMPONENT_ORDER: readonly ["runtime", "documents", "memory-spaces"];
-export type MnemonPackComponent = typeof COMPONENT_ORDER[number];
-export type MnemonPackScope = 'full' | MnemonPackComponent;
-export type MnemonPackImportMode = 'merge' | 'replace';
-export interface MnemonPackComponentSummary {
-    component: MnemonPackComponent;
-    files: number;
-    bytes: number;
-    items: number;
-}
-export interface MnemonPackManifest {
-    format: typeof MNEMON_PACK_FORMAT;
-    version: typeof MNEMON_PACK_VERSION;
-    scope: MnemonPackScope;
-    exportedAt: string;
-    source: {
-        plugin: 'dsh-mnemon';
-        pluginVersion: string;
-    };
-    components: MnemonPackComponent[];
-    summary: MnemonPackComponentSummary[];
-}
-export interface MnemonPackExport {
-    fileName: string;
-    mimeType: typeof MNEMON_PACK_MIME;
-    bytes: number;
-    base64: string;
-    targetRoot: string;
-    manifest: MnemonPackManifest;
-}
-export interface MnemonPackPreview {
-    fileName?: string;
-    archiveBytes: number;
-    expandedBytes: number;
-    targetRoot: string;
-    targetScope: ResolvedConfig['storageScope'];
-    manifest: MnemonPackManifest;
-    occupied: Record<MnemonPackComponent, boolean>;
-}
-export interface MnemonPackImportResult {
-    imported: true;
-    mode: MnemonPackImportMode;
-    targetRoot: string;
-    components: MnemonPackComponent[];
-    summary: MnemonPackComponentSummary[];
-}
 /** Native, checksummed import/export for the one currently effective Mnemon root. */
 export declare class MnemonPackManager {
     private readonly runner;
@@ -70,5 +26,3 @@ export declare class MnemonPackManager {
         components?: MnemonPackComponent[];
     }): Promise<MnemonPackImportResult>;
 }
-export {};
-//# sourceMappingURL=pack.d.ts.map