dsh-mnemon 0.4.7 → 0.5.0

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

@@ -1,316 +0,0 @@
-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, signal?: AbortSignal) => Promise<RpcResult<unknown>>;
-export type HostRpcAuthority = 'trusted-host' | 'loopback';
-/**
- * DSH rc.2 requires this registration policy. DSH 0.1.2-alpha.1 accepts only
- * the first two JavaScript arguments and safely ignores this trailing value.
- * Keeping one unconditional call shape avoids runtime version detection.
- */
-export interface HostRpcRegistrationOptions {
-    readonly authority: HostRpcAuthority;
-}
-export interface HostConnectionHandle {
-    rpc: {
-        handle(channel: string, handler: HostRpcHandler, options: HostRpcRegistrationOptions): unknown;
-    };
-}
-export interface HostSettingsScope<T> {
-    get(): T;
-}
-export interface HostSettingsService {
-    readonly writable: boolean;
-    register<T>(namespace: string, schema: unknown, options: {
-        base?: Partial<T>;
-        applies: 'live' | 'restart';
-        validate?: (value: T) => void;
-    }): HostSettingsScope<T>;
-    describe(options?: {
-        redactSecrets?: boolean;
-    }): Array<{
-        ns: string;
-        value: unknown;
-        base?: unknown;
-        user?: unknown;
-        revision: number;
-        applies: 'live' | 'restart';
-    }>;
-    mutate(namespace: string, ops: SettingsOperation[], expectedRevision?: number): Promise<void>;
-}
-export interface ToolExecution {
-    signal: AbortSignal;
-    agent?: HostAgent;
-    name?: string;
-    /** Parsed tool arguments, available on the authoritative tools/result event. */
-    arguments?: unknown;
-    parent?: symbol;
-    token?: symbol;
-    /** End the current model turn after an authoritative terminal tool call. */
-    concludeTurn?: () => void;
-}
-export type CommandResult = {
-    kind: 'success';
-    text?: string;
-} | {
-    kind: 'error';
-    text: string;
-};
-export interface CommandInvocation {
-    agent: HostAgent;
-    rawInput: string;
-    signal: AbortSignal;
-}
-export interface CommandDefinition {
-    name: string;
-    description: string;
-    input?: {
-        hint: string;
-    };
-    handler(invocation: CommandInvocation): CommandResult | Promise<CommandResult>;
-}
-export interface CommandService {
-    register(definition: CommandDefinition): unknown;
-}
-export interface ToolDefinition {
-    name: string;
-    description: string;
-    parameters: Record<string, unknown>;
-    output: {
-        schema: Record<string, unknown>;
-        render: (args: Record<string, unknown>, value: never) => Array<{
-            type: 'text';
-            text: string;
-        }>;
-    };
-    execute: (args: never, execution: ToolExecution) => Promise<unknown>;
-    presentCall?: (args: never) => Record<string, unknown>;
-    presentResult?: () => Record<string, unknown>;
-}
-export interface HostMessageSource {
-    kind: string;
-    plugin?: string;
-    form?: string;
-    summary?: string;
-}
-/** Minimum shape shared by DSH content blocks, including merge-added blocks. */
-export interface HostOpaqueContentBlock {
-    type: string;
-    /** Present on text-like blocks; omitted by images and other merge-added blocks. */
-    text?: string;
-}
-export interface HostTextContentBlock extends HostOpaqueContentBlock {
-    type: 'text';
-    text: string;
-}
-/** Durable image metadata used by the DSH 0.1.1 prerelease line. */
-export interface HostImageAttachmentRef {
-    attachmentId: string;
-    mediaType: 'image/png' | 'image/jpeg' | 'image/webp' | 'image/gif';
-    bytes: number;
-    width: number;
-    height: number;
-    name?: string;
-}
-export interface HostImageContentBlock extends HostOpaqueContentBlock {
-    type: 'image';
-    attachment: HostImageAttachmentRef;
-}
-/** User content is open to DSH/plugin blocks while documenting first-party text and image shapes. */
-export type HostUserContentBlock = HostTextContentBlock | HostImageContentBlock | HostOpaqueContentBlock;
-export interface HostUserMessage {
-    id: string;
-    role: 'user';
-    content: HostUserContentBlock[];
-    source: HostMessageSource;
-}
-export interface HostSessionEvent {
-    type: string;
-    seq?: number;
-    time?: number;
-    data: Record<string, unknown>;
-}
-/**
- * Minimum session log surface shared by the stable DSH rc line and the 0.1.2
- * alpha line. rc.2 exposes the immutable log through `events`; alpha.4+
- * replaces that property with range snapshots and indexed reads.
- */
-export interface HostSession {
-    header?: {
-        origin?: 'subagent';
-        parentSession?: string;
-        delegationDepth?: number;
-        cwd?: string;
-        agentPreset?: string;
-    };
-    /** Stable rc.2 event-log accessor. */
-    events?: readonly HostSessionEvent[];
-    /** DSH 0.1.2-alpha.4+ event-log accessor. */
-    snapshotEvents?(fromSeq?: number, toSeqExclusive?: number): readonly HostSessionEvent[];
-    /** DSH 0.1.2-alpha.4+ indexed event accessor. */
-    eventAt?(seq: number): HostSessionEvent | undefined;
-    /**
-     * Model-visible event sequences, in order. Optional because not every host
-     * publishes a surface projection; when absent, callers fall back to
-     * session-scoped state.
-     */
-    surface?: {
-        readonly nodes: readonly number[];
-    };
-}
-export type HostPreStepDecision = {
-    kind: 'reject';
-} | {
-    kind: 'enter';
-    messages: HostUserMessage[];
-};
-export interface HostAgentContext {
-    /**
-     * `options` is optional and forwarded verbatim to the host. `prepend`
-     * places the listener at the head of the chain, which for a waterfall
-     * means it observes the fully assembled result. Omitting it keeps the
-     * previous two-argument behaviour exactly.
-     */
-    on(name: string, listener: (...args: never[]) => unknown, options?: {
-        prepend?: boolean;
-    }): () => unknown;
-    effect(callback: () => (() => unknown) | void, label?: string): () => unknown;
-    get?(name: string): unknown;
-}
-export interface HostAgent {
-    id: string;
-    status: 'idle' | 'running';
-    options?: {
-        provider?: string;
-        model?: string;
-        maxTokens?: number;
-    };
-    session: HostSession;
-    ctx: HostAgentContext;
-    followup(message: HostUserMessage): void;
-    steer(message: HostUserMessage): void;
-    inject(message: HostUserMessage): void;
-}
-export interface HostAgentHandle {
-    agent: HostAgent;
-    dispose(): Promise<void>;
-}
-export interface CreateHostAgentOptions {
-    sessionId: string;
-    meta?: {
-        cwd?: string;
-        agentPreset?: string;
-    };
-    agentOptions?: {
-        provider?: string;
-        model?: string;
-        maxTokens?: number;
-    };
-    signal?: AbortSignal;
-    setup?: (agentCtx: HostAgentContext) => unknown | Promise<unknown>;
-}
-export interface HostAgentsService {
-    get(id: string): HostAgent | undefined;
-    roots(): HostAgent[];
-    /** DSH rc.6+ factory for an owned, clean top-level Agent. */
-    create?(options: CreateHostAgentOptions): Promise<HostAgentHandle>;
-}
-export interface HostWorkspace {
-    readonly id: string;
-    readonly path: string;
-    readonly title: string;
-}
-export interface HostWorkspaceRegistry {
-    get(id: string): HostWorkspace | undefined;
-    list(): HostWorkspace[];
-}
-export interface HostSubagentResult {
-    output: Array<{
-        type: string;
-        text?: string;
-        [key: string]: unknown;
-    }>;
-    structured?: unknown;
-    /** DSH rc.8+ provider-authored failure detail, including for remote children. */
-    diagnostic?: string;
-    stopReason: string;
-}
-export interface HostSubagentRun {
-    id: string;
-    localAgent?: HostAgent;
-    result: Promise<HostSubagentResult>;
-    dispose(): Promise<void>;
-}
-export interface HostSubagentProvider {
-    inheritsParentContext?: boolean;
-    capabilities: {
-        outputSchema: boolean;
-        depthLimit: boolean;
-        toolFilter: boolean;
-        persona: boolean;
-    };
-}
-export interface HostSubagentsService {
-    list(): string[];
-    getProvider(name: string): HostSubagentProvider | undefined;
-    start(name: string, request: {
-        label?: string;
-        prompt: Array<{
-            type: 'text';
-            text: string;
-        }>;
-        parent: HostAgent;
-        signal: AbortSignal;
-        agentOptions?: {
-            provider?: string;
-            model?: string;
-            maxTokens?: number;
-        };
-        outputSchema?: Record<string, unknown>;
-        maxDepth?: number;
-        toolFilter?: {
-            allow?: string[];
-            deny?: string[];
-        };
-        persona?: string;
-    }): Promise<HostSubagentRun>;
-}
-export interface HostLlmService {
-    listProviders(): Array<{
-        id: string;
-        name: string;
-    }>;
-    listModels(provider: string): Promise<Array<{
-        id: string;
-        name: string;
-        description?: string;
-        /** Absent means unknown; an explicit list declares the accepted request modalities. */
-        inputModalities?: readonly string[];
-    }>>;
-}
-export interface HostContextShape {
-    tools: {
-        register(definition: ToolDefinition): unknown;
-    };
-    commands: CommandService;
-    settings: HostSettingsService;
-    /** Web-only transport; absent from non-Web profiles such as Headless. */
-    connection?: HostConnectionHandle;
-    agents: HostAgentsService;
-    subagents: HostSubagentsService;
-    /** Web workbench catalog; Agent execution routes by session cwd without it. */
-    workspaceRegistry?: HostWorkspaceRegistry;
-    get(name: string): unknown;
-    /** Cordis service publication; optional only for narrow test/headless shims. */
-    provide?(name: string, value?: unknown, check?: () => boolean): unknown;
-    inject(services: string[], callback: (ctx: HostContextShape) => void): unknown;
-    /**
-     * `options` is optional and forwarded verbatim to the host. `prepend`
-     * places the listener at the head of the chain, which for a waterfall
-     * means it observes the fully assembled result. Omitting it keeps the
-     * previous two-argument behaviour exactly.
-     */
-    on(name: string, listener: (...args: never[]) => unknown, options?: {
-        prepend?: boolean;
-    }): () => unknown;
-    effect(callback: () => (() => unknown) | void, label?: string): () => unknown;
-}

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

