dsh-mnemon 0.4.7 → 0.5.0

package/lib/types/src/storage-scope.d.ts

@@ -1,12 +0,0 @@
-import type { ResolvedConfig } from './config.ts';
-import type { MnemonRunner } from './runner.ts';
-import type { StorageScopeCatalog } from './shared/contracts.ts';
-export type { StorageAreaInventory, StorageAreaKind, StorageAreaStatus, StorageScopeCatalog, StorageScopeInventory, StorageScopeKind } from './shared/contracts.ts';
-/** Read-only catalog of the three storage domains. It never creates, moves, or repairs files. */
-export declare class StorageScopeInspector {
-    private readonly runner;
-    private readonly config;
-    constructor(runner: Pick<MnemonRunner, 'effectiveDataDir'>, config: Pick<ResolvedConfig, 'dataDir' | 'storageScope'>);
-    catalog(workspaceRoot?: string): StorageScopeCatalog;
-}
-export declare function validateCustomStorageRoot(value: string): string;

package/lib/types/src/subagent-token-usage.d.ts

@@ -1,53 +0,0 @@
-/**
- * Mnemon-owned projection for provider usage after a subagent descriptor.
- *
- * Fork-backed subagents inherit the parent's durable event prefix. DSH's
- * generic `tokenUsage` projection intentionally totals that complete log, so
- * it cannot also represent the cost of the child shown in the subagent
- * catalog. This independent projection keeps the generic metric untouched
- * and resets at every durable descriptor.
- */
-import { z } from 'zod';
-import type { HostContextShape } from './contracts.ts';
-export interface MnemonTokenUsageProjection {
-    uncachedInputTokens: number;
-    outputTokens: number;
-    cacheReadTokens: number;
-    cacheWriteTokens: number;
-}
-export interface MnemonSubagentTokenUsageState {
-    descriptorSeen: boolean;
-    totals: MnemonTokenUsageProjection;
-    last: {
-        turn: number;
-        step: number;
-        buckets: MnemonTokenUsageProjection;
-    } | null;
-}
-interface ProjectionEvent {
-    type: string;
-    data: unknown;
-}
-/** Wire key consumed only by Mnemon's subagent-catalog compatibility shim. */
-export declare const MNEMON_SUBAGENT_TOKEN_USAGE_KEY = "mnemonSubagentTokenUsage";
-/**
- * Fold provider usage after the latest subagent descriptor. A fork may carry
- * an ancestor descriptor as part of its seed, so every descriptor resets the
- * fold and the child's own descriptor becomes the final authoritative origin.
- */
-export declare const mnemonSubagentTokenUsageProjectionDefinition: {
-    readonly key: "mnemonSubagentTokenUsage";
-    readonly stateVersion: 1;
-    readonly stateSchema: z.ZodType<MnemonSubagentTokenUsageState, unknown, z.core.$ZodTypeInternals<MnemonSubagentTokenUsageState, unknown>>;
-    readonly schema: z.ZodNullable<z.ZodType<MnemonTokenUsageProjection, unknown, z.core.$ZodTypeInternals<MnemonTokenUsageProjection, unknown>>>;
-    readonly init: () => MnemonSubagentTokenUsageState;
-    readonly apply: (state: MnemonSubagentTokenUsageState, event: ProjectionEvent) => MnemonSubagentTokenUsageState;
-    readonly view: (state: MnemonSubagentTokenUsageState) => MnemonTokenUsageProjection | null;
-    readonly wire: {
-        viewSchema: z.ZodNullable<z.ZodType<MnemonTokenUsageProjection, unknown, z.core.$ZodTypeInternals<MnemonTokenUsageProjection, unknown>>>;
-        view: (state: MnemonSubagentTokenUsageState) => MnemonTokenUsageProjection | null;
-    };
-};
-/** Register lazily when the optional DSH projection service is present. */
-export declare function registerMnemonSubagentTokenUsageProjection(ctx: HostContextShape): void;
-export {};

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

