dsh-mnemon 0.3.5 → 0.3.6

package/lib/kernel.js

@@ -837,6 +837,7 @@ var MemoryTurnViewManager = class {
 	sourceGeneration = 0;
 	views = /* @__PURE__ */ new Map();
 	turns = /* @__PURE__ */ new Map();
+	retainedViews = /* @__PURE__ */ new Map();
 	pendingReceipts = /* @__PURE__ */ new Map();
 	current;
 	currentByScope = /* @__PURE__ */ new Map();
@@ -922,6 +923,17 @@ var MemoryTurnViewManager = class {
 			return existing;
 		}
 		const view = await this.reconcile(scope);
+		return this.pinTurn(id, scope, view.id);
+	}
+	/** Pin an already-authorized View without re-snapshotting a newer Source. */
+	pinTurn(turnId, scope, viewId) {
+		const id = text(turnId, "memory turn id", 300);
+		const view = this.requireStoredView(viewId).view;
+		const existing = this.turns.get(id);
+		if (existing !== void 0) {
+			if (!sameScope(existing.scope, scope) || existing.viewId !== view.id) throw new Error(`memory turn authority changed while pinned: ${id}`);
+			return existing;
+		}
 		const context = deepFreeze({
 			turnId: id,
 			viewId: view.id,
@@ -932,6 +944,20 @@ var MemoryTurnViewManager = class {
 		this.turns.set(id, context);
 		return context;
 	}
+	/** Keep a delegated View available independently of the originating turn. */
+	retainView(viewId) {
+		const id = this.requireStoredView(viewId).view.id;
+		this.retainedViews.set(id, (this.retainedViews.get(id) ?? 0) + 1);
+		let retained = true;
+		return () => {
+			if (!retained) return;
+			retained = false;
+			const count = this.retainedViews.get(id) ?? 0;
+			if (count > 1) this.retainedViews.set(id, count - 1);
+			else this.retainedViews.delete(id);
+			this.collect();
+		};
+	}
 	turn(turnId) {
 		return this.turns.get(turnId);
 	}
@@ -939,6 +965,26 @@ var MemoryTurnViewManager = class {
 		const id = text(agentId, "memory agent id", 300);
 		return [...this.turns.values()].findLast((turn) => turn.scope.agentId === id);
 	}
+	/**
+	* Latest reconciled View for inspection, not execution authority. A child
+	* must retain its delegated View and pin its own turn instead of inheriting
+	* whatever its parent's later turns happen to publish.
+	*/
+	lastViewForAgent(agentId) {
+		const id = text(agentId, "memory agent id", 300);
+		let match;
+		for (const [key, view] of this.currentByScope) {
+			let owner;
+			try {
+				owner = JSON.parse(key).agentId;
+			} catch {
+				continue;
+			}
+			if (owner !== id) continue;
+			if (match === void 0 || view.createdAt > match.createdAt) match = view;
+		}
+		return match;
+	}
 	endTurn(turnId) {
 		const deleted = this.turns.delete(turnId);
 		if (deleted) this.collect();
@@ -1113,6 +1159,7 @@ var MemoryTurnViewManager = class {
 	collect() {
 		if (this.views.size <= this.maxViews) return;
 		const pinned = new Set([...this.turns.values()].map((turn) => turn.viewId));
+		for (const id of this.retainedViews.keys()) pinned.add(id);
 		if (this.current !== void 0) pinned.add(this.current.id);
 		for (const id of this.views.keys()) {
 			if (this.views.size <= this.maxViews) break;

package/lib/types/packages/kernel/src/view.d.ts

@@ -38,6 +38,7 @@ export declare class MemoryTurnViewManager {
     private sourceGeneration;
     private readonly views;
     private readonly turns;
+    private readonly retainedViews;
     private readonly pendingReceipts;
     private current;
     private readonly currentByScope;
@@ -59,8 +60,18 @@ export declare class MemoryTurnViewManager {
     pendingReceiptCount(): number;
     apply(receipt: MemoryReceipt): boolean;
     beginTurn(turnId: string, scope: MemoryOperationScope): Promise<MemoryTurnContext>;
+    /** Pin an already-authorized View without re-snapshotting a newer Source. */
+    pinTurn(turnId: string, scope: MemoryOperationScope, viewId: string): MemoryTurnContext;
+    /** Keep a delegated View available independently of the originating turn. */
+    retainView(viewId: string): () => void;
     turn(turnId: string): MemoryTurnContext | undefined;
     activeTurn(agentId: string): MemoryTurnContext | undefined;
+    /**
+     * Latest reconciled View for inspection, not execution authority. A child
+     * must retain its delegated View and pin its own turn instead of inheriting
+     * whatever its parent's later turns happen to publish.
+     */
+    lastViewForAgent(agentId: string): MemoryTurnView | undefined;
     endTurn(turnId: string): boolean;
     wake(viewId: string): MemoryWake;
     /** Compile and publish a candidate. On failure, preserve the last valid scoped View. */

package/lib/types/src/agent-memory-turn.d.ts

@@ -0,0 +1,42 @@
+import type { MemoryOperationScope, MemoryTurnContext } from '../packages/contracts/src/index.ts';
+import type { MemoryTurnViewManager } from '../packages/kernel/src/index.ts';
+import type { HostAgent } from './contracts.ts';
+import type { MnemonAgentRuntimeSource, MnemonRuntimeGraph } from './live-runtime.ts';
+/** Host-owned authority captured before a child activation starts executing. */
+export interface DelegatedMemoryView {
+    readonly graph: MnemonRuntimeGraph;
+    readonly scope: MemoryOperationScope;
+    readonly viewId?: string;
+}
+export interface PinnedAgentMemoryTurn {
+    readonly turn: number;
+    readonly graph: MnemonRuntimeGraph;
+    readonly manager: MemoryTurnViewManager;
+    readonly context: MemoryTurnContext;
+    readonly releaseRuntime?: () => void;
+}
+export declare function agentMemoryScope(agent: HostAgent, graph: MnemonRuntimeGraph): MemoryOperationScope;
+/** The durable log, not a parent session id, identifies the executing turn. */
+export declare function openAgentTurn(agent: HostAgent): number | undefined;
+/**
+ * One Agent owns each turn pin. A child additionally retains its delegation
+ * across parent completion, collection, and runtime swaps until it is disposed.
+ */
+export declare class AgentMemoryTurn {
+    private readonly agent;
+    private readonly runtime;
+    private readonly delegation?;
+    private pinned;
+    private pending;
+    private generation;
+    private closed;
+    private readonly releaseDelegation;
+    constructor(agent: HostAgent, runtime: Pick<MnemonAgentRuntimeSource, 'forAgent' | 'bindAgentRuntime'>, delegation?: DelegatedMemoryView | undefined);
+    get current(): PinnedAgentMemoryTurn | undefined;
+    /** Capture now; descendants must not resolve a later parent turn on demand. */
+    delegate(): DelegatedMemoryView;
+    begin(turn: number, signal?: AbortSignal): Promise<void>;
+    end(turn?: number): void;
+    dispose(): void;
+    private pin;
+}

package/lib/types/src/client/locales.d.ts

@@ -748,6 +748,13 @@ export declare const zh: {
     'config.embeddingManagedHint': string;
     'config.embeddingEndpoint': string;
     'config.embeddingModel': string;
+    'config.embeddingApiKey': string;
+    'config.embeddingApiKeyInvalid': string;
+    'config.embeddingProtocol': string;
+    'config.embeddingProtocolAuto': string;
+    'config.embeddingProtocolOllama': string;
+    'config.embeddingProtocolOpenai': string;
+    'config.embeddingProtocolInvalid': string;
     'config.embeddingEndpointInvalid': string;
     'config.embeddingModelInvalid': string;
     'config.embeddingSecurity': string;
@@ -757,7 +764,9 @@ export declare const zh: {
     'config.embeddingSaveBeforeTest': string;
     'config.embeddingTestUnavailable': string;
     'config.embeddingStatusAvailable': string;
+    'config.embeddingStatusAvailableWithProtocol': string;
     'config.embeddingStatusUnavailable': string;
+    'config.embeddingStatusUnavailableWithProtocol': string;
     'config.embeddingStatusFailed': string;
     'config.providerGlobalLocation': string;
     'config.providerGlobalLocationHint': string;
@@ -1655,6 +1664,13 @@ export declare const en: {
     'config.embeddingManagedHint': string;
     'config.embeddingEndpoint': string;
     'config.embeddingModel': string;
+    'config.embeddingApiKey': string;
+    'config.embeddingApiKeyInvalid': string;
+    'config.embeddingProtocol': string;
+    'config.embeddingProtocolAuto': string;
+    'config.embeddingProtocolOllama': string;
+    'config.embeddingProtocolOpenai': string;
+    'config.embeddingProtocolInvalid': string;
     'config.embeddingEndpointInvalid': string;
     'config.embeddingModelInvalid': string;
     'config.embeddingSecurity': string;
@@ -1664,7 +1680,9 @@ export declare const en: {
     'config.embeddingSaveBeforeTest': string;
     'config.embeddingTestUnavailable': string;
     'config.embeddingStatusAvailable': string;
+    'config.embeddingStatusAvailableWithProtocol': string;
     'config.embeddingStatusUnavailable': string;
+    'config.embeddingStatusUnavailableWithProtocol': string;
     'config.embeddingStatusFailed': string;
     'config.providerGlobalLocation': string;
     'config.providerGlobalLocationHint': string;

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

@@ -12,4 +12,4 @@ export declare const DEFAULT_RUNTIME_USER_LIMIT_BYTES: number;
 export declare const DEFAULT_RUNTIME_MAINTENANCE_MAX_TOKENS = 8192;
 export declare const MAX_RUNTIME_MEMORY_LIMIT_BYTES: number;
 export declare const MAX_RUNTIME_MAINTENANCE_MAX_TOKENS = 1000000;
-export { DEFAULT_EMBEDDING_ENDPOINT, DEFAULT_EMBEDDING_MODEL } from './shared/contracts.ts';
+export { DEFAULT_EMBEDDING_ENDPOINT, DEFAULT_EMBEDDING_MODEL, DEFAULT_EMBEDDING_PROTOCOL, MNEMON_EMBEDDING_PROTOCOLS } from './shared/contracts.ts';

package/lib/types/src/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_EMBEDDING_ENDPOINT, DEFAULT_EMBEDDING_MODEL, 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_RUNTIME_MAINTENANCE_MAX_TOKENS, DEFAULT_RUNTIME_MEMORY_LIMIT_BYTES, DEFAULT_RUNTIME_USER_LIMIT_BYTES, DEFAULT_TIMEOUT_MS, MAX_RUNTIME_MAINTENANCE_MAX_TOKENS, MAX_RUNTIME_MEMORY_LIMIT_BYTES, } from './config-values.ts';
+export { DEFAULT_IDLE_REVIEW_MS, DEFAULT_EMBEDDING_ENDPOINT, DEFAULT_EMBEDDING_MODEL, DEFAULT_EMBEDDING_PROTOCOL, 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_RUNTIME_MAINTENANCE_MAX_TOKENS, DEFAULT_RUNTIME_MEMORY_LIMIT_BYTES, DEFAULT_RUNTIME_USER_LIMIT_BYTES, DEFAULT_TIMEOUT_MS, MAX_RUNTIME_MAINTENANCE_MAX_TOKENS, MAX_RUNTIME_MEMORY_LIMIT_BYTES, } from './config-values.ts';
 export type Config = SharedConfig;
 export type CustomPackConfig = SharedCustomPackConfig;
 export type InteractionConfig = SharedInteractionConfig;

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

@@ -136,7 +136,15 @@ export type HostPreStepDecision = {
     messages: HostUserMessage[];
 };
 export interface HostAgentContext {
-    on(name: string, listener: (...args: never[]) => unknown): () => 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;
     get?(name: string): unknown;
 }
@@ -284,6 +292,14 @@ export interface HostContextShape {
     /** 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;
-    on(name: string, listener: (...args: never[]) => unknown): () => 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/guidance.d.ts

@@ -6,6 +6,7 @@ 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<{

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

@@ -22,6 +22,8 @@ export declare class MnemonLifecycle {
     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;
@@ -73,4 +75,6 @@ export declare class MnemonLifecycle {
     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

@@ -29,7 +29,7 @@ export interface MnemonRuntimeGraph {
 export interface MnemonAgentRuntimeSource {
     readonly config: ResolvedConfig;
     forAgent(agent: HostAgent): MnemonRuntimeGraph;
-    /** Pin every tool in one Agent turn to the same immutable runtime generation. */
+    /** Retain one runtime generation for an Agent turn or delegated child lifetime. */
     bindAgentRuntime(agentId: string, graph: MnemonRuntimeGraph): () => void;
 }
 /**

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

@@ -10,6 +10,13 @@ export declare const MNEMON_SETTINGS_NAMESPACE = "mnemon";
 export declare const MNEMON_UI_SETTINGS_NAMESPACE = "mnemon-ui";
 export declare const DEFAULT_EMBEDDING_ENDPOINT = "http://localhost:11434";
 export declare const DEFAULT_EMBEDDING_MODEL = "nomic-embed-text";
+export declare const EMBEDDING_PROTOCOL_AUTO = "auto";
+export declare const EMBEDDING_PROTOCOL_OLLAMA = "ollama";
+export declare const EMBEDDING_PROTOCOL_OPENAI = "openai";
+/** Default protocol defers to Mnemon's /v1 auto-detection. */
+export declare const DEFAULT_EMBEDDING_PROTOCOL = "auto";
+/** Wire protocols accepted by the embedding protocol override; single source for schema, resolver, and UI validation. */
+export declare const MNEMON_EMBEDDING_PROTOCOLS: readonly ["auto", "ollama", "openai"];
 export type JsonPrimitive = string | number | boolean | null;
 export type JsonValue = JsonPrimitive | JsonValue[] | {
     [key: string]: JsonValue;
@@ -161,16 +168,23 @@ export interface Config {
     /** Model route used by clean, session-independent maintenance Agents. */
     taskAgentModel?: TaskAgentModelConfig;
 }
+export type MnemonEmbeddingProtocol = (typeof MNEMON_EMBEDDING_PROTOCOLS)[number];
 export interface MnemonEmbeddingConfig {
     /** When false or omitted, Mnemon keeps its inherited environment and built-in defaults. */
     enabled?: boolean;
     endpoint?: string;
     model?: string;
+    /** Optional Bearer token forwarded as MNEMON_EMBED_API_KEY for OpenAI-compatible endpoints. */
+    apiKey?: string;
+    /** Explicit wire-protocol override; 'auto' keeps Mnemon's /v1 auto-detection. */
+    protocol?: MnemonEmbeddingProtocol;
 }
 export interface ResolvedMnemonEmbeddingConfig {
     enabled: boolean;
     endpoint: string;
     model: string;
+    apiKey: string;
+    protocol: MnemonEmbeddingProtocol;
 }
 export interface TaskAgentModelConfig {
     mode?: 'inherit' | 'fixed';
@@ -249,6 +263,8 @@ export interface ResolvedConfig {
 export interface MnemonEmbeddingStatus {
     available: boolean;
     model: string;
+    /** Protocol Mnemon resolved for the embedding endpoint; omitted when the CLI does not report one. */
+    protocol?: string;
     totalInsights: number;
     embedded: number;
     coverage: string;

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

@@ -79,12 +79,12 @@ export declare class MnemonSubagentCoordinator {
     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 root turn. */
+    /** 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 root turn. */
+    /** 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;

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

@@ -5,6 +5,6 @@ import type { MnemonAgentRuntimeSource } from './live-runtime.ts';
 import { MnemonSubagentCoordinator } from './subagent.ts';
 import { type MnemonService } from './service.ts';
 type AgentRuntimeSource = MnemonAgentRuntimeSource;
-/** Root calls delegate to a bounded child; memory-worker calls reach the deterministic service. */
+/** 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mnemon",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "Composable three-tier memory control plane for DeepSeek Harness: persistent runtime context, searchable project documents, pluggable long-term memory, guarded strategies, WebUI, and headless tools.",
   "keywords": [
     "deepseek-harness",
@@ -152,6 +152,8 @@
     "@arethetypeswrong/cli": "^0.18.5",
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-agent": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-agent-loop": "0.1.1-rc.2",
     "@deepseek-ai/dsh-client-connection": "0.1.1-rc.2",
     "@deepseek-ai/dsh-client-locale": "0.1.1-rc.2",
     "@deepseek-ai/dsh-client-ui-conversation": "0.1.1-rc.2",
@@ -160,7 +162,14 @@
     "@deepseek-ai/dsh-client-ui-settings": "0.1.1-rc.2",
     "@deepseek-ai/dsh-client-ui-slots": "0.1.1-rc.2",
     "@deepseek-ai/dsh-client-ui-tool": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-llm": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-session": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-session-persistence-jsonl": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-session-query": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-subagent": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-subagent-spawn-in-process": "0.1.1-rc.2",
     "@deepseek-ai/dsh-system-prompt": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-tools": "0.1.1-rc.2",
     "@testing-library/react": "^16.3.0",
     "@types/node": "^22.0.0",
     "@types/react": "^18.3.0",