dsh-mnemon 0.4.7 → 0.5.0

package/lib/types/src/host/protocol.d.ts

@@ -0,0 +1,549 @@
+/** Starter Entry ids remain reserved when DSH nests them under an include. */
+export declare function isDefaultSourceInstance(instanceKey: string, sourceTypeId: string): boolean;
+export type MemoryParticipationMode = 'off' | 'manual' | 'automatic';
+export type MemoryParticipationChannel = 'recall' | 'write' | 'projection' | 'maintenance';
+export type MemoryLayerParticipation = Record<MemoryParticipationChannel, MemoryParticipationMode>;
+export interface MemoryTopologyDefinition {
+    id: string;
+    strategyId: string;
+    layers: Array<ResolvedMemoryLayerConfig & {
+        id: string;
+    }>;
+}
+export interface MemoryCompositionStatus {
+    evaluation: import('../core/contracts/index.ts').MemoryCompositionEvaluationReport;
+    sources: MemorySourceManagementInstance[];
+    configuration: ResolvedMemoryTopologyConfig;
+}
+import type { RecallQualityConfig, ResolvedRecallQualityConfig, MnemonEmbeddingConfig, ResolvedMnemonEmbeddingConfig } from 'dsh-mnemon-source-memory-spaces/contracts';
+import type { MemoryPersistenceStrategy, ResolvedMemoryPersistenceStrategy, MemoryProviderRuntimeStatus, MemoryBodyStats, MemoryBodyView } from 'dsh-mnemon-source-memory-spaces/contracts';
+import type { ConnectionHandle as DshClientConnectionHandle } from '@deepseek-ai/dsh-client-connection/client';
+import type { DocumentSnapshot } from 'dsh-mnemon-source-documents/contracts';
+export declare const MNEMON_READ_CHANNEL = "/dsh-mnemon-read";
+export declare const MNEMON_ACTIVATION_CHANNEL = "/dsh-mnemon-activation";
+export declare const MNEMON_WRITE_CHANNEL = "/dsh-mnemon-write";
+export declare const MNEMON_PACK_CHANNEL = "/dsh-mnemon-pack";
+export declare const MNEMON_SETTINGS_CHANNEL = "/dsh-mnemon-settings";
+export declare const MNEMON_SETTINGS_NAMESPACE = "mnemon";
+export declare const MNEMON_UI_SETTINGS_NAMESPACE = "mnemon-ui";
+export * from './view-protocol.ts';
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export interface MemorySourceManagementField {
+    key: string;
+    label: string;
+    description?: string;
+    input: 'text' | 'number' | 'boolean' | 'url' | 'secret' | 'select';
+    required: boolean;
+    secret?: boolean;
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+}
+/** Browser-safe descriptor of one Source instance visible in the current scope. */
+export interface MemorySourceManagementInstance {
+    sourceInstanceKey: string;
+    sourceTypeId: string;
+    packageName: string;
+    role: string;
+    availability: 'ready' | 'degraded' | 'unavailable';
+    revision: string;
+    capabilities: string[];
+    assistance?: readonly string[];
+    management: {
+        label: string;
+        description: string;
+        fields?: MemorySourceManagementField[];
+        diagnostics?: string[];
+    };
+    hints?: JsonValue;
+}
+export interface MemorySourceManagementCatalog {
+    generationId: string;
+    sources: MemorySourceManagementInstance[];
+}
+export interface MemorySourceManagementResult {
+    revision: string;
+    value: JsonValue;
+}
+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 plus the transport boundary needed to gate local-only writes. */
+export type ClientConnectionHandle = Pick<DshClientConnectionHandle, 'rpc'> & Partial<Pick<DshClientConnectionHandle, 'isLoopback'>>;
+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>;
+    mutate?(ops: SettingsOperation[]): Promise<void>;
+}
+export type SettingsOperation = {
+    op: 'set';
+    path: string[];
+    value: unknown;
+} | {
+    op: 'unset';
+    path: string[];
+};
+export type StorageScopeKind = 'global' | 'workspace' | 'custom';
+export interface MemoryLayerConfig {
+    enabled?: boolean;
+    participation?: Partial<MemoryLayerParticipation>;
+    adapterIds?: string[];
+}
+export interface MemoryTopologyConfig {
+    id?: string;
+    strategyId?: string;
+    layers?: Record<string, MemoryLayerConfig>;
+}
+export interface ResolvedMemoryLayerConfig {
+    enabled: boolean;
+    participation: MemoryLayerParticipation;
+    adapterIds: string[];
+}
+export interface ResolvedMemoryTopologyConfig {
+    id: string;
+    strategyId: string;
+    layers: Record<string, ResolvedMemoryLayerConfig>;
+}
+export interface CustomPackConfig {
+    id: string;
+    name: string;
+    dataDir: string;
+}
+export interface RuntimeMemoryConfig {
+    /** Maximum UTF-8 bytes projected into MEMORY.md. */
+    memoryLimitBytes?: number;
+    /** Maximum UTF-8 bytes projected into USER.md. */
+    userLimitBytes?: number;
+    /** Completion-token budget for Runtime migration and compaction workers. */
+    maintenanceMaxTokens?: number;
+}
+export interface ResolvedRuntimeMemoryConfig {
+    memoryLimitBytes: number;
+    userLimitBytes: number;
+    maintenanceMaxTokens: number;
+}
+export { normalizeDisplayMode } from './display-mode.ts';
+export type MnemonDisplayMode = 'sidebar' | 'builtin';
+export interface Config {
+    storageScope?: StorageScopeKind;
+    /** Whether USER.md follows the selected storage root or stays in the global root. */
+    runtimeUserScope?: 'storage' | 'global';
+    cliPath?: string;
+    dataDir?: string;
+    customPackId?: string;
+    customPacks?: CustomPackConfig[];
+    store?: string;
+    timeoutMs?: number;
+    defaultRecallLimit?: number;
+    runtimeMemory?: RuntimeMemoryConfig;
+    /** Optional DSH-owned overrides injected into every Mnemon CLI process. */
+    embedding?: MnemonEmbeddingConfig;
+    memoryTopology?: MemoryTopologyConfig;
+    recallQuality?: RecallQualityConfig;
+    routingGuidance?: boolean;
+    /** Entry placement only. Legacy `buildin` input is migrated to `builtin`. */
+    displayMode?: MnemonDisplayMode | 'buildin';
+    tabEnabled?: boolean;
+    writeEnabled?: boolean;
+    /** DSH rc.2 management-channel authority; ignored by DSH 0.1.2-alpha.1. */
+    remoteAccess?: 'read-only' | 'trusted-host';
+    lifecycleEnabled?: boolean;
+    recallMode?: 'guided' | 'off';
+    writebackMode?: 'guided' | 'off';
+    idleReviewMs?: number;
+    conversationInteraction?: {
+        toolviews?: boolean;
+        turnBar?: boolean;
+        saveAction?: boolean;
+    };
+    /** Provider policy used when an Agent must create a new Memory Space while distilling memory. */
+    persistenceStrategy?: MemoryPersistenceStrategy;
+    /** Model route used by clean, session-independent maintenance Agents. */
+    taskAgentModel?: TaskAgentModelConfig;
+}
+export interface TaskAgentModelConfig {
+    mode?: 'inherit' | 'fixed';
+    provider?: string;
+    model?: string;
+}
+export interface ResolvedTaskAgentModelConfig {
+    mode: 'inherit' | 'fixed';
+    provider?: string;
+    model?: string;
+}
+export interface TaskAgentModelCatalogModel {
+    id: string;
+    name: string;
+    description?: string;
+    /** DSH's merge-extensible model modality ids; absent means capability is unknown. */
+    inputModalities?: string[];
+}
+export interface TaskAgentModelCatalogGroup {
+    id: string;
+    name: string;
+    models: TaskAgentModelCatalogModel[];
+}
+export interface TaskAgentModelCatalogFailure {
+    id: string;
+    name: string;
+    message: string;
+}
+export interface TaskAgentModelCatalog {
+    effective?: {
+        provider: string;
+        model: string;
+        source: 'fixed' | 'dsh-default' | 'active-agent';
+    };
+    defaultSelection?: {
+        provider: string;
+        model: string;
+    };
+    groups: TaskAgentModelCatalogGroup[];
+    failures: TaskAgentModelCatalogFailure[];
+}
+export interface InteractionConfig {
+    turnBar?: boolean;
+    saveAction?: boolean;
+}
+export interface ResolvedConfig {
+    storageScope: StorageScopeKind;
+    runtimeUserScope: 'storage' | 'global';
+    cliPath?: string;
+    dataDir?: string;
+    store?: string;
+    timeoutMs: number;
+    defaultRecallLimit: number;
+    runtimeMemory: ResolvedRuntimeMemoryConfig;
+    embedding: ResolvedMnemonEmbeddingConfig;
+    memoryTopology: ResolvedMemoryTopologyConfig;
+    recallQuality: ResolvedRecallQualityConfig;
+    routingGuidance: boolean;
+    displayMode: MnemonDisplayMode;
+    tabEnabled: boolean;
+    writeEnabled: boolean;
+    /** DSH rc.2 management-channel authority; ignored by DSH 0.1.2-alpha.1. */
+    remoteAccess: 'read-only' | 'trusted-host';
+    lifecycleEnabled: boolean;
+    recallMode: 'guided' | 'off';
+    writebackMode: 'guided' | 'off';
+    idleReviewMs: number;
+    conversationInteraction: {
+        toolviews: boolean;
+        turnBar: boolean;
+        saveAction: boolean;
+    };
+    persistenceStrategy: ResolvedMemoryPersistenceStrategy;
+    taskAgentModel: ResolvedTaskAgentModelConfig;
+}
+export interface ResolvedInteractionConfig {
+    turnBar: boolean;
+    saveAction: boolean;
+}
+/**
+ * Provider instance identity inside one Memory Spaces Source. Built-in ids
+ * remain stable; third-party child modules may contribute additional ids.
+ */
+export type * from 'dsh-mnemon-source-memory-spaces/contracts';
+export type * from 'dsh-mnemon-source-documents/contracts';
+export type * from 'dsh-mnemon-source-runtime/contracts';
+export interface TurnMemoryActivity {
+    turn: number;
+    count: number;
+    names: string[];
+    recalls: number;
+    writes: number;
+    documentSearches: number;
+    inspections: number;
+    failures: number;
+    /** Successful evidence-bearing reads with tool-authored safe previews. */
+    retrieved: MemoryActivityRead[];
+    /** Only writes whose tool-authored result confirms durable commitment. */
+    writebacks: MemoryActivityWriteback[];
+}
+export interface MemoryActivityItem {
+    id: string;
+    title: string;
+    excerpt?: string;
+}
+export interface MemoryActivityRead {
+    callId: string;
+    toolName: string;
+    operationId: string;
+    reference?: string;
+    sourceTypeId?: string;
+    items: MemoryActivityItem[];
+}
+export interface MemoryActivityWriteback {
+    callId: string;
+    toolName: string;
+    operationId: string;
+    reference?: string;
+    sourceTypeId?: string;
+    item: MemoryActivityItem;
+}
+export interface TurnMemoryActivitySnapshot {
+    cursor: number;
+    activities: TurnMemoryActivity[];
+}
+export interface AssistantMessageText {
+    messageId: string;
+    text: string;
+}
+export type StorageAreaKind = 'runtime' | 'memory-bodies' | 'documents' | 'state';
+export type StorageAreaStatus = 'ready' | 'empty' | 'missing' | 'invalid';
+export interface StorageAreaInventory {
+    kind: StorageAreaKind;
+    path: string;
+    status: StorageAreaStatus;
+    bytes: number;
+    itemCount: number;
+    details: Record<string, number | string | boolean>;
+    issue?: string;
+}
+export interface StorageScopeInventory {
+    kind: StorageScopeKind;
+    root?: string;
+    configured: boolean;
+    active: boolean;
+    available: boolean;
+    totalBytes: number;
+    areas: StorageAreaInventory[];
+    issue?: string;
+}
+export interface StorageScopeCatalog {
+    activeKind: StorageScopeKind;
+    activeRoot: string;
+    scopes: StorageScopeInventory[];
+    generatedAt: string;
+}
+export interface ReviewActivity {
+    totalUserTextLength: number;
+    turnCount: number;
+    toolCallCount: number;
+    uniqueToolCount: number;
+}
+export interface ReviewActivityScore extends ReviewActivity {
+    textLengthScore: number;
+    turnScore: number;
+    toolCallScore: number;
+    toolDiversityScore: number;
+    score: number;
+    threshold: number;
+    eligible: boolean;
+}
+export interface SubagentCounters {
+    recalls: number;
+    writes: number;
+    answers: number;
+    reviews: number;
+    placements: number;
+    migrations: number;
+    compactions: number;
+    documentArchives: number;
+    metadataMaintenances: number;
+    failures: number;
+    lastRunId?: string;
+    lastOperation?: 'recall' | 'write' | 'review' | 'placement' | 'migration' | 'compaction' | 'document-archive' | 'metadata-maintenance';
+    lastAt?: string;
+}
+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: 'guided' | 'off';
+    writebackMode: 'guided' | 'off';
+    idleReviewMs: number;
+    activeAgents: number;
+    sessionAvailable: boolean;
+    /** A session-independent task Agent can be created for WebUI maintenance. */
+    taskAgentAvailable: boolean;
+    counters: LifecycleCounters;
+    subagents: SubagentCounters;
+    current?: LifecycleAgentSnapshot;
+}
+export interface StatusView {
+    healthy: boolean;
+    error?: string;
+    version?: string;
+    dshMnemonVersion?: string;
+    cliPath: string;
+    commandFound: boolean;
+    dataDir: string;
+    /** Legacy comma-separated DSH-enabled Store list. */
+    store: string;
+    mnemonDefaultStore: string;
+    dshActiveStores: string[];
+    writeEnabled: boolean;
+    timeoutMs: number;
+    defaultRecallLimit: number;
+    recallQuality: ResolvedRecallQualityConfig;
+    memoryBodyDirectory: string;
+    memoryBodies: MemoryBodyView[];
+    providerServices?: MemoryProviderRuntimeStatus[];
+    memorySystem?: MemoryCompositionStatus;
+    lifecycle?: LifecycleSnapshot;
+    documents?: DocumentSnapshot;
+    storage?: StorageScopeCatalog;
+    workspaceContext?: {
+        mode: StorageScopeKind;
+        selectedRoot: string;
+        effectiveRoot: string;
+        aligned: boolean;
+        selectedWorkspace?: {
+            id: string;
+            title: string;
+            path: string;
+        };
+        effectiveWorkspace?: {
+            id: string;
+            title: string;
+            path: string;
+        };
+    };
+    stats?: MemoryBodyStats & {
+        dbPath?: string;
+    };
+}
+export type MnemonPackComponent = 'runtime' | 'documents' | 'memory-spaces';
+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: 'mnemonpack';
+    version: 1;
+    scope: MnemonPackScope;
+    exportedAt: string;
+    source: {
+        plugin: 'dsh-mnemon';
+        pluginVersion: string;
+    };
+    components: MnemonPackComponent[];
+    summary: MnemonPackComponentSummary[];
+}
+export interface MnemonPackExport {
+    fileName: string;
+    mimeType: 'application/zip';
+    bytes: number;
+    base64: string;
+    targetRoot: string;
+    manifest: MnemonPackManifest;
+}
+export interface MnemonPackPreview {
+    fileName?: string;
+    archiveBytes: number;
+    expandedBytes: number;
+    targetRoot: string;
+    targetScope: StorageScopeKind;
+    manifest: MnemonPackManifest;
+    occupied: Record<MnemonPackComponent, boolean>;
+}
+export interface MnemonPackImportResult {
+    imported: true;
+    mode: MnemonPackImportMode;
+    targetRoot: string;
+    components: MnemonPackComponent[];
+    summary: MnemonPackComponentSummary[];
+}
+export type VersionComponentId = 'mnemon' | 'dsh-mnemon';
+export type VersionInstallMode = 'homebrew' | 'go' | 'npm' | 'link' | 'manual' | 'missing';
+export interface VersionComponentStatus {
+    id: VersionComponentId;
+    name: string;
+    executablePath?: string;
+    installPath?: string;
+    installProfile?: string;
+    current?: string;
+    latest?: string;
+    outdated: boolean;
+    installMode: VersionInstallMode;
+    updateSupported: boolean;
+    updateHint: string;
+    checkError?: string;
+}
+export interface VersionStatus {
+    checkedAt: string;
+    components: VersionComponentStatus[];
+}
+export interface VersionUpdateResult {
+    component: VersionComponentId;
+    previousVersion?: string;
+    currentVersion?: string;
+    updated: boolean;
+    restartRequired: boolean;
+    output?: string;
+}
+export declare const CATEGORIES: readonly ["preference", "decision", "fact", "insight", "context", "general"];
+export declare const SOURCES: readonly ["user", "agent", "external"];
+export declare const EDGE_TYPES: readonly ["temporal", "semantic", "causal", "entity"];
+export declare const INTENTS: readonly ["WHY", "WHEN", "ENTITY", "GENERAL"];
+export declare const DEFAULT_EMBEDDING_ENDPOINT = "http://localhost:11434";
+export declare const DEFAULT_EMBEDDING_MODEL = "nomic-embed-text";
+export declare const DEFAULT_EMBEDDING_PROTOCOL = "auto";
+export declare const MNEMON_EMBEDDING_PROTOCOLS: readonly ["auto", "ollama", "openai"];

