dsh-mnemon 0.2.6 → 0.2.8

package/lib/types/config-values.d.ts

@@ -1,3 +1,9 @@
 export declare const DEFAULT_TIMEOUT_MS = 10000;
 export declare const DEFAULT_RECALL_LIMIT = 10;
 export declare const DEFAULT_IDLE_REVIEW_MS = 30000;
+export declare const DEFAULT_RECALL_QUALITY_POLICY = "strict-v1";
+export declare const DEFAULT_RECALL_LOW_SCORE_THRESHOLD = 0.25;
+export declare const DEFAULT_RECALL_HIGH_SCORE_THRESHOLD = 0.6;
+export declare const DEFAULT_RECALL_CANDIDATE_MULTIPLIER = 3;
+export declare const DEFAULT_RECALL_MAX_MEDIUM_RESULTS = 4;
+export declare const DEFAULT_RECALL_MAX_UNKNOWN_RESULTS = 2;

package/lib/types/config.d.ts

@@ -1,6 +1,6 @@
 import z from 'schemastery';
 import type { Config as SharedConfig, CustomPackConfig as SharedCustomPackConfig, InteractionConfig as SharedInteractionConfig, ResolvedConfig as SharedResolvedConfig, ResolvedInteractionConfig as SharedResolvedInteractionConfig } from './shared/contracts.ts';
-export { DEFAULT_IDLE_REVIEW_MS, DEFAULT_RECALL_LIMIT, DEFAULT_TIMEOUT_MS } from './config-values.ts';
+export { DEFAULT_IDLE_REVIEW_MS, DEFAULT_RECALL_CANDIDATE_MULTIPLIER, DEFAULT_RECALL_HIGH_SCORE_THRESHOLD, DEFAULT_RECALL_LIMIT, DEFAULT_RECALL_LOW_SCORE_THRESHOLD, DEFAULT_RECALL_MAX_MEDIUM_RESULTS, DEFAULT_RECALL_MAX_UNKNOWN_RESULTS, DEFAULT_RECALL_QUALITY_POLICY, DEFAULT_TIMEOUT_MS, } from './config-values.ts';
 export type Config = SharedConfig;
 export type CustomPackConfig = SharedCustomPackConfig;
 export type InteractionConfig = SharedInteractionConfig;

package/lib/types/contracts.d.ts