@@ -1,124 +0,0 @@
-import type { HostAgent, HostSubagentsService, ToolDefinition } from './contracts.ts';
-import { type DocumentManager, type DocumentMutation, type DocumentMutationResult, type DocumentView } from './documents.ts';
-import { type RuntimeMemoryController, type RuntimeMemoryMutation, type RuntimeMemoryMutationResult } from './runtime-memory.ts';
-import { type EdgeType, type Insight, type RememberRequest, type SearchRequest } from './service.ts';
-import { type PreparedMemoryPlacement } from './provider-placement.ts';
-import type { MemoryBodyMetadataMaintenanceResult, MemoryPlacementDecision, SubagentCounters } from './shared/contracts.ts';
-import type { MnemonAgentRuntimeSource } from './live-runtime.ts';
-export type { SubagentCounters } from './shared/contracts.ts';
-type AgentRuntimeSource = Pick<MnemonAgentRuntimeSource, 'forAgent'>;
-interface HostToolRegistry {
-    register(definition: ToolDefinition): unknown;
-}
-interface HostResultToolRuntime {
-    tools: HostToolRegistry;
-    on(name: string, listener: (...args: never[]) => unknown): unknown;
-}
-/** Rejects schema keywords that DSH structured-output tools cannot compile. */
-export declare function assertDshOutputSchema(schema: unknown, path?: string): void;
-export interface RecallResult {
-    query: string;
-    mode: string;
-    results: Insight[];
-    hint?: string;
-}
-/** Compatibility name for the v0.3 pre-release API. Recall no longer delegates. */
-export type DelegatedRecallResult = RecallResult;
-export interface DelegatedWriteResult {
-    delegated: true;
-    runId: string;
-    provider: string;
-    summary: string;
-    action: string;
-    memoryBodyIds: string[];
-    documentIds?: string[];
-}
-export type CoordinatedDocumentResult = DocumentMutationResult & {
-    maintenance?: {
-        runId: string;
-        provider: string;
-        summary: string;
-        memoryBodyIds: string[];
-        archivedDocumentIds: string[];
-    };
-};
-export interface DelegatedAnswerResult {
-    answer: string;
-    citations: string[];
-    delegation: {
-        runId: string;
-        provider: string;
-    };
-}
-export type CoordinatedRuntimeMemoryResult = RuntimeMemoryMutationResult & {
-    maintenance?: {
-        runId: string;
-        provider: string;
-        summary: string;
-        memoryBodyIds: string[];
-    };
-};
-export declare function isSubagent(agent: HostAgent | undefined): boolean;
-/** Delegates memory judgment and execution to a fresh, tool-scoped DSH child. */
-export declare class MnemonSubagentCoordinator {
-    private readonly subagents;
-    private readonly runtimeMemoryOrSource?;
-    private readonly documents?;
-    private readonly resultRuntime?;
-    private readonly taskAgentModelResolver?;
-    private readonly runtimeMaintenanceMaxTokensResolver?;
-    private readonly counters;
-    private runtimeQueue;
-    private documentQueue;
-    private readonly retrievalTurns;
-    constructor(subagents: HostSubagentsService, runtimeMemoryOrSource?: (RuntimeMemoryController | AgentRuntimeSource) | undefined, documents?: DocumentManager | undefined, resultRuntime?: HostResultToolRuntime | undefined, taskAgentModelResolver?: (() => {
-        provider: string;
-        model: string;
-    } | undefined) | undefined, runtimeMaintenanceMaxTokensResolver?: (() => number) | undefined);
-    snapshot(): SubagentCounters;
-    documentsSnapshot(parent: HostAgent): import("./documents.ts").DocumentSnapshot;
-    documentGet(parent: HostAgent, id: string): DocumentView;
-    documentSearch(parent: HostAgent, query: string, includeArchived?: boolean, limit?: number): Promise<import("./documents.ts").DocumentSearchResult>;
-    /** Admit at most one model-facing Documents query for one executing turn. */
-    claimDocumentSearch(parent: HostAgent): boolean;
-    recall(parent: HostAgent, request: SearchRequest, signal: AbortSignal, options?: {
-        requirePinnedView?: boolean;
-    }): Promise<RecallResult>;
-    /** Bind a model read to the Source state pinned by its own executing turn. */
-    scopeRecallRequest(agent: HostAgent, request: SearchRequest, requirePinnedView?: boolean): SearchRequest;
-    private scopeRecallWithAuthority;
-    scopeRelatedMemoryBody(agent: HostAgent, memoryBodyId?: string, requirePinnedView?: boolean): string | undefined;
-    private scopeRelatedWithAuthority;
-    related(parent: HostAgent, id: string, memoryBodyId: string | undefined, signal: AbortSignal, options?: {
-        depth?: number;
-        edge?: EdgeType;
-        requirePinnedView?: boolean;
-    }): Promise<RecallResult>;
-    placeProvider(parent: HostAgent, body: {
-        name: string;
-        description: string;
-    }, prepared: PreparedMemoryPlacement, signal: AbortSignal): Promise<MemoryPlacementDecision>;
-    maintainMetadata(parent: HostAgent, memoryBodyIds: readonly string[], signal: AbortSignal): Promise<MemoryBodyMetadataMaintenanceResult>;
-    remember(parent: HostAgent, request: RememberRequest, signal: AbortSignal): Promise<DelegatedWriteResult>;
-    runtime(parent: HostAgent, request: RuntimeMemoryMutation, signal: AbortSignal): Promise<CoordinatedRuntimeMemoryResult>;
-    document(parent: HostAgent, request: DocumentMutation, signal: AbortSignal): Promise<CoordinatedDocumentResult>;
-    archiveDocument(parent: HostAgent, id: string, signal: AbortSignal): Promise<CoordinatedDocumentResult>;
-    answer(parent: HostAgent, query: string, evidence: Insight[], signal: AbortSignal): Promise<DelegatedAnswerResult>;
-    write(parent: HostAgent, operation: string, request: unknown, signal: AbortSignal): Promise<DelegatedWriteResult>;
-    review(parent: HostAgent, signal: AbortSignal): Promise<DelegatedWriteResult>;
-    private documentLocked;
-    private archiveDocumentLocked;
-    private runtimeLocked;
-    private compactUserAndCommit;
-    private archiveRuntimeEntry;
-    private delegate;
-    private provider;
-    private recallAuthority;
-    private turnAuthority;
-    private turnRetrievalState;
-    private recordRecall;
-    private runtimeMemoryFor;
-    private serviceFor;
-    private assertAutomaticMemoryWrite;
-    private documentsFor;
-}

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

