dsh-mnemon 0.1.5 → 0.2.0

package/lib/types/process.d.ts

@@ -4,11 +4,13 @@ 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. */
 export declare const runProcess: ProcessRunner;
-//# sourceMappingURL=process.d.ts.map

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/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

@@ -11,7 +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;
-//# 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