@@ -34,6 +34,11 @@ export interface HostSettingsService {
 export interface ToolExecution {
     signal: AbortSignal;
     agent?: HostAgent;
+    name?: string;
+    parent?: symbol;
+    token?: symbol;
+    /** End the current model turn after an authoritative terminal tool call. */
+    concludeTurn?: () => void;
 }
 export type CommandResult = {
     kind: 'success';

package/lib/types/index.d.ts

@@ -9,6 +9,8 @@ import { MnemonSubagentCoordinator } from './subagent.ts';
 import { StorageScopeInspector } from './storage-scope.ts';
 import { MnemonPackManager } from './pack.ts';
 import { VersionUpdateManager } from './version-updates.ts';
+export { BALANCED_RECALL_QUALITY_POLICY, EXHAUSTIVE_RECALL_QUALITY_POLICY, RecallQualityPolicyRegistry, STRICT_RECALL_QUALITY_POLICY, recallQualityPolicies, registerRecallQualityPolicy, } from './recall-quality/index.ts';
+export type { RecallQualityCandidate, RecallQualityDecision, RecallQualityPolicy, RecallQualityPolicyContext, } from './recall-quality/index.ts';
 export declare const name = "dsh-mnemon";
 export declare const inject: string[];
 export { Config, InteractionConfig, resolveConfig, resolveInteractionConfig, DocumentManager, LiveMnemonRuntime, MnemonLifecycle, MnemonService, MnemonSubagentCoordinator, RuntimeMemoryController, StorageScopeInspector, MnemonPackManager, VersionUpdateManager, createRunner, createRuntimeGraph };

package/lib/types/providers/byterover.d.ts

@@ -2,7 +2,7 @@ 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';
+import { type MemoryProviderAdapter, type ProviderBodyStatus, type ProviderMemorySpace, type ProviderSearchResult } from './provider.ts';
 interface ByteRoverProviderOptions {
     process?: ProcessRunner;
     queryTimeoutMs?: number;
@@ -11,6 +11,7 @@ interface ByteRoverProviderOptions {
 export declare class ByteRoverProvider implements MemoryProviderAdapter {
     private readonly memoryBodies;
     readonly id: "byterover";
+    readonly scoreSemantics: import("./provider.ts").ProviderScoreSemantics;
     private readonly process;
     private readonly queryTimeoutMs;
     private readonly curateTimeoutMs;

package/lib/types/providers/hindsight.d.ts

@@ -2,9 +2,10 @@ 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';
+import { type MemoryProviderAdapter, type ProviderBodyStatus, type ProviderMemorySpace, type ProviderSearchResult } from './provider.ts';
 export declare class HindsightProvider extends HttpMemoryProvider implements MemoryProviderAdapter {
     readonly id: "hindsight";
+    readonly scoreSemantics: import("./provider.ts").ProviderScoreSemantics;
     constructor(memoryBodies: MemoryBodyRegistry, options?: HttpProviderOptions);
     discover(connection: Record<string, string | number | boolean>, signal?: AbortSignal): Promise<ProviderMemorySpace[]>;
     status(body: MemoryBody, signal?: AbortSignal): Promise<ProviderBodyStatus>;

package/lib/types/providers/holographic.d.ts

@@ -1,10 +1,11 @@
 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';
+import { type MemoryProviderAdapter, type ProviderBodyStatus, type ProviderMemorySpace, type ProviderSearchResult } from './provider.ts';
 export declare class HolographicProvider implements MemoryProviderAdapter {
     private readonly memoryBodies;
     readonly id: "holographic";
+    readonly scoreSemantics: import("./provider.ts").ProviderScoreSemantics;
     constructor(memoryBodies: MemoryBodyRegistry);
     discover(connection: MemoryProviderConnection): Promise<ProviderMemorySpace[]>;
     status(body: MemoryBody): Promise<ProviderBodyStatus>;

package/lib/types/providers/mem0.d.ts

@@ -2,9 +2,10 @@ 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';
+import { type MemoryProviderAdapter, type ProviderBodyStatus, type ProviderMemorySpace, type ProviderSearchResult } from './provider.ts';
 export declare class Mem0Provider extends HttpMemoryProvider implements MemoryProviderAdapter {
     readonly id: "mem0";
+    readonly scoreSemantics: import("./provider.ts").ProviderScoreSemantics;
     constructor(memoryBodies: MemoryBodyRegistry, options?: HttpProviderOptions);
     discover(connection: Record<string, string | number | boolean>, signal?: AbortSignal): Promise<ProviderMemorySpace[]>;
     status(body: MemoryBody, signal?: AbortSignal): Promise<ProviderBodyStatus>;

package/lib/types/providers/openviking.d.ts

@@ -1,7 +1,7 @@
 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';
+import { type MemoryProviderAdapter, type ProviderBodyStatus, type ProviderMemorySpace, type ProviderSearchResult } from './provider.ts';
 interface OpenVikingProviderOptions {
     fetch?: typeof fetch;
     requestTimeoutMs?: number;
@@ -11,6 +11,7 @@ interface OpenVikingProviderOptions {
 export declare class OpenVikingProvider implements MemoryProviderAdapter {
     private readonly memoryBodies;
     readonly id: "openviking";
+    readonly scoreSemantics: import("./provider.ts").ProviderScoreSemantics;
     private readonly requestFetch;
     private readonly requestTimeoutMs;
     private readonly settlementTimeoutMs;

package/lib/types/providers/provider.d.ts

@@ -9,6 +9,11 @@ export interface ProviderSearchResult {
     results: Insight[];
     hint?: string;
 }
+export interface ProviderScoreSemantics {
+    /** Provider promises a finite relevance score in 0..1 where larger is better. */
+    kind: 'normalized-relevance';
+}
+export declare const NORMALIZED_RELEVANCE_SCORE: ProviderScoreSemantics;
 /** 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. */
@@ -23,6 +28,7 @@ export interface ProviderMemorySpace {
  */
 export interface MemoryProviderAdapter {
     readonly id: MemoryBody['provider']['id'];
+    readonly scoreSemantics?: ProviderScoreSemantics;
     /** 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. */

package/lib/types/providers/retaindb.d.ts

@@ -2,9 +2,10 @@ 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';
+import { type MemoryProviderAdapter, type ProviderBodyStatus, type ProviderMemorySpace, type ProviderSearchResult } from './provider.ts';
 export declare class RetainDbProvider extends HttpMemoryProvider implements MemoryProviderAdapter {
     readonly id: "retaindb";
+    readonly scoreSemantics: import("./provider.ts").ProviderScoreSemantics;
     constructor(memoryBodies: MemoryBodyRegistry, options?: HttpProviderOptions);
     discover(connection: Record<string, string | number | boolean>, signal?: AbortSignal): Promise<ProviderMemorySpace[]>;
     status(body: MemoryBody, signal?: AbortSignal): Promise<ProviderBodyStatus>;

package/lib/types/providers/supermemory.d.ts

@@ -2,9 +2,10 @@ 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';
+import { type MemoryProviderAdapter, type ProviderBodyStatus, type ProviderMemorySpace, type ProviderSearchResult } from './provider.ts';
 export declare class SupermemoryProvider extends HttpMemoryProvider implements MemoryProviderAdapter {
     readonly id: "supermemory";
+    readonly scoreSemantics: import("./provider.ts").ProviderScoreSemantics;
     constructor(memoryBodies: MemoryBodyRegistry, options?: HttpProviderOptions);
     discover(connection: Record<string, string | number | boolean>, signal?: AbortSignal): Promise<ProviderMemorySpace[]>;
     status(body: MemoryBody, signal?: AbortSignal): Promise<ProviderBodyStatus>;

package/lib/types/recall-quality/contracts.d.ts

@@ -0,0 +1,32 @@
+import type { Insight, MemoryProviderId, ResolvedRecallQualityConfig } from '../shared/contracts.ts';
+import type { ProviderScoreSemantics } from '../providers/provider.ts';
+export type RecallQualityDecisionReason = 'high-score' | 'medium-score' | 'low-score' | 'non-positive-score' | 'invalid-score' | 'unscaled-score' | 'unscored';
+export interface RecallQualityCandidate {
+    insight: Insight;
+    memoryBodyId: string;
+    providerId: MemoryProviderId;
+    providerRank: number;
+    bodyOrder: number;
+    scoreSemantics?: ProviderScoreSemantics;
+}
+export interface RecallQualityDecision {
+    action: 'keep' | 'drop';
+    tier: 'high' | 'medium' | 'low' | 'unknown';
+    reason: RecallQualityDecisionReason;
+    normalizedScore?: number;
+}
+export interface EvaluatedRecallQualityCandidate {
+    candidate: RecallQualityCandidate;
+    decision: RecallQualityDecision;
+}
+export interface RecallQualityPolicyContext {
+    requestedLimit: number;
+    config: ResolvedRecallQualityConfig;
+}
+/** Pure, bounded policy applied before recall rows are serialized to an Agent. */
+export interface RecallQualityPolicy {
+    readonly id: string;
+    candidateLimit(context: RecallQualityPolicyContext): number;
+    evaluate(candidate: RecallQualityCandidate, context: RecallQualityPolicyContext): RecallQualityDecision;
+    select(candidates: readonly EvaluatedRecallQualityCandidate[], context: RecallQualityPolicyContext): EvaluatedRecallQualityCandidate[];
+}

package/lib/types/recall-quality/engine.d.ts

@@ -0,0 +1,13 @@
+import type { EvaluatedRecallQualityCandidate, RecallQualityCandidate, RecallQualityPolicy, RecallQualityPolicyContext } from './contracts.ts';
+export interface PreparedRecallQualityPolicy {
+    policy: RecallQualityPolicy;
+    candidateLimit: number;
+    fallbackFrom?: string;
+}
+export declare function prepareRecallQualityPolicy(policy: RecallQualityPolicy, context: RecallQualityPolicyContext, fallback?: RecallQualityPolicy): PreparedRecallQualityPolicy;
+export declare function applyRecallQualityPolicy(prepared: PreparedRecallQualityPolicy, candidates: readonly RecallQualityCandidate[], context: RecallQualityPolicyContext, fallback?: RecallQualityPolicy): {
+    policyId: string;
+    fallbackFrom?: string;
+    evaluated: EvaluatedRecallQualityCandidate[];
+    selected: EvaluatedRecallQualityCandidate[];
+};

package/lib/types/recall-quality/index.d.ts

@@ -0,0 +1,4 @@
+export type { EvaluatedRecallQualityCandidate, RecallQualityCandidate, RecallQualityDecision, RecallQualityDecisionReason, RecallQualityPolicy, RecallQualityPolicyContext, } from './contracts.ts';
+export { BALANCED_RECALL_QUALITY_POLICY, BUILTIN_RECALL_QUALITY_POLICIES, EXHAUSTIVE_RECALL_QUALITY_POLICY, STRICT_RECALL_QUALITY_POLICY, } from './policies.ts';
+export { applyRecallQualityPolicy, prepareRecallQualityPolicy, type PreparedRecallQualityPolicy } from './engine.ts';
+export { RecallQualityPolicyRegistry, recallQualityPolicies, registerRecallQualityPolicy } from './registry.ts';

package/lib/types/recall-quality/policies.d.ts

@@ -0,0 +1,5 @@
+import type { RecallQualityPolicy } from './contracts.ts';
+export declare const STRICT_RECALL_QUALITY_POLICY: RecallQualityPolicy;
+export declare const BALANCED_RECALL_QUALITY_POLICY: RecallQualityPolicy;
+export declare const EXHAUSTIVE_RECALL_QUALITY_POLICY: RecallQualityPolicy;
+export declare const BUILTIN_RECALL_QUALITY_POLICIES: readonly [RecallQualityPolicy, RecallQualityPolicy, RecallQualityPolicy];

package/lib/types/recall-quality/registry.d.ts

@@ -0,0 +1,10 @@
+import type { RecallQualityPolicy } from './contracts.ts';
+export declare class RecallQualityPolicyRegistry {
+    private readonly policies;
+    constructor(policies?: readonly RecallQualityPolicy[]);
+    register(policy: RecallQualityPolicy): () => void;
+    resolve(id: string): RecallQualityPolicy;
+    ids(): string[];
+}
+export declare const recallQualityPolicies: RecallQualityPolicyRegistry;
+export declare function registerRecallQualityPolicy(policy: RecallQualityPolicy): () => void;

package/lib/types/service.d.ts

@@ -3,9 +3,10 @@ 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 LlmMemoryPlacementSelection, type PreparedMemoryPlacement } from './provider-placement.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 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, MemoryReadSource, RememberRequest, SearchRequest, Source, StatusView, } from './shared/contracts.ts';
+export type { Category, EdgeType, EntityView, Insight, Intent, MemoryBodyCatalog, MemoryBodyStats, MemoryBodyView, MemoryGraphEdge, MemoryGraphNode, MemoryGraphSnapshot, MemoryListRequest, MemoryListView, MemoryReadSource, RecallQualityStats, RememberRequest, SearchRequest, Source, StatusView, } from './shared/contracts.ts';
 export interface MemoryBodyMetadataSample {
     memoryBodyId: string;
     name: string;
@@ -22,8 +23,9 @@ export declare class MnemonService {
     readonly config: ResolvedConfig;
     readonly memoryBodies: MemoryBodyRegistry;
     private readonly providers;
+    private readonly recallQualityPolicy;
     private bodiesInFlight;
-    constructor(runner: MnemonRunner, config: ResolvedConfig, memoryBodies?: MemoryBodyRegistry);
+    constructor(runner: MnemonRunner, config: ResolvedConfig, memoryBodies?: MemoryBodyRegistry, recallQualityPolicyRegistry?: RecallQualityPolicyRegistry);
     bodies(signal?: AbortSignal): Promise<MemoryBodyCatalog>;
     /** Coalesce simultaneous Status/Memory-page probes without caching mutations. */
     private collectBodies;

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

@@ -68,6 +68,26 @@ export interface CustomPackConfig {
     name: string;
     dataDir: string;
 }
+export interface RecallQualityConfig {
+    /** Registered deterministic policy id. */
+    policy?: string;
+    lowScoreThreshold?: number;
+    highScoreThreshold?: number;
+    /** Provider candidate expansion before quality filtering, from 1 through 5. */
+    candidateMultiplier?: number;
+    /** Maximum medium-relevance rows admitted by the strict policy. */
+    maxMediumResults?: number;
+    /** Maximum unknown-scale or unscored rows admitted by the strict policy. */
+    maxUnknownResults?: number;
+}
+export interface ResolvedRecallQualityConfig {
+    policy: string;
+    lowScoreThreshold: number;
+    highScoreThreshold: number;
+    candidateMultiplier: number;
+    maxMediumResults: number;
+    maxUnknownResults: number;
+}
 export interface Config {
     storageScope?: StorageScopeKind;
     cliPath?: string;
@@ -77,6 +97,7 @@ export interface Config {
     store?: string;
     timeoutMs?: number;
     defaultRecallLimit?: number;
+    recallQuality?: RecallQualityConfig;
     routingGuidance?: boolean;
     displayMode?: 'sidebar' | 'buildin';
     tabEnabled?: boolean;
@@ -146,6 +167,7 @@ export interface ResolvedConfig {
     store?: string;
     timeoutMs: number;
     defaultRecallLimit: number;
+    recallQuality: ResolvedRecallQualityConfig;
     routingGuidance: boolean;
     displayMode: 'sidebar' | 'buildin';
     tabEnabled: boolean;
@@ -365,6 +387,7 @@ export type EdgeType = 'temporal' | 'semantic' | 'causal' | 'entity';
 export declare const EDGE_TYPES: readonly ["temporal", "semantic", "causal", "entity"];
 export type Intent = 'WHY' | 'WHEN' | 'ENTITY' | 'GENERAL';
 export declare const INTENTS: readonly ["WHY", "WHEN", "ENTITY", "GENERAL"];
+export type RecallRelevanceTier = 'high' | 'medium' | 'low' | 'unknown';
 export interface Insight {
     id: string;
     content: string;
@@ -374,6 +397,10 @@ export interface Insight {
     entities?: string[];
     source?: string;
     score?: number;
+    /** Policy-normalized query relevance; absent for unknown Provider score scales. */
+    normalizedScore?: number;
+    /** Query relevance assigned by the active deterministic recall quality policy. */
+    relevanceTier?: RecallRelevanceTier;
     /** Comparable rank score only when results were fused across providers. */
     federatedScore?: number;
     confidence?: string;
@@ -483,6 +510,19 @@ export interface MemoryReadSource {
     itemCount: number;
     edgeCount?: number;
     hint?: string;
+    quality?: RecallQualityStats;
+}
+export interface RecallQualityStats {
+    policyId: string;
+    fallbackFrom?: string;
+    fetched: number;
+    retained: number;
+    selected: number;
+    droppedLowScore: number;
+    droppedNonPositiveScore: number;
+    droppedInvalidScore: number;
+    unscored: number;
+    unscaled: number;
 }
 export interface MemoryListRequest {
     query?: string;
@@ -772,6 +812,7 @@ export interface StatusView {
     writeEnabled: boolean;
     timeoutMs: number;
     defaultRecallLimit: number;
+    recallQuality: ResolvedRecallQualityConfig;
     memoryBodyDirectory: string;
     memoryBodies: MemoryBodyView[];
     providerServices?: MemoryProviderRuntimeStatus[];

package/lib/types/subagent.d.ts

@@ -1,4 +1,4 @@
-import type { HostAgent, HostSubagentsService } from './contracts.ts';
+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 { Insight, MnemonService, RememberRequest, SearchRequest } from './service.ts';
@@ -12,6 +12,13 @@ interface AgentRuntimeSource {
         documents: DocumentManager;
     };
 }
+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 DelegatedRecallResult {
@@ -66,10 +73,11 @@ export declare class MnemonSubagentCoordinator {
     private readonly subagents;
     private readonly runtimeMemoryOrSource?;
     private readonly documents?;
+    private readonly resultRuntime?;
     private readonly counters;
     private runtimeQueue;
     private documentQueue;
-    constructor(subagents: HostSubagentsService, runtimeMemoryOrSource?: (RuntimeMemoryController | AgentRuntimeSource) | undefined, documents?: DocumentManager | undefined);
+    constructor(subagents: HostSubagentsService, runtimeMemoryOrSource?: (RuntimeMemoryController | AgentRuntimeSource) | undefined, documents?: DocumentManager | undefined, resultRuntime?: HostResultToolRuntime | undefined);
     snapshot(): SubagentCounters;
     documentsSnapshot(parent: HostAgent): import("./documents.ts").DocumentSnapshot;
     documentGet(parent: HostAgent, id: string): DocumentView;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mnemon",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Three-tier memory control plane for DeepSeek Harness: persistent runtime context, searchable project documents, pluggable long-term memory, smart routing, supervised agent workflows, WebUI, and headless tools.",
   "keywords": [
     "deepseek-harness",