@@ -1,77 +0,0 @@
-import type { HostAgent } from './contracts.ts';
-import type { DocumentMutation, DocumentMutationResult, DocumentRecord, DocumentSearchResult, DocumentSnapshot, DocumentView } from './shared/contracts.ts';
-import type { AuthorityCommitRecorder } from './memory-receipts.ts';
-import type { MemoryMigrationLineage } from '../packages/contracts/src/index.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 interface DocumentCapacityPlan {
-    projected: number;
-    limit: number;
-    fits: boolean;
-    candidates: DocumentRecord[];
-}
-export declare class DocumentCapacityError extends Error {
-    readonly projected: number;
-    readonly limit: number;
-    readonly candidates: DocumentRecord[];
-    constructor(projected: number, limit: number, candidates: DocumentRecord[]);
-}
-export declare class DocumentConflictError extends Error {
-    constructor();
-}
-/** Project-scoped control plane for managed active and cold document copies. */
-export declare class DocumentController {
-    readonly limitBytes: number;
-    private readonly now;
-    private readonly recordCommit?;
-    readonly workspaceRoot: string;
-    readonly storageRoot: string;
-    readonly directory: string;
-    readonly activeDirectory: string;
-    readonly archivedDirectory: string;
-    readonly indexPath: string;
-    readonly lockPath: string;
-    private readonly managedRelativePrefix;
-    private queue;
-    constructor(workspaceRoot: string, limitBytes?: number, now?: () => Date, storageRoot?: string, recordCommit?: AuthorityCommitRecorder | undefined);
-    snapshot(): DocumentSnapshot;
-    get(id: string): DocumentView;
-    capacityPlan(request: DocumentMutation): DocumentCapacityPlan;
-    search(query: string, options?: {
-        includeArchived?: boolean;
-        limit?: number;
-    }): Promise<DocumentSearchResult>;
-    mutate(request: DocumentMutation): Promise<DocumentMutationResult>;
-    archive(id: string, expectedRevision: number, details: {
-        summary: string;
-        memoryBodyIds: string[];
-        lineage?: readonly MemoryMigrationLineage[];
-    }): Promise<DocumentMutationResult>;
-    private mutateLocked;
-    private initialize;
-    private readIndex;
-    private snapshotUnlocked;
-    private requireDocument;
-    private assertCapacity;
-    private normalizeSourcePaths;
-    private relativeManagedPath;
-    private pathFor;
-    private readBody;
-    private view;
-    private persistDocument;
-    private persistIndex;
-    private atomicWrite;
-    private withLock;
-}
-/** Resolves one cached controller per canonical DSH workspace. */
-export declare class DocumentManager {
-    private readonly limitBytes;
-    private readonly now;
-    private readonly storageRoot?;
-    private readonly recordCommit?;
-    private readonly controllers;
-    constructor(limitBytes?: number, now?: () => Date, storageRoot?: (() => string) | undefined, recordCommit?: AuthorityCommitRecorder | undefined);
-    forWorkspace(workspaceRoot: string): DocumentController;
-    forAgent(agent: HostAgent): DocumentController;
-}

