@snoai/memory 0.0.0-stage → 1.0.0

package/dist/provider-registration-CF1tg8Xy.js

@@ -0,0 +1,721 @@
+import { MAX_LIST_LIMIT } from "./internal/config/index.js";
+import { Y as FIXED_MEMORY_ROW_PATH_PATTERN, at as FIXED_PROTOCOL_VALUE_66, ht as FIXED_PROTOCOL_VALUE_76, it as FIXED_PROTOCOL_VALUE_65, ot as FIXED_PROTOCOL_VALUE_67, pt as FIXED_PROTOCOL_VALUE_74, st as FIXED_PROTOCOL_VALUE_68, wt as PERSISTED_PROVIDER_SYSTEM } from "./signed-registry-constants-yq3DlG3B.js";
+import { StorageError } from "./internal/engine/shared/errors.js";
+import { s as parseInsightMetadata } from "./memory-metadata-codec-DL1sbJiN.js";
+import { clampInt } from "./internal/engine/shared/utils.js";
+import { listCanonicalMemoryFiles, readCanonicalMemoryFile, searchCanonicalMemoryFiles } from "./internal/engine/provider/canonical-memory-corpus.js";
+import { isProviderRowId, providerRowPath, renderProviderRowMemory } from "./internal/engine/provider/provider-row-renderer.js";
+import { createLogger, currentLogContext, privateLogReference, withLogContext } from "@snoai/utils/logger";
+import { resolve } from "node:path";
+import { createUUIDv7, isLowercaseCanonicalUUIDv7 } from "@snoai/common-core";
+import { bootstrapIdentity } from "@snoai/observability";
+import { randomUUID } from "node:crypto";
+//#region src/engine/provider/provider-authority.ts
+/** @file provider-authority.ts
+* @purpose Resolves SnoStationMem external project/agent keys to internal provider authority.
+* @boundary SQLite mapping tables and project-agent membership checks.
+*/
+function validateAuthorityInput(input) {
+	const userId = input.trustedUserId.trim();
+	if (userId.length === 0) throw new StorageError("Provider authority userId is required");
+	if (!isLowercaseCanonicalUUIDv7(userId)) throw new StorageError("trusted userId must be a lowercase UUID-v7");
+	if (input.externalSystem !== "openclaw") throw new StorageError(FIXED_PROTOCOL_VALUE_76);
+	const projectKey = input.projectKey.trim();
+	if (projectKey.length === 0) throw new StorageError("Provider authority projectKey is required");
+	const agentKey = input.agentKey.trim();
+	if (agentKey.length === 0) throw new StorageError("Provider authority agentKey is required");
+	return {
+		userId,
+		projectKey,
+		agentKey
+	};
+}
+function selectProjectMapping(store, userId, projectKey) {
+	return store.sqlite.prepare(FIXED_PROTOCOL_VALUE_65).get(userId, projectKey);
+}
+function selectAgentMapping(store, userId, agentKey) {
+	return store.sqlite.prepare(FIXED_PROTOCOL_VALUE_66).get(userId, agentKey);
+}
+function ensureProjectMapping(store, userId, projectKey) {
+	const existing = selectProjectMapping(store, userId, projectKey);
+	if (existing) return {
+		projectId: existing.project_id,
+		created: false
+	};
+	const projectId = createUUIDv7();
+	store.sqlite.prepare(FIXED_PROTOCOL_VALUE_67).run(userId, projectKey, projectId, Date.now());
+	const winner = selectProjectMapping(store, userId, projectKey);
+	if (!winner) throw new StorageError("Provider project mapping insert did not persist");
+	return {
+		projectId: winner.project_id,
+		created: winner.project_id === projectId
+	};
+}
+function ensureAgentMapping(store, userId, agentKey) {
+	const existing = selectAgentMapping(store, userId, agentKey);
+	if (existing) return existing.agent_id;
+	const agentId = createUUIDv7();
+	store.sqlite.prepare(FIXED_PROTOCOL_VALUE_68).run(userId, agentKey, agentId, Date.now());
+	const winner = selectAgentMapping(store, userId, agentKey);
+	if (!winner) throw new StorageError("Provider agent mapping insert did not persist");
+	return winner.agent_id;
+}
+function hasMembership(store, userId, projectId, agentId) {
+	return store.sqlite.prepare("SELECT 1 FROM nodix_provider_project_agents WHERE user_id = ? AND project_id = ? AND agent_id = ? LIMIT 1").get(userId, projectId, agentId) !== void 0;
+}
+function insertMembership(store, userId, projectId, agentId) {
+	store.sqlite.prepare("INSERT OR IGNORE INTO nodix_provider_project_agents(user_id, project_id, agent_id, created_at_ms) VALUES (?, ?, ?, ?)").run(userId, projectId, agentId, Date.now());
+}
+async function resolveProviderAuthority(store, input) {
+	const { userId, projectKey, agentKey } = validateAuthorityInput(input);
+	return store.writeMutex.runExclusive(() => {
+		let resolved;
+		store.sqlite.transaction(() => {
+			const project = ensureProjectMapping(store, userId, projectKey);
+			const agentId = ensureAgentMapping(store, userId, agentKey);
+			insertMembership(store, userId, project.projectId, agentId);
+			resolved = {
+				userId,
+				projectId: project.projectId,
+				agentId
+			};
+		}).immediate();
+		if (!resolved) throw new StorageError("Provider authority resolution failed");
+		return resolved;
+	});
+}
+async function readProviderAuthority(store, input) {
+	const { userId, projectKey, agentKey } = validateAuthorityInput(input);
+	return store.writeMutex.runExclusive(() => {
+		const project = selectProjectMapping(store, userId, projectKey);
+		if (!project) throw new StorageError("Provider project provisioning is required");
+		const agent = selectAgentMapping(store, userId, agentKey);
+		if (!agent || !hasMembership(store, userId, project.project_id, agent.agent_id)) throw new StorageError("Provider project-agent membership is required");
+		return {
+			userId,
+			projectId: project.project_id,
+			agentId: agent.agent_id
+		};
+	});
+}
+//#endregion
+//#region src/engine/provider/provider-search-manager.ts
+const diagnosticLog$1 = createLogger("sno-station-mem:provider-search-manager");
+const ROW_PATH_RE = FIXED_MEMORY_ROW_PATH_PATTERN;
+const DEFAULT_SEARCH_LIMIT = 10;
+const DEFAULT_READ_LINES = 200;
+const MAX_READ_LINES = 2e3;
+const EMBEDDING_FAILURE_RETRY_MS = 3e4;
+function scoreAtLeast(score, minScore) {
+	return Number.isFinite(score) && score >= minScore;
+}
+function lineBound(text, from, lines) {
+	const allLines = text.split("\n");
+	const start = clampInt(from ?? 1, 1, Math.max(allLines.length, 1));
+	const requested = clampInt(lines ?? DEFAULT_READ_LINES, 1, MAX_READ_LINES);
+	const endExclusive = Math.min(start - 1 + requested, allLines.length);
+	const truncated = endExclusive < allLines.length;
+	return {
+		text: allLines.slice(start - 1, endExclusive).join("\n"),
+		truncated,
+		from: start,
+		lines: requested,
+		...truncated ? { nextFrom: endExclusive + 1 } : {}
+	};
+}
+function mapSearchResult(result, source) {
+	const rendered = renderProviderRowMemory(result.entry);
+	const snippet = result.snippet && result.snippet.length > 0 ? result.snippet : result.entry.text;
+	return {
+		path: providerRowPath(result.entry.id),
+		startLine: 1,
+		endLine: rendered.split("\n").length,
+		score: result.score,
+		...source === "semantic" ? { vectorScore: result.score } : { textScore: result.score },
+		snippet,
+		source: "memory",
+		citation: providerRowPath(result.entry.id)
+	};
+}
+function readCount(value) {
+	if (!value || typeof value !== "object") return 0;
+	const count = value.count;
+	return typeof count === "number" ? count : 0;
+}
+var SnoStationMemProviderSearchManager = class {
+	options;
+	cachedEmbeddingAvailability = null;
+	embeddingRetryAfterMs = 0;
+	authorizedCanonicalPaths = /* @__PURE__ */ new Set();
+	closed = false;
+	constructor(options) {
+		this.options = options;
+	}
+	async search(query, opts = {}) {
+		return withLogContext({ operation_id: currentLogContext().operation_id ?? randomUUID() }, async () => {
+			const started = performance.now();
+			let outcome = "failed";
+			let fallback = "none";
+			let semanticCount;
+			let keywordCount;
+			let served = [];
+			let failure;
+			const canonicalDiagnostics = {
+				io_failure_count: 0,
+				unavailable_file_count: 0
+			};
+			try {
+				this.assertOpen();
+				if (opts.signal?.aborted) throw new Error("Provider memory search aborted");
+				if (opts.sources && !opts.sources.includes("memory")) {
+					outcome = "skipped";
+					return [];
+				}
+				const maxResults = clampInt(opts.maxResults ?? DEFAULT_SEARCH_LIMIT, 1, MAX_LIST_LIMIT);
+				const minScore = opts.minScore ?? 0;
+				const searchOptions = {
+					limit: maxResults,
+					minScore,
+					projectIdFilter: [this.options.identity.projectId],
+					excludeInvalidatedBefore: Date.now(),
+					includeRefused: true
+				};
+				opts.onDebug?.({
+					backend: "qmd",
+					effectiveMode: "sno-station-mem-row-semantic"
+				});
+				let rowResults = [];
+				const cachedEmbeddingFailure = Date.now() < this.embeddingRetryAfterMs;
+				if (!await this.probeVectorAvailability() || cachedEmbeddingFailure) {
+					fallback = cachedEmbeddingFailure ? "cached_embedding_failure" : "vector_unavailable";
+					opts.onDebug?.({
+						backend: "qmd",
+						effectiveMode: "sno-station-mem-row-keyword",
+						fallback: "semantic-unavailable"
+					});
+				} else try {
+					const vector = await this.options.store.embedder.embed(query);
+					this.cachedEmbeddingAvailability = {
+						ok: true,
+						checked: true,
+						cached: false,
+						checkedAtMs: Date.now()
+					};
+					this.embeddingRetryAfterMs = 0;
+					const semantic = await this.options.store.searchSemantic(vector, searchOptions);
+					semanticCount = semantic.length;
+					const filteredSemantic = this.filterAuthorized(semantic, minScore);
+					if (filteredSemantic.length > 0) rowResults = filteredSemantic.map((result) => mapSearchResult(result, "semantic"));
+				} catch (error) {
+					failure = error;
+					fallback = "semantic_failed";
+					const checkedAtMs = Date.now();
+					this.cachedEmbeddingAvailability = {
+						ok: false,
+						error: error instanceof Error ? error.message : String(error),
+						checked: true,
+						cached: false,
+						checkedAtMs
+					};
+					this.embeddingRetryAfterMs = checkedAtMs + EMBEDDING_FAILURE_RETRY_MS;
+					opts.onDebug?.({
+						backend: "qmd",
+						effectiveMode: "sno-station-mem-row-keyword",
+						fallback: "semantic-unavailable"
+					});
+				}
+				if (rowResults.length === 0) {
+					if (fallback === "none") fallback = "semantic_empty";
+					const keyword = await this.options.store.searchKeyword(query, searchOptions);
+					keywordCount = keyword.length;
+					rowResults = this.filterAuthorized(keyword, minScore).map((result) => mapSearchResult(result, "keyword"));
+				}
+				const canonicalResults = await this.searchCanonical(query, maxResults, minScore, canonicalDiagnostics);
+				served = [...rowResults, ...canonicalResults].sort((left, right) => right.score - left.score || left.path.localeCompare(right.path)).slice(0, maxResults);
+				outcome = fallback === "semantic_failed" || fallback === "cached_embedding_failure" || canonicalDiagnostics.io_failure_count > 0 ? "partial" : served.length ? "success" : "empty_success";
+				return served;
+			} catch (error) {
+				failure = error;
+				outcome = opts.signal?.aborted ? "cancelled" : "failed";
+				throw error;
+			} finally {
+				diagnosticLog$1[outcome === "failed" ? "error" : "info"]("Provider memory search completed", {
+					outcome,
+					fallback_reason: fallback,
+					error: failure,
+					duration_ms: performance.now() - started,
+					input_size: query.length,
+					scope_count: 1,
+					semantic_candidate_count: semanticCount ?? "unavailable",
+					keyword_candidate_count: keywordCount ?? "unavailable",
+					served_count: served.length,
+					canonical_io_failure_count: canonicalDiagnostics.io_failure_count,
+					canonical_unavailable_file_count: canonicalDiagnostics.unavailable_file_count,
+					canonical_available: this.options.workspaceDir !== void 0,
+					served_ids: served.flatMap((row) => {
+						const id = ROW_PATH_RE.exec(row.path)?.[1];
+						return id ? [id] : [];
+					}).slice(0, 128),
+					store_reference: privateLogReference(this.options.store.dbPath)
+				}, {
+					event_name: "memory.provider.search.completed",
+					file: "packages/memory/src/engine/provider/provider-search-manager.ts",
+					function: "SnoStationMemProviderSearchManager.search",
+					site_id: "memory.provider.search.completed"
+				});
+			}
+		});
+	}
+	async readFile(params) {
+		return withLogContext({ operation_id: currentLogContext().operation_id ?? randomUUID() }, async () => {
+			const started = performance.now();
+			let outcome = "failed";
+			let failure;
+			let reason = "read_failed";
+			const canonicalDiagnostic = {};
+			try {
+				this.assertOpen();
+				const memoryId = ROW_PATH_RE.exec(params.relPath)?.[1];
+				if (memoryId) {
+					const entry = this.options.store.getById(memoryId);
+					if (!this.isAuthorizedEntry(entry)) {
+						outcome = "refused";
+						reason = entry === void 0 ? "row_missing" : "row_not_authorized";
+						throw new Error("Provider memory row not found or not authorized");
+					}
+					const bounded = lineBound(renderProviderRowMemory(entry), params.from, params.lines);
+					outcome = "success";
+					reason = "row_read";
+					return {
+						...bounded,
+						path: providerRowPath(entry.id)
+					};
+				}
+				const canonical = await this.readAuthorizedCanonical(params, canonicalDiagnostic);
+				outcome = "success";
+				reason = "canonical_read";
+				return {
+					text: canonical.text,
+					path: canonical.path,
+					...canonical.truncated ? { truncated: canonical.truncated } : {},
+					...canonical.from ? { from: canonical.from } : {},
+					...canonical.lines ? { lines: canonical.lines } : {},
+					...canonical.nextFrom ? { nextFrom: canonical.nextFrom } : {}
+				};
+			} catch (error) {
+				failure = error;
+				if (canonicalDiagnostic.reason) {
+					reason = canonicalDiagnostic.reason;
+					outcome = reason === "canonical_not_authorized" ? "refused" : "failed";
+					failure = canonicalDiagnostic.error ?? error;
+				}
+				throw error;
+			} finally {
+				diagnosticLog$1[outcome === "failed" ? "error" : "info"]("Provider memory read completed", {
+					outcome,
+					reason_code: reason,
+					error: failure,
+					duration_ms: performance.now() - started,
+					artifact_reference: privateLogReference(params.relPath)
+				}, {
+					event_name: "memory.provider.read.completed",
+					file: "packages/memory/src/engine/provider/provider-search-manager.ts",
+					function: "SnoStationMemProviderSearchManager.readFile",
+					site_id: "memory.provider.read.completed"
+				});
+			}
+		});
+	}
+	status() {
+		const started = performance.now();
+		try {
+			this.assertOpen();
+			const vectorStoreAvailable = this.hasVectorStore();
+			const embeddingAvailable = this.cachedEmbeddingAvailability?.ok === true;
+			const semanticAvailable = vectorStoreAvailable && embeddingAvailable;
+			const memoryCount = readCount(this.options.store.sqlite.prepare("SELECT COUNT(*) AS count FROM nodix_memories WHERE project_id = ?").get(this.options.identity.projectId));
+			const chunkCount = readCount(this.options.store.sqlite.prepare("SELECT COUNT(*) AS count FROM nodix_memory_chunks c JOIN nodix_memories m ON m.id = c.memory_id WHERE m.project_id = ?").get(this.options.identity.projectId));
+			diagnosticLog$1.debug("Provider memory status read", {
+				outcome: "success",
+				memory_count: memoryCount,
+				chunk_count: chunkCount,
+				vector_available: vectorStoreAvailable,
+				embedding_available: embeddingAvailable,
+				duration_ms: performance.now() - started
+			}, {
+				event_name: "memory.provider.status.completed",
+				file: "packages/memory/src/engine/provider/provider-search-manager.ts",
+				function: "SnoStationMemProviderSearchManager.status",
+				site_id: "memory.provider.status.completed"
+			});
+			return {
+				backend: "qmd",
+				provider: FIXED_PROTOCOL_VALUE_74,
+				model: this.options.store.embedder.model,
+				files: memoryCount,
+				chunks: chunkCount,
+				dbPath: this.options.store.dbPath,
+				...this.options.workspaceDir ? { workspaceDir: this.options.workspaceDir } : {},
+				sources: ["memory"],
+				sourceCounts: [{
+					source: "memory",
+					files: memoryCount,
+					chunks: chunkCount
+				}],
+				fts: {
+					enabled: true,
+					available: this.options.store.hasFtsSupport
+				},
+				vector: {
+					enabled: true,
+					storeAvailable: vectorStoreAvailable,
+					semanticAvailable,
+					available: semanticAvailable,
+					dims: this.options.store.vectorDim,
+					...this.cachedEmbeddingAvailability?.ok === false ? { loadError: this.cachedEmbeddingAvailability.error ?? "embedding unavailable" } : {}
+				},
+				custom: {
+					userId: this.options.identity.userId,
+					projectId: this.options.identity.projectId,
+					agentId: this.options.identity.agentId
+				}
+			};
+		} catch (error) {
+			diagnosticLog$1.error("Provider memory status failed", {
+				outcome: "failed",
+				error,
+				duration_ms: performance.now() - started
+			}, {
+				event_name: "memory.provider.status.completed",
+				file: "packages/memory/src/engine/provider/provider-search-manager.ts",
+				function: "SnoStationMemProviderSearchManager.status",
+				site_id: "memory.provider.status.failed"
+			});
+			throw error;
+		}
+	}
+	async sync(params = {}) {
+		this.assertOpen();
+		if (!this.options.workspaceDir) {
+			params.progress?.({
+				completed: 1,
+				total: 1,
+				label: "sno-station-mem rows are live"
+			});
+			return;
+		}
+		const canonicalFiles = await listCanonicalMemoryFiles(this.options.workspaceDir);
+		for (const file of canonicalFiles) this.authorizedCanonicalPaths.add(file.path);
+		params.progress?.({
+			completed: canonicalFiles.length,
+			total: canonicalFiles.length,
+			label: "canonical memory files indexed"
+		});
+	}
+	getCachedEmbeddingAvailability() {
+		return this.cachedEmbeddingAvailability;
+	}
+	async probeEmbeddingAvailability() {
+		this.assertOpen();
+		const checkedAtMs = Date.now();
+		try {
+			await this.options.store.embedder.embed("provider availability probe");
+			this.cachedEmbeddingAvailability = {
+				ok: true,
+				checked: true,
+				cached: false,
+				checkedAtMs
+			};
+			this.embeddingRetryAfterMs = 0;
+		} catch (error) {
+			this.cachedEmbeddingAvailability = {
+				ok: false,
+				error: error instanceof Error ? error.message : String(error),
+				checked: true,
+				cached: false,
+				checkedAtMs
+			};
+			this.embeddingRetryAfterMs = checkedAtMs + EMBEDDING_FAILURE_RETRY_MS;
+		}
+		return this.cachedEmbeddingAvailability;
+	}
+	async probeVectorStoreAvailability() {
+		return this.probeVectorAvailability();
+	}
+	async probeVectorAvailability() {
+		this.assertOpen();
+		return this.hasVectorStore();
+	}
+	async close() {
+		const alreadyClosed = this.closed;
+		this.closed = true;
+		diagnosticLog$1.debug("Provider memory manager closed", {
+			outcome: "success",
+			already_closed: alreadyClosed
+		}, {
+			event_name: "memory.provider.manager.closed",
+			file: "packages/memory/src/engine/provider/provider-search-manager.ts",
+			function: "SnoStationMemProviderSearchManager.close",
+			site_id: "memory.provider.manager.closed"
+		});
+	}
+	hasVectorStore() {
+		return !!this.options.store.sqlite.prepare("SELECT 1 AS ok FROM sqlite_master WHERE name = 'nodix_memory_chunk_vectors' LIMIT 1").get();
+	}
+	assertOpen() {
+		if (this.closed) throw new Error("Provider memory manager is closed");
+	}
+	filterAuthorized(results, minScore) {
+		return results.filter((result) => this.isAuthorizedEntry(result.entry) && isProviderRowId(result.entry.id) && scoreAtLeast(result.score, minScore));
+	}
+	isAuthorizedEntry(entry) {
+		if (entry?.projectId !== this.options.identity.projectId) return false;
+		try {
+			return parseInsightMetadata(entry.metadata, entry).invalidated_at === void 0;
+		} catch {
+			return false;
+		}
+	}
+	async searchCanonical(query, maxResults, minScore, diagnostics) {
+		if (!this.options.workspaceDir) return [];
+		const filtered = (await searchCanonicalMemoryFiles({
+			diagnostics,
+			workspaceDir: this.options.workspaceDir,
+			query,
+			maxResults
+		})).filter((result) => scoreAtLeast(result.score, minScore));
+		for (const result of filtered) this.authorizedCanonicalPaths.add(result.path);
+		return filtered;
+	}
+	async readAuthorizedCanonical(params, diagnostics) {
+		if (!this.options.workspaceDir || !this.authorizedCanonicalPaths.has(params.relPath)) {
+			if (diagnostics) diagnostics.reason = "canonical_not_authorized";
+			throw new Error("Provider canonical memory file not found or not authorized");
+		}
+		try {
+			return await readCanonicalMemoryFile({
+				workspaceDir: this.options.workspaceDir,
+				relPath: params.relPath,
+				from: params.from,
+				lines: params.lines
+			});
+		} catch (error) {
+			if (diagnostics) {
+				diagnostics.reason = "canonical_read_unavailable";
+				diagnostics.error = error;
+			}
+			throw new Error("Provider canonical memory file not found or not authorized");
+		}
+	}
+};
+//#endregion
+//#region src/engine/provider/provider-registration.ts
+const diagnosticLog = createLogger("sno-station-mem:provider-registration");
+let machineUserId;
+/** The configured provider.userId, else this machine's identity (the same id every skin sees). */
+function readTrustedUserId(config) {
+	const configured = config.provider.userId;
+	let trimmed;
+	if (typeof configured === "string" && configured.trim().length > 0) trimmed = configured.trim();
+	else {
+		machineUserId ??= bootstrapIdentity().machine_uuid;
+		trimmed = machineUserId;
+	}
+	if (!isLowercaseCanonicalUUIDv7(trimmed)) throw new Error("sno-station-mem provider userId must be a lowercase UUID-v7");
+	return trimmed;
+}
+function readConfiguredAgents(cfg) {
+	const entries = cfg.agents?.entries;
+	if (entries && Object.keys(entries).length > 0) return Object.entries(entries).filter(([id]) => id.length > 0).map(([id, entry]) => ({
+		...entry,
+		id
+	}));
+	return cfg.agents?.list ?? [];
+}
+function readAgentWorkspace(cfg, agentId) {
+	const agent = readConfiguredAgents(cfg).find((entry) => entry.id === agentId);
+	if (!agent) throw new Error("sno-station-mem provider requires a configured sno-station-mem agent");
+	const workspace = agent?.workspace ?? cfg.agents?.defaults?.workspace;
+	if (typeof workspace !== "string" || workspace.trim().length === 0) throw new Error("sno-station-mem provider requires an explicit sno-station-mem agent workspace");
+	return resolve(workspace);
+}
+async function resolveProviderIdentity(params) {
+	const userId = readTrustedUserId(params.config);
+	const workspaceDir = readAgentWorkspace(params.cfg, params.agentId);
+	return {
+		identity: await resolveProviderAuthority(params.store, {
+			trustedUserId: userId,
+			externalSystem: PERSISTED_PROVIDER_SYSTEM,
+			projectKey: workspaceDir,
+			agentKey: params.agentId
+		}),
+		workspaceDir
+	};
+}
+async function readProviderIdentity(params) {
+	const userId = readTrustedUserId(params.config);
+	const workspaceDir = readAgentWorkspace(params.cfg, params.agentId);
+	return {
+		identity: await readProviderAuthority(params.store, {
+			trustedUserId: userId,
+			externalSystem: PERSISTED_PROVIDER_SYSTEM,
+			projectKey: workspaceDir,
+			agentKey: params.agentId
+		}),
+		workspaceDir
+	};
+}
+function createMemoryRuntime(params) {
+	const managers = /* @__PURE__ */ new Map();
+	const failedClosingManagers = /* @__PURE__ */ new Map();
+	function managerKey(identity, workspaceDir) {
+		return `${identity.userId}:${identity.projectId}:${identity.agentId}:${workspaceDir}`;
+	}
+	function rememberFailedClose(key, manager) {
+		const existing = failedClosingManagers.get(key);
+		if (existing) {
+			existing.add(manager);
+			return;
+		}
+		failedClosingManagers.set(key, /* @__PURE__ */ new Set([manager]));
+	}
+	async function closeFailedManagers(key) {
+		const failed = failedClosingManagers.get(key);
+		if (!failed) return;
+		for (const manager of Array.from(failed)) {
+			await manager.close();
+			failed.delete(manager);
+		}
+		if (failed.size === 0) failedClosingManagers.delete(key);
+	}
+	return {
+		async getMemorySearchManager({ cfg, agentId }) {
+			const started = performance.now();
+			let outcome = "success";
+			let failure;
+			try {
+				const resolved = await resolveProviderIdentity({
+					cfg,
+					config: params.config,
+					store: params.store,
+					agentId
+				});
+				const key = managerKey(resolved.identity, resolved.workspaceDir);
+				const existing = managers.get(key);
+				if (existing) return { manager: existing };
+				const manager = new SnoStationMemProviderSearchManager({
+					store: params.store,
+					identity: resolved.identity,
+					workspaceDir: resolved.workspaceDir
+				});
+				const winner = managers.get(key);
+				if (winner) {
+					await manager.close();
+					return { manager: winner };
+				}
+				managers.set(key, manager);
+				return { manager };
+			} catch (error) {
+				outcome = "failed";
+				failure = error;
+				return {
+					manager: null,
+					error: error instanceof Error ? error.message : String(error)
+				};
+			} finally {
+				diagnosticLog[outcome === "failed" ? "error" : "debug"]("Provider memory manager resolved", {
+					outcome,
+					error: failure,
+					duration_ms: performance.now() - started
+				}, {
+					event_name: "memory.provider.manager.resolved",
+					file: "packages/memory/src/engine/provider/provider-registration.ts",
+					function: "createMemoryRuntime.getMemorySearchManager",
+					site_id: "memory.provider.manager.resolved"
+				});
+			}
+		},
+		resolveMemoryBackendConfig() {
+			return { backend: "qmd" };
+		},
+		async closeMemorySearchManager({ cfg, agentId }) {
+			let resolved;
+			try {
+				resolved = await resolveProviderIdentity({
+					cfg,
+					config: params.config,
+					store: params.store,
+					agentId
+				});
+			} catch (error) {
+				diagnosticLog.warn("Provider manager close lacks identity", {
+					outcome: "skipped",
+					error
+				}, {
+					event_name: "memory.provider.manager.close.skipped",
+					file: "packages/memory/src/engine/provider/provider-registration.ts",
+					function: "createMemoryRuntime.closeMemorySearchManager",
+					site_id: "memory.provider.manager.close.skipped"
+				});
+				return;
+			}
+			const key = managerKey(resolved.identity, resolved.workspaceDir);
+			await closeFailedManagers(key);
+			const manager = managers.get(key);
+			if (!manager) return;
+			managers.delete(key);
+			try {
+				await manager.close();
+			} catch (error) {
+				if (managers.has(key)) rememberFailedClose(key, manager);
+				else managers.set(key, manager);
+				diagnosticLog.warn("Provider manager close retained for retry", {
+					outcome: "failed",
+					error
+				}, {
+					event_name: "memory.provider.manager.close.failed",
+					file: "packages/memory/src/engine/provider/provider-registration.ts",
+					function: "createMemoryRuntime.closeMemorySearchManager",
+					site_id: "memory.provider.manager.close.failed"
+				});
+				throw error;
+			}
+		},
+		async closeAllMemorySearchManagers() {
+			const started = performance.now();
+			let closedCount = 0;
+			let failure;
+			let failed = false;
+			try {
+				for (const failed of failedClosingManagers.values()) for (const manager of failed) {
+					await manager.close();
+					closedCount += 1;
+				}
+				failedClosingManagers.clear();
+				for (const manager of managers.values()) {
+					await manager.close();
+					closedCount += 1;
+				}
+				managers.clear();
+			} catch (error) {
+				failure = error;
+				failed = true;
+				throw error;
+			} finally {
+				diagnosticLog[failed ? "warn" : "debug"]("Provider managers shutdown completed", {
+					outcome: failed ? "partial" : "success",
+					closed_count: closedCount,
+					error: failure,
+					duration_ms: performance.now() - started
+				}, {
+					event_name: "memory.provider.managers.shutdown.completed",
+					file: "packages/memory/src/engine/provider/provider-registration.ts",
+					function: "createMemoryRuntime.closeAllMemorySearchManagers",
+					site_id: "memory.provider.managers.shutdown.completed"
+				});
+			}
+		}
+	};
+}
+//#endregion
+export { readTrustedUserId as a, readProviderIdentity as i, readAgentWorkspace as n, resolveProviderIdentity as o, readConfiguredAgents as r, SnoStationMemProviderSearchManager as s, createMemoryRuntime as t };