dsh-mnemon 0.1.4 → 0.1.6

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

@@ -1,31 +1,41 @@
 import type { JsonValue } from './contracts.ts';
 import type { ResolvedConfig } from './config.ts';
 import { type ProcessRunner } from './process.ts';
+export interface CommandDiscoveryOptions {
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+    isExecutable?: (path: string) => boolean;
+}
 /** Locate the local Mnemon binary without invoking a shell. */
-export declare function findMnemonCommand(config: Pick<ResolvedConfig, 'cliPath'>): string | undefined;
+export declare function findMnemonCommand(config: Pick<ResolvedConfig, 'cliPath'>, options?: CommandDiscoveryOptions): string | undefined;
 export declare class MnemonCliError extends Error {
     readonly exitCode: number | null;
     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

package/lib/types/service.d.ts

@@ -2,154 +2,9 @@ import type { JsonValue } from './contracts.ts';
 import type { ResolvedConfig } from './config.ts';
 import { MemoryBodyRegistry, type CreateMemoryBodyRequest, type MemoryBody, type UpdateMemoryBodyRequest } from './memory-bodies.ts';
 import type { MnemonRunner } from './runner.ts';
-import type { LifecycleSnapshot } from './lifecycle.ts';
-import type { DocumentSnapshot } from './documents.ts';
-import type { StorageScopeCatalog } from './storage-scope.ts';
-export declare const CATEGORIES: readonly ["preference", "decision", "fact", "insight", "context", "general"];
-export type Category = typeof CATEGORIES[number];
-export declare const SOURCES: readonly ["user", "agent", "external"];
-export type Source = typeof SOURCES[number];
-export declare const EDGE_TYPES: readonly ["temporal", "semantic", "causal", "entity"];
-export type EdgeType = typeof EDGE_TYPES[number];
-export declare const INTENTS: readonly ["WHY", "WHEN", "ENTITY", "GENERAL"];
-export type Intent = typeof INTENTS[number];
-export interface Insight {
-    id: string;
-    content: string;
-    category?: string;
-    importance?: number;
-    tags?: string[];
-    entities?: string[];
-    source?: string;
-    score?: number;
-    confidence?: string;
-    intent?: string;
-    matchedVia?: string;
-    createdAt?: string;
-    depth?: number;
-    edgeType?: string;
-    memoryBodyId?: string;
-    memoryBodyName?: string;
-}
-export interface SearchRequest {
-    query: string;
-    mode?: 'smart' | 'keyword' | 'basic';
-    limit?: number;
-    category?: Category;
-    source?: Source;
-    intent?: Intent;
-    memoryBodyIds?: string[];
-}
-export interface RememberRequest {
-    content: string;
-    category?: Category;
-    importance?: number;
-    tags?: string[];
-    entities?: string[];
-    source?: Source;
-    memoryBodyId?: string;
-}
-export interface MemoryBodyStats {
-    totalInsights: number;
-    deletedInsights: number;
-    edgeCount: number;
-    oplogCount: number;
-    dbSizeBytes: number;
-    byCategory: Record<string, number>;
-    topEntities: Array<{
-        entity: string;
-        count: number;
-    }>;
-}
-export interface MemoryBodyView extends MemoryBody {
-    healthy: boolean;
-    error?: string;
-    stats?: MemoryBodyStats;
-}
-export interface MemoryBodyCatalog {
-    items: MemoryBodyView[];
-    total: number;
-    activeCount: number;
-    directory: string;
-    generatedAt: string;
-}
-export interface StatusView {
-    healthy: boolean;
-    error?: string;
-    version?: string;
-    dshMnemonVersion?: string;
-    cliPath: string;
-    commandFound: boolean;
-    dataDir: string;
-    store: string;
-    writeEnabled: boolean;
-    timeoutMs: number;
-    defaultRecallLimit: number;
-    memoryBodyDirectory: string;
-    memoryBodies: MemoryBodyView[];
-    lifecycle?: LifecycleSnapshot;
-    documents?: DocumentSnapshot;
-    storage?: StorageScopeCatalog;
-    workspaceContext?: {
-        mode: 'global' | 'workspace' | 'custom';
-        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 interface MemoryGraphNode extends Insight {
-    color: string;
-    graphId?: string;
-    kind?: 'memory' | 'entity' | 'space';
-    memoryBodyIds?: string[];
-    memoryBodyNames?: string[];
-    occurrenceCount?: number;
-}
-export interface MemoryGraphEdge {
-    sourceId: string;
-    targetId: string;
-    label: string;
-    color: string;
-    type?: EdgeType | 'scope';
-}
-export interface MemoryGraphSnapshot {
-    nodes: MemoryGraphNode[];
-    edges: MemoryGraphEdge[];
-    generatedAt: string;
-    memoryBodies?: Array<Pick<MemoryBody, 'id' | 'name' | 'active'>>;
-}
-export interface MemoryListRequest {
-    query?: string;
-    category?: Category;
-    limit?: number;
-    memoryBodyIds?: string[];
-}
-export interface MemoryListView {
-    items: MemoryGraphNode[];
-    total: number;
-    generatedAt: string;
-}
-export interface EntityView {
-    items: Array<{
-        entity: string;
-        count: number;
-    }>;
-    insights: Insight[];
-    selected?: string;
-}
+import { type EdgeType, type EntityView, type Insight, type MemoryBodyCatalog, type MemoryGraphSnapshot, type MemoryListRequest, type MemoryListView, type RememberRequest, type SearchRequest, type StatusView } from './shared/contracts.ts';
+export { CATEGORIES, EDGE_TYPES, INTENTS, SOURCES } from './shared/contracts.ts';
+export type { Category, EdgeType, EntityView, Insight, Intent, MemoryBodyCatalog, MemoryBodyStats, MemoryBodyView, MemoryGraphEdge, MemoryGraphNode, MemoryGraphSnapshot, MemoryListRequest, MemoryListView, RememberRequest, SearchRequest, Source, StatusView, } from './shared/contracts.ts';
 /** Parse the official Mnemon vis.js export without executing its HTML or loading its CDN script. */
 export declare function parseMemoryGraph(html: string, now?: Date): MemoryGraphSnapshot;
 export declare class MnemonService {
@@ -188,4 +43,3 @@ export declare class MnemonService {
     private activateAfterWrite;
     private assertWritable;
 }
-//# sourceMappingURL=service.d.ts.map

package/lib/types/settings.d.ts

@@ -1,7 +1,4 @@
 import type { HostConnectionHandle, HostRpcHandler, HostSettingsService } from './contracts.ts';
-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 { MNEMON_SETTINGS_CHANNEL, MNEMON_SETTINGS_NAMESPACE, MNEMON_UI_SETTINGS_NAMESPACE } from './shared/contracts.ts';
 export declare function createSettingsHandler(settings: HostSettingsService): HostRpcHandler;
 export declare function registerSettingsRpc(connection: HostConnectionHandle, settings: HostSettingsService): void;
-//# sourceMappingURL=settings.d.ts.map