package/lib/types/src/git-branch.d.ts

@@ -1,6 +0,0 @@
-/**
- * Resolve the current git branch of a workspace root. Returns undefined when
- * the directory is not a git working tree, HEAD is detached, or the probe
- * fails or times out, so callers fall back to the unfiltered view.
- */
-export declare function resolveGitBranch(cwd?: string): string | undefined;

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

@@ -1,29 +0,0 @@
-import type { HostAgent, HostContextShape } from './contracts.ts';
-import type { ResolvedConfig } from './config.ts';
-import { type RuntimeMemoryController } from './runtime-memory.ts';
-import type { MemoryWake } from '../packages/contracts/src/index.ts';
-export declare const GUIDANCE_SECTION_NAME = "mnemon:routing";
-export declare const RUNTIME_MEMORY_PROTOCOL_SECTION_NAME = "mnemon:runtime-memory-protocol";
-export declare const RUNTIME_MEMORY_CONTEXT_NAME = "mnemon:runtime-memory";
-export declare const ROUTING_GUIDANCE = "Use memory only when needed. Search Mnemon Documents for substantial project records. Call mnemon_recall for durable history or exact prior details; never infer a missing historical rule. Put only new user facts or explicit save/correction requests in mnemon_runtime_memory; never cache retrieved evidence. A write exists only after its receipt.";
-export declare function memoryPromptText(value: string): string;
-/** Replace the already-materialized Agent protocol and context with the Wake pinned during assembly. */
-export declare function applyAgentMemoryViewWake<T extends {
-    sections: Array<{
-        name: string;
-        text: string;
-    }>;
-    contexts: Array<{
-        name: string;
-        text: string;
-    }>;
-}>(assembly: T, wake: MemoryWake | undefined): T;
-/** Register the non-recursive escape used by both legacy Runtime and View Wake contexts. */
-export declare function registerMemoryPromptInterpolation(ctx: HostContextShape): void;
-export declare function registerGuidance(ctx: HostContextShape, config?: Pick<ResolvedConfig, 'routingGuidance'>): void;
-/** Project the latest committed USER.md/MEMORY.md as DSH's durable runtime-context snapshot. */
-export declare function registerRuntimeMemoryContext(ctx: HostContextShape, runtimeMemory: RuntimeMemoryController, enabled?: () => boolean): void;
-/** Shadow the global fallback with the current Agent workspace's hot memory. */
-export declare function registerAgentRuntimeMemoryContext(agent: HostAgent, runtimeMemory: () => RuntimeMemoryController, enabled?: () => boolean): () => void;
-/** Project only the immutable Wake pinned by the root Agent lifecycle. */
-export declare function registerAgentMemoryViewContext(agent: HostAgent, wake: () => MemoryWake | undefined): () => void;

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

