dsh-mnemon 0.3.4 → 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/MnemonTurnTail.d.ts

@@ -1,5 +1,4 @@
 import type { ClientConnectionHandle } from '../shared/contracts.ts';
-import type { TurnTailOwnerProps } from '@deepseek-ai/dsh-client-ui-conversation/client';
 import { type MnemonAnchorPage } from './anchor.ts';
 import type { MnemonKey } from './locales.ts';
 export interface MnemonTurnTailProps {
@@ -15,6 +14,8 @@ export interface MnemonTurnTailProps {
 /** Route a settled tool name to the workbench page that explains its effect. */
 export declare function memoryPageForTool(name: string): MnemonAnchorPage;
 /** Whether this entry renders for the owner; chain selectors decline quietly. */
-export declare function selectMnemonTurnTail(owner: TurnTailOwnerProps): Record<string, never> | null;
+export declare function selectMnemonTurnTail(owner: {
+    turn: unknown;
+}): Record<string, never> | null;
 /** One-line memory-activity bar under a completed turn; hides when the turn touched no memory. */
 export declare const MnemonTurnTail: import("react").NamedExoticComponent<MnemonTurnTailProps>;

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

@@ -9,7 +9,7 @@ export interface MnemonViewProps {
     workspaceSelection?: MnemonWorkspaceSelection;
     surface?: MnemonViewSurface;
     t?: MnemonTranslate;
-    locale?: 'zh' | 'en';
+    locale?: string;
     onClose?: () => void;
 }
 export interface MnemonWorkspaceSelection {

package/lib/types/src/client/dsh-compat.d.ts

@@ -6,15 +6,46 @@
  */
 import type { ConnectionHandle } from '@deepseek-ai/dsh-client-connection/client';
 import type { LocaleRuntime } from '@deepseek-ai/dsh-client-locale/client';
-import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
+import type { Context } from '@deepseek-ai/cordis';
 import type { MnemonKey } from './locales.ts';
 declare module '@deepseek-ai/dsh-client-ui-slots' {
     interface LocaleNamespaceMap {
         mnemon: MnemonKey;
     }
 }
-/** DSH 0.1.1-rc.2 client context plus the two injected feature services. */
-export type MnemonClientContext = ClientContext & {
+export interface MnemonSessionSummary {
+    cwd?: string;
+    origin?: string;
+    projectionValues?: Readonly<Record<string, unknown>>;
+    [key: string]: unknown;
+}
+export interface MnemonSessionListState {
+    current?: string;
+    byId: Record<string, MnemonSessionSummary>;
+    [key: string]: unknown;
+}
+export interface MnemonWorkspaceSummary {
+    workspaceId: unknown;
+    title: string;
+    path: string;
+}
+export interface MnemonWorkspaceListState {
+    items: MnemonWorkspaceSummary[];
+    [key: string]: unknown;
+}
+interface SnapshotStore<State> {
+    getSnapshot(): State;
+    subscribe(listener: () => void): () => void;
+}
+/** Context shared by the released client runtime and the 0.1.2 controller split. */
+export type MnemonClientContext = Context & {
     connection: ConnectionHandle;
     locale: LocaleRuntime;
+    sessions: {
+        list: SnapshotStore<MnemonSessionListState>;
+    };
+    workspaces: {
+        list: SnapshotStore<MnemonWorkspaceListState>;
+    };
 };
+export {};

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/client/subagent-token-usage.d.ts

@@ -1,6 +1,5 @@
-import type { SessionListState } from '@deepseek-ai/dsh-client-runtime/client';
 import type { SnapshotSelectorHook } from '@deepseek-ai/dsh-client-ui-slots';
-import type { MnemonClientContext } from './dsh-compat.ts';
+import type { MnemonClientContext, MnemonSessionListState } from './dsh-compat.ts';
 export declare const MNEMON_SUBAGENT_TOKEN_USAGE_KEY = "mnemonSubagentTokenUsage";
 export interface MnemonTokenUsageProjection {
     uncachedInputTokens: number;
@@ -13,9 +12,9 @@ export interface MnemonTokenUsageProjection {
  * released official catalog component. All other consumers continue seeing
  * DSH's complete-log `tokenUsage` value.
  */
-export declare function scopeSubagentTokenUsage(state: SessionListState): SessionListState;
+export declare function scopeSubagentTokenUsage(state: MnemonSessionListState): MnemonSessionListState;
 /** Wrap the framework hook while preserving its selector/equality contract. */
-export declare function createScopedUseSessions(useSessions: SnapshotSelectorHook<SessionListState>): SnapshotSelectorHook<SessionListState>;
+export declare function createScopedUseSessions(useSessions: SnapshotSelectorHook<MnemonSessionListState>): SnapshotSelectorHook<MnemonSessionListState>;
 /**
  * Shadow the released official single-slot entry at a lower priority. The
  * component and action factory are captured from the public slot ledger, so

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

@@ -1,12 +1,18 @@
 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) => Promise<RpcResult<unknown>>;
+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: {
-            authority: HostRpcAuthority;
-        }): unknown;
+        handle(channel: string, handler: HostRpcHandler, options: HostRpcRegistrationOptions): unknown;
     };
 }
 export interface HostSettingsScope<T> {
@@ -130,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;
 }
@@ -278,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/rpc.d.ts

@@ -9,14 +9,14 @@ import { VersionUpdateManager } from './version-updates.ts';
 export { MNEMON_ACTIVATION_CHANNEL, MNEMON_PACK_CHANNEL, MNEMON_READ_CHANNEL, MNEMON_WRITE_CHANNEL } from './channels.ts';
 type RuntimeInput = MnemonService | LiveMnemonRuntime;
 export declare function createReadHandler(input: RuntimeInput, lifecycle?: MnemonLifecycle, runtimeMemory?: RuntimeMemoryController, storage?: StorageScopeInspector, versions?: VersionUpdateManager): HostRpcHandler;
-/**
- * Expose only DSH read-routing activation to trusted Web hosts. Metadata,
- * provider connections, credentials, and durable memory writes stay on the
- * loopback-only write channel.
- */
+/** Keep activation on a narrow, independently validated control endpoint. */
 export declare function createActivationHandler(input: RuntimeInput): HostRpcHandler;
 export declare function createWriteHandler(input: RuntimeInput, lifecycle?: MnemonLifecycle, runtimeMemory?: RuntimeMemoryController, versions?: VersionUpdateManager): HostRpcHandler;
-/** Backup payloads contain private memory and use the deployment's management authority. */
+/** Backup payloads contain private memory and stay behind DSH browser authentication. */
 export declare function createPackHandler(input: MnemonPackManager | LiveMnemonRuntime, writeEnabled?: boolean | (() => boolean)): HostRpcHandler;
-/** Reads and activation use trusted hosts; other privileged channels require explicit promotion. */
+/**
+ * Register one call shape across DSH rc.2 and 0.1.2-alpha.1. The former
+ * enforces channel authority; the latter ignores the trailing options object
+ * after applying its uniform browser-session authentication boundary.
+ */
 export declare function registerRpc(connection: HostConnectionHandle, input: RuntimeInput, lifecycle?: MnemonLifecycle, runtimeMemory?: RuntimeMemoryController, storage?: StorageScopeInspector, packs?: MnemonPackManager, versions?: VersionUpdateManager, managementAuthority?: HostRpcAuthority): 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;
@@ -145,7 +152,7 @@ export interface Config {
     displayMode?: 'sidebar' | 'buildin';
     tabEnabled?: boolean;
     writeEnabled?: boolean;
-    /** Remote Web policy for privileged Mnemon RPC. This boundary is sampled at Host startup. */
+    /** DSH rc.2 management-channel authority; ignored by DSH 0.1.2-alpha.1. */
     remoteAccess?: 'read-only' | 'trusted-host';
     lifecycleEnabled?: boolean;
     recallMode?: 'guided' | 'off';
@@ -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';
@@ -232,6 +246,7 @@ export interface ResolvedConfig {
     displayMode: 'sidebar' | 'buildin';
     tabEnabled: boolean;
     writeEnabled: boolean;
+    /** DSH rc.2 management-channel authority; ignored by DSH 0.1.2-alpha.1. */
     remoteAccess: 'read-only' | 'trusted-host';
     lifecycleEnabled: boolean;
     recallMode: 'guided' | 'off';
@@ -248,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.4",
+  "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",
@@ -114,9 +114,9 @@
     },
     "client": {
       "inject": [
-        "@deepseek-ai/dsh-client-runtime",
         "@deepseek-ai/dsh-client-connection",
         "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-renderer",
         "@deepseek-ai/dsh-client-ui-settings",
         "@deepseek-ai/dsh-client-locale"
       ],
@@ -133,7 +133,9 @@
     "verify:build": "node scripts/verify-deterministic-build.mjs",
     "verify:headless": "node scripts/verify-headless-profile.mjs",
     "verify:package": "node scripts/verify-package-contents.mjs && node scripts/verify-public-entries.mjs && pnpm run lint:package",
-    "verify": "pnpm run typecheck && pnpm run test && pnpm run verify:build && pnpm run verify:headless && pnpm run verify:package"
+    "verify": "pnpm run typecheck && pnpm run test && pnpm run verify:build && pnpm run verify:headless && pnpm run verify:package",
+    "dsh:link-source": "node scripts/link-dsh-source.mjs",
+    "dsh:restore-registry": "node scripts/link-dsh-source.mjs --restore"
   },
   "dependencies": {
     "fflate": "^0.8.3",
@@ -142,7 +144,7 @@
     "zod": "^4.4.3"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.0-rc.6 || ^0.1.1-rc.1",
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.0-rc.6 || ^0.1.1-rc.1 || ^0.1.2-alpha.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
   },
@@ -150,15 +152,24 @@
     "@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-runtime": "0.1.1-rc.2",
     "@deepseek-ai/dsh-client-ui-conversation": "0.1.1-rc.2",
     "@deepseek-ai/dsh-client-ui-primitives": "0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-renderer": "0.1.1-rc.2",
     "@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",