dsh-mnemon 0.1.5 → 0.1.6

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: {
@@ -232,31 +202,3 @@ export interface HostContextShape {
     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,21 @@ 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 } from './shared/contracts.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;
@@ -92,4 +51,3 @@ export declare class MnemonLifecycle {
     private liveAgent;
     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,23 +1,6 @@
 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 { CreateMemoryBodyRequest, MemoryBody, UpdateMemoryBodyRequest } from './shared/contracts.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.
@@ -44,7 +27,7 @@ export declare class MemoryBodyRegistry {
     reload(): void;
     private loadAndReconcile;
     private reconcileDiscoveredStores;
+    private nativeStoreIds;
     private view;
     private save;
 }
-//# 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

package/lib/types/process.d.ts

@@ -11,4 +11,3 @@ export interface ProcessOptions {
 export type ProcessRunner = (command: string, args: readonly string[], options: ProcessOptions) => Promise<ProcessResult>;
 /** Spawn without a shell, with bounded output and cooperative cancellation. */
 export declare const runProcess: ProcessRunner;
-//# sourceMappingURL=process.d.ts.map

package/lib/types/review-activity.d.ts

@@ -14,20 +14,6 @@ export declare const QODERWORK_REVIEW_POLICY: Readonly<{
     toolDiversityScoreCap: 2;
     turnScore: 1;
 }>;
-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 declare function scoreReviewActivity(activity: ReviewActivity): ReviewActivityScore;
-//# sourceMappingURL=review-activity.d.ts.map
+import type { ReviewActivity, ReviewActivityScore } from './shared/contracts.ts';
+export type { ReviewActivity, ReviewActivityScore } from './shared/contracts.ts';

package/lib/types/rpc.d.ts

@@ -14,4 +14,3 @@ export declare function createWriteHandler(input: RuntimeInput, lifecycle?: Mnem
 export declare function createPackHandler(manager: MnemonPackManager, 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;
-//# sourceMappingURL=rpc.d.ts.map

package/lib/types/runner.d.ts

@@ -14,24 +14,28 @@ export declare class MnemonCliError extends Error {
     readonly stderr: string;
     constructor(message: string, exitCode?: number | null, stderr?: string);
 }
+export interface MnemonRunOptions {
+    signal?: AbortSignal;
+    globalFlags?: boolean;
+    store?: string;
+}
+export interface MnemonTextCommand {
+    args: readonly string[];
+    options?: MnemonRunOptions;
+}
 export interface MnemonRunner {
     readonly command: string;
     readonly commandFound: boolean;
     readonly config: ResolvedConfig;
-    runJson(args: readonly string[], options?: {
-        signal?: AbortSignal;
-        globalFlags?: boolean;
-        store?: string;
-    }): Promise<JsonValue>;
-    runText(args: readonly string[], options?: {
-        signal?: AbortSignal;
-        globalFlags?: boolean;
-        store?: string;
-    }): Promise<string>;
+    runJson(args: readonly string[], options?: MnemonRunOptions): Promise<JsonValue>;
+    runText(args: readonly string[], options?: MnemonRunOptions): Promise<string>;
+    /** Run related CLI commands consecutively without allowing queued work between them. */
+    runTextBatch(commands: readonly MnemonTextCommand[]): Promise<string[]>;
     /** Run one operation after all CLI work and hold the same queue until it settles. */
     withExclusive<T>(operation: () => T | Promise<T>): Promise<T>;
     effectiveDataDir(): string;
+    /** Read Mnemon's persisted active-file selection, ignoring config and environment overrides. */
+    persistedStore(): string;
     effectiveStore(): string;
 }
 export declare function createRunner(config: ResolvedConfig, processRunner?: ProcessRunner, workspaceRoot?: string): MnemonRunner;
-//# sourceMappingURL=runner.d.ts.map

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

@@ -1,68 +1,12 @@
 import type { MnemonRunner } from './runner.ts';
+import type { RuntimeMemoryCompactedEntry, 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;
 export declare const RUNTIME_ENTRY_DELIMITER = "\n\u00A7\n";
 export declare const RUNTIME_MEMORY_LIMITS: {
     readonly memory: number;
     readonly user: number;
 };
-export type RuntimeMemoryTarget = keyof typeof RUNTIME_MEMORY_LIMITS;
-export type RuntimeMemoryImportance = 'critical' | 'normal' | 'low';
-export type RuntimeMemoryAction = 'add' | 'replace' | 'remove';
-export interface RuntimeMemoryEntry {
-    content: string;
-    created_at: string;
-    updated_at: string;
-    target: RuntimeMemoryTarget;
-    importance: RuntimeMemoryImportance;
-}
-export interface RuntimeMemoryUsage {
-    used: number;
-    limit: number;
-}
-export interface RuntimeMemoryTargetView extends RuntimeMemoryUsage {
-    target: RuntimeMemoryTarget;
-    entryCount: number;
-    markdownPath: string;
-}
-export interface RuntimeMemorySnapshot {
-    directory: string;
-    sourcePath: string;
-    revision: string;
-    generatedAt: string;
-    entries: RuntimeMemoryEntry[];
-    targets: Record<RuntimeMemoryTarget, RuntimeMemoryTargetView>;
-}
-export interface RuntimeMemoryCompactedEntry {
-    content: string;
-    importance: RuntimeMemoryImportance;
-}
-export interface RuntimeMemoryMutation {
-    action: RuntimeMemoryAction;
-    target: RuntimeMemoryTarget;
-    content?: string;
-    oldText?: string;
-    importance?: RuntimeMemoryImportance;
-}
-export type RuntimeMemoryMutationResult = {
-    success: true;
-    message: string;
-    target: RuntimeMemoryTarget;
-    entryCount: number;
-    usage: RuntimeMemoryUsage;
-    added?: string;
-    replaced?: {
-        from: string;
-        to: string;
-    };
-    removed?: string;
-    maintenance?: {
-        kind: 'local-compaction' | 'mnemon-archive';
-        runId: string;
-        provider: string;
-        summary: string;
-        memoryBodyIds: string[];
-    };
-};
 export declare class RuntimeMemoryCapacityError extends Error {
     readonly target: RuntimeMemoryTarget;
     readonly used: number;
@@ -101,4 +45,3 @@ export declare class RuntimeMemoryController {
     private repairProjections;
     private withLock;
 }
-//# sourceMappingURL=runtime-memory.d.ts.map