@@ -1,80 +0,0 @@
-import type { ResolvedConfig } from './config.ts';
-import type { 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 } from './subagent.ts';
-import { type TurnMemoryActivitySnapshot } from './activity.ts';
-import type { AssistantMessageText, LifecycleSnapshot, TaskAgentModelCatalog } from './shared/contracts.ts';
-import type { PreparedMemoryPlacement } from './provider-placement.ts';
-import type { MnemonAgentRuntimeSource } from './live-runtime.ts';
-type AgentRuntimeSource = Pick<MnemonAgentRuntimeSource, 'forAgent' | 'bindAgentRuntime'>;
-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 interface SupervisedWritebackResult extends DelegatedWriteResult {
-    sessionId: string;
-}
-/** DSH-native owner for per-agent Mnemon lifecycle hooks and UI-triggered LLM work. */
-export declare class MnemonLifecycle {
-    private readonly ctx;
-    private readonly coordinator;
-    private readonly config;
-    private readonly runtimeSource?;
-    private readonly owners;
-    private readonly children;
-    private readonly memoryTurns;
-    private readonly counters;
-    /** Creation ids reserved before DSH publishes clean task-root Agents. */
-    private readonly taskAgentIds;
-    /** Bounded process-local replay fence for finalized-message write actions. */
-    private readonly supervisedWritebacks;
-    constructor(ctx: HostContextShape, coordinator: MnemonSubagentCoordinator, config: ResolvedConfig, runtimeSource?: AgentRuntimeSource | undefined);
-    start(): () => void;
-    snapshot(sessionId?: string, workspaceRoot?: string): LifecycleSnapshot;
-    /** Provider/model directory used by Settings without requiring a live session. */
-    taskAgentModels(includeCatalog?: boolean): Promise<TaskAgentModelCatalog>;
-    private availableAgent;
-    workspaceRoot(sessionId?: string): string | undefined;
-    /** Settled memory-tool activity for all turns, resolved per session. */
-    turnActivities(sessionId: string): TurnMemoryActivitySnapshot;
-    /** Plain text of one finalized assistant message, resolved per session; null while absent. */
-    assistantMessage(sessionId: string, messageId: string): AssistantMessageText | null;
-    recall(sessionId: string, request: SearchRequest, signal?: AbortSignal): Promise<import("./subagent.ts").RecallResult>;
-    related(sessionId: string, id: string, memoryBodyId?: string, signal?: AbortSignal): Promise<import("./subagent.ts").RecallResult>;
-    answer(sessionId: string, query: string, evidence: Insight[], signal?: AbortSignal): Promise<import("./subagent.ts").DelegatedAnswerResult>;
-    /** Synthesize a Web Agent Query without borrowing a conversation Agent or its history. */
-    answerTask(sessionId: string, query: string, evidence: Insight[], workspaceRoot?: string, signal?: AbortSignal): Promise<import("./subagent.ts").DelegatedAnswerResult>;
-    remember(sessionId: string, request: RememberRequest, signal?: AbortSignal): Promise<DelegatedWriteResult>;
-    runtime(sessionId: string, request: RuntimeMemoryMutation, signal?: AbortSignal): Promise<import("./subagent.ts").CoordinatedRuntimeMemoryResult>;
-    documents(sessionId: string): import("./documents.ts").DocumentSnapshot;
-    document(sessionId: string, id: string): import("./documents.ts").DocumentView;
-    searchDocuments(sessionId: string, query: string, includeArchived?: boolean, limit?: number): Promise<import("./documents.ts").DocumentSearchResult>;
-    mutateDocument(sessionId: string, request: DocumentMutation, signal?: AbortSignal): Promise<import("./subagent.ts").CoordinatedDocumentResult>;
-    archiveDocument(sessionId: string, id: string, workspaceRoot?: string, signal?: AbortSignal): Promise<import("./subagent.ts").CoordinatedDocumentResult>;
-    mutate(sessionId: string, operation: string, request: unknown, signal?: AbortSignal): Promise<DelegatedWriteResult>;
-    placeProvider(sessionId: string, body: {
-        name: string;
-        description: string;
-    }, prepared: PreparedMemoryPlacement, signal?: AbortSignal): Promise<import("./shared/contracts.ts").MemoryPlacementDecision>;
-    maintainMetadata(sessionId: string, memoryBodyIds: readonly string[], workspaceRoot?: string, signal?: AbortSignal): Promise<import("./shared/contracts.ts").MemoryBodyMetadataMaintenanceResult>;
-    supervise(sessionId: string, content: string, idempotencyKey?: string, signal?: AbortSignal): Promise<SupervisedWritebackResult>;
-    /** Run a Web workbench distillation under a fresh top-level task Agent. */
-    superviseTask(sessionId: string, content: string, idempotencyKey?: string, workspaceRoot?: string, signal?: AbortSignal): Promise<SupervisedWritebackResult>;
-    private superviseResolved;
-    private liveAgent;
-    /**
-     * Run session-independent maintenance under a fresh top-level Agent. Its cwd
-     * is the explicit Web workbench scope, so LiveMnemonRuntime resolves the same
-     * workspace graph without borrowing conversation history or ownership.
-     */
-    private runTaskAgent;
-    /** Resolve the same model route and preset composition as an ordinary fresh DSH Agent. */
-    private taskAgentCreation;
-    /** Resolve a complete task route for both status admission and actual creation. */
-    private taskAgentModelRoute;
-    private taskAgentModelOptions;
-    private install;
-    /** Child memory ownership is independent of root-only reminders and idle review. */
-    private installChild;
-}

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