@@ -1,10 +0,0 @@
-import type { HostContextShape } from './contracts.ts';
-import type { DocumentManager } from './documents.ts';
-import type { RuntimeMemoryController } from './runtime-memory.ts';
-import type { MnemonAgentRuntimeSource } from './live-runtime.ts';
-import { MnemonSubagentCoordinator } from './subagent.ts';
-import { type MnemonService } from './service.ts';
-type AgentRuntimeSource = MnemonAgentRuntimeSource;
-/** Model tools use the executing Agent's pinned runtime and deterministic service. */
-export declare function registerTools(ctx: HostContextShape, serviceOrSource: MnemonService | AgentRuntimeSource, coordinator: MnemonSubagentCoordinator, runtimeMemory?: RuntimeMemoryController, documents?: DocumentManager): void;
-export {};

package/lib/types/src/version-updates.d.ts

@@ -1,37 +0,0 @@
-import { type ProcessRunner } from './process.ts';
-import type { VersionComponentId, VersionStatus, VersionUpdateResult } from './shared/contracts.ts';
-export type { VersionComponentId, VersionComponentStatus, VersionInstallMode, VersionStatus, VersionUpdateResult } from './shared/contracts.ts';
-export interface VersionUpdateDependencies {
-    packageManifestPath?: string;
-    dshHome?: string;
-    mnemonCliPath?: () => string | undefined;
-    processRunner?: ProcessRunner;
-    resolveExecutable?: (command: string) => string | undefined;
-    fetchNpmLatest?: (name: string) => Promise<string | undefined>;
-    fetchMnemonLatest?: () => Promise<string | undefined>;
-}
-/** Resolve one executable without invoking a shell. */
-export declare function resolveExecutable(command: string): string | undefined;
-export interface SemverParts {
-    major: number;
-    minor: number;
-    patch: number;
-    prerelease: string[];
-}
-export declare function parseSemver(value: string): SemverParts | undefined;
-export declare function compareVersions(a: string, b: string): number;
-export declare class VersionUpdateManager {
-    private dshMnemonVersion;
-    private readonly packageManifestPath;
-    private readonly dshHome;
-    private readonly mnemonCliPath;
-    private readonly processRunner;
-    private readonly executable;
-    private readonly fetchNpmLatest;
-    private readonly fetchMnemonLatest;
-    constructor(dependencies?: VersionUpdateDependencies);
-    get currentDshMnemonVersion(): string;
-    private inspectMnemon;
-    check(): Promise<VersionStatus>;
-    update(component: VersionComponentId): Promise<VersionUpdateResult>;
-}