package/lib/types/src/host/view-protocol.d.ts

@@ -0,0 +1,123 @@
+import type { MemoryJsonValue, MemoryPluginLocalizedText, MemoryPluginRole, MemoryViewGuidance, MemoryViewSourcePresentation } from '../core/contracts/index.ts';
+import type { TurnMemoryActivity } from './protocol.ts';
+import type { MemoryStrategyConfigurationField } from '../sdk/strategy-configuration.ts';
+export declare const MNEMON_VIEW_CHANNEL = "/dsh-mnemon-view";
+export declare const MNEMON_VIEW_WRITE_CHANNEL = "/dsh-mnemon-view-settings";
+export declare const MNEMON_VIEW_SETTINGS_NAMESPACE = "mnemon-view";
+export interface MemoryPluginPreference {
+    enabled: boolean;
+    config: Record<string, MemoryJsonValue>;
+}
+export interface MemoryViewPreferences {
+    strategyTypeId?: string;
+    entries: Record<string, MemoryPluginPreference>;
+}
+export interface MemoryPluginEntryView {
+    entryId: string;
+    packageName: string;
+    roles: MemoryPluginRole[];
+    typeId?: string;
+    strategyTypeId?: string;
+    slot?: string;
+    label: MemoryPluginLocalizedText;
+    description: MemoryPluginLocalizedText;
+    provides: Array<{
+        id: string;
+        exclusive: boolean;
+    }>;
+    requires: string[];
+    requiredBy: string[];
+    fields: readonly MemoryStrategyConfigurationField[];
+    enabled: boolean;
+    active: boolean;
+    writable: boolean;
+    config: Record<string, MemoryJsonValue>;
+    diagnostic?: string;
+}
+/** Browser read model, not a serialized authority envelope. No readGrants. */
+export interface MemoryViewInspection {
+    id: string;
+    digest: string;
+    generationId: string;
+    createdAt: string;
+    turn?: number;
+    state: 'active' | 'recent' | 'preview';
+    strategyTypeId: string;
+    strategyInstanceKey: string;
+    extensions: Array<{
+        instanceKey: string;
+        typeId: string;
+        slot: string;
+        digest: string;
+    }>;
+    projection: Array<{
+        id: string;
+        sourceInstanceKey: string;
+        mode: string;
+        text: string;
+        revision: string;
+    }>;
+    sourcePresentations?: MemoryViewSourcePresentation[];
+    routes: Array<{
+        id: string;
+        sourceInstanceKey: string;
+        operationId: string;
+        description: string;
+        maxCalls: number;
+    }>;
+    actions: Array<{
+        id: string;
+        sourceInstanceKey: string;
+        operationId: string;
+        description: string;
+    }>;
+    memoryText: string;
+    guidance?: MemoryViewGuidance;
+    diagnostics: string[];
+}
+export interface MemoryViewDashboard {
+    revision: string;
+    writable: boolean;
+    strategyTypeId: string;
+    entries: MemoryPluginEntryView[];
+    current?: MemoryViewInspection;
+    /** Durable activity observed after the frozen current View was compiled. */
+    activity?: TurnMemoryActivity;
+    currentUnavailable?: 'no-session' | 'unaligned' | 'not-generated';
+    sources: Array<{
+        sourceInstanceKey: string;
+        sourceTypeId: string;
+        packageName: string;
+        role: string;
+        label: string;
+    }>;
+    pluginInstallation: MemoryPluginInstallationEnvironment;
+    diagnostics: string[];
+}
+export interface MemoryViewConfigurationRequest {
+    expectedRevision: string;
+    strategyTypeId: string;
+    entries: Record<string, MemoryPluginPreference>;
+}
+export type MemoryPluginKind = 'source' | 'strategy';
+export interface MemoryPluginInstallationEnvironment {
+    supported: boolean;
+    profileName?: string;
+    reason?: 'loader-unavailable' | 'profile-unavailable' | 'cli-unavailable';
+    suggestions: string[];
+}
+export interface MemoryPluginInspection {
+    packageName: string;
+    version: string;
+    kind: MemoryPluginKind;
+    description?: string;
+    mnemonPeerRange: string;
+    installed: boolean;
+}
+export interface MemoryPluginInstallResult {
+    packageName: string;
+    version: string;
+    profileName: string;
+    installed: true;
+    restartRequired: true;
+}

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

@@ -1,21 +1,2 @@
-import { Config, InteractionConfig, resolveConfig, resolveInteractionConfig, type Config as MnemonConfig } from './config.ts';
-import { DocumentManager } from './documents.ts';
-import { createRuntimeGraph, LiveMnemonRuntime } from './live-runtime.ts';
-import { MnemonLifecycle } from './lifecycle.ts';
-import { createRunner } from './runner.ts';
-import { RuntimeMemoryController } from './runtime-memory.ts';
-import { MnemonService } from './service.ts';
-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, 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;
+export { name, inject, provide, Config, apply } from './host/plugin.ts';
+export type { MnemonConfig } from './host/plugin.ts';