@@ -1,92 +0,0 @@
-import type { ResolvedConfig } from './config.ts';
-import type { HostAgent, HostAgentsService, HostWorkspace, HostWorkspaceRegistry } from './contracts.ts';
-import { DocumentManager } from './documents.ts';
-import { MnemonPackManager } from './pack.ts';
-import { type MnemonRunner } from './runner.ts';
-import { RuntimeMemoryController } from './runtime-memory.ts';
-import { MnemonService } from './service.ts';
-import { StorageScopeInspector } from './storage-scope.ts';
-import { MemoryCatalog } from './memory-system/catalog.ts';
-import { MemoryKernel } from './memory-system/kernel.ts';
-import { MemoryTopologyManager } from './memory-system/topology.ts';
-import type { MemoryBoot } from '../packages/extension-sdk/src/index.ts';
-import type { MemoryTurnViewManager } from '../packages/kernel/src/index.ts';
-export interface MnemonRuntimeGraph {
-    config: ResolvedConfig;
-    runner: MnemonRunner;
-    service: MnemonService;
-    runtimeMemory: RuntimeMemoryController;
-    documents: DocumentManager;
-    storage: StorageScopeInspector;
-    packs: MnemonPackManager;
-    memoryCatalog: MemoryCatalog;
-    memoryTopology: MemoryTopologyManager;
-    memoryKernel: MemoryKernel;
-    memoryViews: MemoryTurnViewManager;
-    /** Detach this generation from future Host-global extension changes. */
-    dispose(): void;
-}
-export interface MnemonAgentRuntimeSource {
-    readonly config: ResolvedConfig;
-    forAgent(agent: HostAgent): MnemonRuntimeGraph;
-    /** Retain one runtime generation for an Agent turn or delegated child lifetime. */
-    bindAgentRuntime(agentId: string, graph: MnemonRuntimeGraph): () => void;
-}
-/**
- * Build a complete generation before it can become visible. Constructors also
- * validate and initialize the selected storage root, so a failed candidate is
- * rejected by DSH settings validation without disturbing the active graph.
- */
-export declare function createRuntimeGraph(config: ResolvedConfig, workspaceRoot?: string, extensions?: MemoryBoot): MnemonRuntimeGraph;
-/**
- * Stable faces handed to DSH registrations. `swap` is synchronous and contains
- * no user code, so all faces move to the same prevalidated generation in one
- * JavaScript turn. A method obtained before the swap stays bound to its old
- * generation until that invocation settles.
- */
-export declare class LiveMnemonRuntime implements MnemonAgentRuntimeSource {
-    private readonly workspaceRegistry?;
-    private readonly agents?;
-    private readonly extensions?;
-    private current;
-    private readonly workspaceGraphs;
-    private readonly agentGraphs;
-    private closed;
-    readonly config: ResolvedConfig;
-    readonly runner: MnemonRunner;
-    readonly service: MnemonService;
-    readonly runtimeMemory: RuntimeMemoryController;
-    readonly documents: DocumentManager;
-    readonly storage: StorageScopeInspector;
-    readonly packs: MnemonPackManager;
-    readonly memoryCatalog: MemoryCatalog;
-    readonly memoryTopology: MemoryTopologyManager;
-    readonly memoryKernel: MemoryKernel;
-    readonly memoryViews: MemoryTurnViewManager;
-    constructor(initial: MnemonRuntimeGraph, workspaceRegistry?: HostWorkspaceRegistry | undefined, agents?: HostAgentsService | undefined, extensions?: MemoryBoot | undefined);
-    swap(next: MnemonRuntimeGraph): void;
-    snapshot(): MnemonRuntimeGraph;
-    bindAgentRuntime(agentId: string, graph: MnemonRuntimeGraph): () => void;
-    dispose(): void;
-    /** Resolve the runtime that must serve one Agent execution. */
-    forAgent(agent: HostAgent): MnemonRuntimeGraph;
-    /** Resolve an authorized DSH workspace selected by the Web workbench. */
-    forWorkspaceId(workspaceId: string): MnemonRuntimeGraph;
-    /** Resolve a Web request, preferring its explicit inspection workspace. */
-    route(request: {
-        workspaceId?: string;
-        sessionId?: string;
-    }): {
-        graph: MnemonRuntimeGraph;
-        selectedWorkspace?: HostWorkspace;
-        effectiveWorkspace?: HostWorkspace;
-        selectedRoot: string;
-        effectiveRoot: string;
-        aligned: boolean;
-    };
-    private forWorkspacePath;
-    private assertOpen;
-    private agent;
-    private requireWorkspace;
-    private workspaceForPath;
-}

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

