dsh-mnemon 0.4.7 → 0.5.0

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

@@ -1,41 +0,0 @@
-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'>, 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?: 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;

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

@@ -1,90 +0,0 @@
-import type { MnemonRunner } from './runner.ts';
-import type { AuthorityCommitRecorder } from './memory-receipts.ts';
-import type { MemoryMigrationLineage } from '../packages/contracts/src/index.ts';
-import type { RuntimeMemoryAction, RuntimeMemoryCompactedEntry, RuntimeMemoryEntry, 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 interface RuntimeMemoryLimits {
-    readonly memory: number;
-    readonly user: number;
-}
-export declare const RUNTIME_MEMORY_LIMITS: RuntimeMemoryLimits;
-export declare const RUNTIME_MEMORY_PROTOCOL: string;
-export interface RuntimeMemoryContextProjection {
-    revision: string;
-    text: string;
-}
-/** Host-only plan for capacity maintenance; this is not exposed as a Tool or RPC action. */
-export interface RuntimeMemoryMaintenancePlan {
-    revision: string;
-    action: RuntimeMemoryAction;
-    target: RuntimeMemoryTarget;
-    entries: RuntimeMemoryEntry[];
-    pending?: RuntimeMemoryCompactedEntry;
-    excluded?: RuntimeMemoryEntry;
-    used: number;
-    projected: number;
-    limit: number;
-    requiresMaintenance: boolean;
-}
-export declare class RuntimeMemoryCapacityError extends Error {
-    readonly target: RuntimeMemoryTarget;
-    readonly used: number;
-    readonly projected: number;
-    readonly limit: number;
-    constructor(target: RuntimeMemoryTarget, used: number, projected: number, limit: number);
-}
-export declare class RuntimeMemoryConflictError extends Error {
-    constructor();
-}
-export declare const RUNTIME_BRANCH_NAME_MAX = 128;
-export declare const RUNTIME_BRANCHES_PER_ENTRY_MAX = 16;
-/** Validate a model-supplied branch scope. Returns the normalized list; an empty list means "no scope". */
-export declare function normalizeRuntimeBranches(value: unknown, field?: string): string[];
-/**
- * Single authority for hot memory. JSON is the durable source of truth;
- * Markdown files are deterministic projections consumed by prompt assembly.
- */
-export declare class RuntimeMemoryController {
-    private readonly now;
-    private readonly recordCommit?;
-    readonly directory: string;
-    readonly sourcePath: string;
-    readonly userSourcePath: string;
-    readonly memoryPath: string;
-    readonly userPath: string;
-    readonly lockPath: string;
-    readonly limits: RuntimeMemoryLimits;
-    private queue;
-    private readonly localUserPath;
-    private readonly userController;
-    constructor(runner: Pick<MnemonRunner, 'effectiveDataDir'>, now?: () => Date, recordCommit?: AuthorityCommitRecorder | undefined, limits?: RuntimeMemoryLimits, userRunner?: Pick<MnemonRunner, 'effectiveDataDir'>);
-    snapshot(): RuntimeMemorySnapshot;
-    contextText(branch?: string): string;
-    /**
-     * Read the exact Runtime revision and its prompt projection from each
-     * configured authority root.
-     * When a git branch is supplied, target=memory entries scoped to other
-     * branches are hidden from the projection; the on-disk Markdown files and
-     * the source JSON always remain complete.
-     */
-    contextProjection(branch?: string): RuntimeMemoryContextProjection;
-    private localContextProjection;
-    mutate(request: RuntimeMemoryMutation): Promise<RuntimeMemoryMutationResult>;
-    /** Resolve exactly which committed entries survive a blocked mutation and are safe to compact. */
-    planMaintenance(request: RuntimeMemoryMutation): Promise<RuntimeMemoryMaintenancePlan>;
-    /** Commit semantic compaction and the original mutation together, or leave every local file unchanged. */
-    compactAndMutate(expectedRevision: string, request: RuntimeMemoryMutation, compacted: RuntimeMemoryCompactedEntry[], maxCompactedBytes?: number, lineage?: readonly MemoryMigrationLineage[]): Promise<RuntimeMemoryMutationResult>;
-    /** Apply an LLM-produced compaction only to the exact snapshot it reviewed. */
-    compactTarget(expectedRevision: string, target: RuntimeMemoryTarget, compacted: RuntimeMemoryCompactedEntry[], maxBytes?: number, lineage?: readonly MemoryMigrationLineage[]): Promise<RuntimeMemorySnapshot>;
-    private initialize;
-    private mutateLocked;
-    private result;
-    private targetView;
-    private snapshotUnlocked;
-    private readSource;
-    private persist;
-    private repairProjections;
-    private withLock;
-}

package/lib/types/src/search-tokens.d.ts

@@ -1,5 +0,0 @@
-/** Small deterministic tokenizer shared by local Document and Native recovery. */
-export declare function lexicalSearchTokens(value: string, maximum?: number): string[];
-export declare function lexicalTokenMatchCount(value: string, tokens: readonly string[]): number;
-/** Require broader coverage only after a query is focused enough to support it. */
-export declare function lexicalRequiredMatchCount(tokens: readonly string[]): number;

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

@@ -1,113 +0,0 @@
-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 { AuthorityCommitRecorder } from './memory-receipts.ts';
-import { type LlmMemoryPlacementSelection, type PreparedMemoryPlacement } from './provider-placement.ts';
-import { type MemoryProviderAdapterRegistry } from './providers/registry.ts';
-import { type RecallQualityPolicyRegistry } from './recall-quality/index.ts';
-import { type EdgeType, type EntityView, type Insight, type MemoryBodyCatalog, type MemoryBodyMetadataUpdate, type MemoryBodyView, type MemoryGraphSnapshot, type MemoryListRequest, type MemoryListView, type MnemonEmbeddingStatus, type MemoryPlacementDecision, type MemoryReadSource, 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, MnemonEmbeddingStatus, MemoryReadSource, RecallQualityStats, RememberRequest, SearchRequest, Source, StatusView, } from './shared/contracts.ts';
-export interface MemoryBodyMetadataSample {
-    memoryBodyId: string;
-    name: string;
-    description: string;
-    providerId: MemoryBody['provider']['id'];
-    providerLabel: string;
-    method: 'native-basic' | 'browse' | 'search';
-    evidence: Array<Pick<Insight, 'content' | 'category' | 'entities'>>;
-}
-/** 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;
-/** A provider mutation is authoritative only after it reports an explicit durable terminal state. */
-export declare function mutationResultCommitted(result: unknown): boolean;
-export declare class MnemonService {
-    readonly runner: MnemonRunner;
-    readonly config: ResolvedConfig;
-    private readonly recordCommit?;
-    readonly memoryBodies: MemoryBodyRegistry;
-    private readonly providers;
-    private readonly recallQualityPolicy;
-    private bodiesInFlight;
-    constructor(runner: MnemonRunner, config: ResolvedConfig, memoryBodies?: MemoryBodyRegistry, recallQualityPolicyRegistry?: RecallQualityPolicyRegistry, providerAdapterRegistry?: MemoryProviderAdapterRegistry, recordCommit?: AuthorityCommitRecorder | undefined);
-    bodies(signal?: AbortSignal): Promise<MemoryBodyCatalog>;
-    /** Coalesce simultaneous Status/Memory-page probes without caching mutations. */
-    private collectBodies;
-    /** Return the control-plane directory without waiting for provider I/O. */
-    bodyDirectory(): MemoryBodyCatalog;
-    /** Stable, secret-free checkpoint for the projected Memory Space authority. */
-    memoryRevision(): string;
-    /** Return a usable system snapshot without waiting for any Provider I/O. */
-    statusSummary(): StatusView;
-    /** Probe the effective Mnemon embedding runtime and its default Store coverage. */
-    embeddingStatus(signal?: AbortSignal): Promise<MnemonEmbeddingStatus>;
-    status(signal?: AbortSignal): Promise<StatusView>;
-    reconnectBody(id: string, signal?: AbortSignal): Promise<MemoryBodyView>;
-    search(request: SearchRequest, signal?: AbortSignal): Promise<{
-        query: string;
-        mode: string;
-        results: Insight[];
-        hint?: string;
-        sources: MemoryReadSource[];
-    }>;
-    /**
-     * Read a deliberately small metadata sample through the cheapest useful path
-     * exposed by the owning Provider. This avoids federated ranking, graph
-     * expansion, and large browse projections before an LLM metadata pass.
-     */
-    metadataSample(memoryBodyId: string, signal?: AbortSignal): Promise<MemoryBodyMetadataSample>;
-    graph(signal?: AbortSignal, memoryBodyIds?: string[]): Promise<MemoryGraphSnapshot>;
-    list(request?: MemoryListRequest, signal?: AbortSignal): Promise<MemoryListView>;
-    entities(entity?: string, limit?: number, signal?: AbortSignal): Promise<EntityView>;
-    remember(request: RememberRequest, signal?: AbortSignal): Promise<JsonValue>;
-    /**
-     * Persist a host-authorized set of exact memories without involving a model
-     * in the data plane. Mnemon Native requests share one import per destination;
-     * other Providers retain their adapter-defined write semantics.
-     */
-    rememberMany(requests: readonly RememberRequest[], signal?: AbortSignal): Promise<JsonValue[]>;
-    related(id: string, depth?: number, edge?: EdgeType, signal?: AbortSignal, memoryBodyId?: string): Promise<Insight[]>;
-    link(sourceId: string, targetId: string, type?: EdgeType, weight?: number, reason?: string, signal?: AbortSignal, memoryBodyId?: string): Promise<JsonValue>;
-    forget(id: string, signal?: AbortSignal, memoryBodyId?: string): Promise<JsonValue>;
-    prepareBodyPlacement(request: CreateMemoryBodyRequest): PreparedMemoryPlacement;
-    createBody(request: CreateMemoryBodyRequest, signal?: AbortSignal, placement?: MemoryPlacementDecision): Promise<MemoryBody>;
-    /**
-     * Create a Memory Space from the configured distillation policy. The model
-     * may choose only among candidates already filtered by the host; manual mode
-     * ignores model preference and always uses the configured fixed provider.
-     */
-    createBodyForPersistence(body: {
-        name: string;
-        description: string;
-    }, selection: LlmMemoryPlacementSelection | undefined, signal?: AbortSignal, delegation?: {
-        runId: string;
-        provider: string;
-    }): Promise<MemoryBody>;
-    updateProviderService(providerId: MemoryBody['provider']['id'], settings: Record<string, string | number | boolean>, clearSecrets?: readonly string[], enabled?: boolean, signal?: AbortSignal): Promise<import("./shared/contracts.ts").MemoryProviderServiceView>;
-    updateBody(id: string, request: UpdateMemoryBodyRequest): MemoryBody;
-    updateBodyMetadata(updates: readonly MemoryBodyMetadataUpdate[]): MemoryBody[];
-    deleteBody(id: string, signal?: AbortSignal): Promise<MemoryBody>;
-    mergeBodies(targetBodyId: string, sourceBodyIds: string[], deactivateSources?: boolean, signal?: AbortSignal): Promise<JsonValue>;
-    private nativeBodyStatus;
-    private parseStats;
-    private nativeGraph;
-    private allNativeInsights;
-    private nativeMetadataSample;
-    private nativeSearch;
-    private nativeRemember;
-    private nativeRememberMany;
-    private nativeRelated;
-    private nativeLink;
-    private nativeForget;
-    private providerFor;
-    private readBodies;
-    private readBody;
-    private writeBody;
-    private prepareRemember;
-    private annotate;
-    private annotateResult;
-    private activateAfterWrite;
-    private recordMemoryCommit;
-    private assertWritable;
-}

package/lib/types/src/session-events.d.ts

@@ -1,8 +0,0 @@
-import type { HostSession, HostSessionEvent } from './contracts.ts';
-/**
- * Materialize one immutable event-log snapshot across supported DSH releases.
- * Capability detection keeps alpha and stable rc behavior on one code path.
- */
-export declare function hostSessionEvents(session: HostSession): readonly HostSessionEvent[];
-/** Read one exact event without materializing the alpha log when possible. */
-export declare function hostSessionEventAt(session: HostSession, seq: number): HostSessionEvent | undefined;

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

@@ -1,6 +0,0 @@
-import type { HostConnectionHandle, HostRpcAuthority, HostRpcHandler, HostSettingsService } from './contracts.ts';
-export { MNEMON_SETTINGS_CHANNEL, MNEMON_SETTINGS_NAMESPACE, MNEMON_UI_SETTINGS_NAMESPACE } from './shared/contracts.ts';
-/** Canonicalize only the legacy field through DSH's locked, revision-fenced writer. */
-export declare function migrateLegacyDisplayMode(settings: HostSettingsService): Promise<void>;
-export declare function createSettingsHandler(settings: HostSettingsService): HostRpcHandler;
-export declare function registerSettingsRpc(connection: HostConnectionHandle, settings: HostSettingsService, authority?: HostRpcAuthority): void;