@@ -1,57 +0,0 @@
-import type { MnemonRunner } from './runner.ts';
-import type { MemoryPlacementCandidate } from './provider-placement.ts';
-import type { CreateMemoryBodyRequest, MemoryBody, MemoryPlacementDecision, MemoryProviderServiceCatalog, MemoryProviderServiceView, MemoryProviderConnection, MemoryProviderId, MemoryBodyMetadataUpdate, OpenVikingBodyConnection, UpdateMemoryBodyRequest } from './shared/contracts.ts';
-import type { ProviderMemorySpace } from './providers/provider.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.
- *
- * Native metadata lives beside Store directories so existing Mnemon Packs stay
- * compatible. External connection metadata lives under state and is never
- * included in Memory Space Packs.
- */
-export declare class MemoryBodyRegistry {
-    readonly runner: MnemonRunner;
-    private readonly persistent;
-    private readonly now;
-    readonly directory: string;
-    readonly registryPath: string;
-    readonly providerRegistryPath: string;
-    private bodies;
-    private services;
-    private serviceEnabled;
-    constructor(runner: MnemonRunner, persistent?: boolean, now?: () => Date);
-    list(): MemoryBody[];
-    active(): MemoryBody[];
-    get(id: string): MemoryBody;
-    openVikingConnection(id: string): OpenVikingBodyConnection;
-    providerConnection(id: string, expectedProviderId?: MemoryProviderId): MemoryProviderConnection;
-    providerServiceConfigured(providerId: MemoryProviderId): boolean;
-    providerServiceEnabled(providerId: MemoryProviderId): boolean;
-    providerServices(options?: {
-        includeSecrets?: boolean;
-    }): MemoryProviderServiceCatalog;
-    updateProviderService(providerId: MemoryProviderId, settings: MemoryProviderConnection, clearSecrets?: readonly string[], enabled?: boolean): MemoryProviderServiceView;
-    resolveProviderService(providerId: MemoryProviderId, settings: MemoryProviderConnection, clearSecrets?: readonly string[]): MemoryProviderConnection;
-    /** Atomically replace one provider's local projections after authoritative discovery. */
-    syncProviderService(providerId: MemoryProviderId, service: MemoryProviderConnection, discovered: readonly ProviderMemorySpace[]): MemoryProviderServiceView;
-    placementCandidates(request: Pick<CreateMemoryBodyRequest, 'connection' | 'providerConnections' | 'openViking'>): MemoryPlacementCandidate[];
-    create(request: CreateMemoryBodyRequest, signal?: AbortSignal, placement?: MemoryPlacementDecision): Promise<MemoryBody>;
-    update(id: string, request: UpdateMemoryBodyRequest): MemoryBody;
-    /** Validate every model-authored update before committing the batch. */
-    updateMetadata(updates: readonly MemoryBodyMetadataUpdate[]): MemoryBody[];
-    remove(id: string, signal?: AbortSignal): Promise<MemoryBody>;
-    setActive(id: string, active: boolean): MemoryBody;
-    /** Advance the safe catalog checkpoint after provider-backed content changes. */
-    touch(id: string): MemoryBody;
-    /** Refresh metadata after an atomic Pack import replaced the data component. */
-    reload(): void;
-    private loadAndReconcile;
-    private reconcileDiscoveredStores;
-    private nativeStoreIds;
-    private nextTimestamp;
-    private view;
-    private save;
-    private writeRegistry;
-}