@snoai/memory 0.0.0-stage → 1.0.1

package/dist/internal/config/product-mode.js

@@ -0,0 +1,36 @@
+import { SUPPORTED_LOCALES } from "../engine/i18n/locales.js";
+import { z } from "zod";
+//#region config/plugin-config-mode-schema.ts
+/**
+* Product LLM modes, tier-ordered: Local First (selected calls on host) → Agent
+* Native (every call borrows the host agent's model) → REM Enhanced (top
+* tier: SNO-REM-MEM serves the LoRA-covered calls, the host model covers
+* the rest).
+*/
+const PRODUCT_MODES = [
+	"local-first",
+	"agent-native",
+	"rem-enhanced"
+];
+const DEFAULT_MODEL_MODE = "agent-native";
+/** Occasions select system messages; call ids select destinations. */
+const LLM_OCCASIONS = [
+	"memoryExtract",
+	"profileSectionMerge",
+	"profileActiveTaskClassify",
+	"conflictAdjudication",
+	"summaryBuild",
+	"dateResolution"
+];
+const remEnhancedConfigSchema = z.object({ trigger: z.object({ tick: z.boolean().default(true) }).strict().prefault({}) }).strict().prefault({});
+const llmRoutingConfigSchema = z.object({
+	mode: z.enum(PRODUCT_MODES),
+	language: z.enum(SUPPORTED_LOCALES).default("en"),
+	modelCalls: z.record(z.string(), z.record(z.enum(PRODUCT_MODES), z.enum([
+		"off",
+		"host",
+		"sno-gpu"
+	]))).optional()
+}).strict();
+//#endregion
+export { DEFAULT_MODEL_MODE, LLM_OCCASIONS, PRODUCT_MODES, llmRoutingConfigSchema, remEnhancedConfigSchema };

package/dist/internal/config/settings.d.ts

@@ -0,0 +1,2 @@
+import { S as settingsToPluginConfig, b as defaultSettings, x as settingsSchema, y as Settings } from "../../plugin-config-schema-C0UUbOmG.js";
+export { Settings, defaultSettings, settingsSchema, settingsToPluginConfig };

package/dist/internal/config/settings.js

@@ -0,0 +1,265 @@
+import { l as SESSION_STRATEGIES, t as pluginConfigSchema } from "../../plugin-config-schema-YJLyIIcJ.js";
+import { EMBEDDER_MODEL_DEFAULT } from "./index.js";
+import { SUPPORTED_LOCALES } from "../engine/i18n/locales.js";
+import { PRODUCT_MODES } from "./product-mode.js";
+import { t as MODEL_CALLS } from "../../model-call-table-CspopkBg.js";
+import { z } from "zod";
+import { LOCAL_EMBEDDING_MODEL_REVISION } from "@snoai/embedder";
+import { isLowercaseCanonicalUUIDv7 } from "@snoai/common-core";
+//#region config/settings.ts
+const destination = z.enum([
+	"off",
+	"host",
+	"sno-gpu"
+]);
+const destinations = z.strictObject({
+	"local-first": destination,
+	"agent-native": destination,
+	"rem-enhanced": destination
+});
+const modelCalls = z.strictObject(Object.fromEntries(Object.keys(MODEL_CALLS).map((id) => [id, destinations])));
+const settingsSchema = z.strictObject({
+	mode: z.enum(PRODUCT_MODES),
+	modelCalls,
+	user: z.strictObject({
+		id: z.string().refine((id) => id === "" || isLowercaseCanonicalUUIDv7(id)),
+		language: z.enum(SUPPORTED_LOCALES)
+	}),
+	snoGpu: z.strictObject({
+		baseUrl: z.string(),
+		apiKey: z.string()
+	}),
+	rerank: z.strictObject({
+		mode: z.enum([
+			"lightweight",
+			"cross-encoder",
+			"none"
+		]),
+		provider: z.enum([
+			"jina",
+			"siliconflow",
+			"pinecone",
+			"voyage",
+			"dashscope",
+			"tei",
+			"custom"
+		]),
+		endpoint: z.string(),
+		model: z.string(),
+		apiKey: z.string(),
+		timeoutMs: z.number().int().min(1e3).max(12e4),
+		maxCandidates: z.number().int().min(1).max(2e3)
+	}),
+	store: z.strictObject({
+		path: z.string(),
+		encryptionKey: z.string().min(1).regex(/^[0-9a-f]{64}$/u)
+	}),
+	embedding: z.strictObject({
+		model: z.string(),
+		revision: z.string(),
+		dtype: z.enum([
+			"q4",
+			"q8",
+			"fp16",
+			"fp32"
+		]),
+		threads: z.number().int().nonnegative(),
+		cacheDir: z.string(),
+		offline: z.boolean(),
+		mirror: z.string()
+	}),
+	recall: z.strictObject({
+		auto: z.boolean(),
+		sessionStart: z.strictObject({
+			limit: z.number().int().nonnegative(),
+			maxChars: z.number().int().nonnegative(),
+			timeoutMs: z.number().int().nonnegative()
+		}),
+		prompt: z.strictObject({
+			limit: z.number().int().min(0).max(2e3),
+			maxChars: z.number().int().nonnegative(),
+			timeoutMs: z.number().int().min(500).max(6e4),
+			minChars: z.number().int().min(0).max(200),
+			minScore: z.number().min(0).max(1)
+		}),
+		explicitLimit: z.number().int().nonnegative()
+	}),
+	capture: z.strictObject({
+		assistant: z.boolean(),
+		ambient: z.boolean(),
+		sessionMemory: z.strictObject({
+			enabled: z.boolean(),
+			messageCount: z.number().int().min(1).max(100)
+		}),
+		sessionStrategy: z.enum(SESSION_STRATEGIES)
+	}),
+	rem: z.strictObject({
+		tick: z.boolean(),
+		operations: z.array(z.enum(["rem-replace", "rem-update"])).min(1).max(2)
+	}),
+	telemetry: z.strictObject({
+		memoryUsage: z.strictObject({
+			enabled: z.boolean(),
+			key: z.string(),
+			historicKeys: z.array(z.string())
+		}),
+		observe: z.strictObject({
+			enabled: z.boolean(),
+			baseUrl: z.string()
+		}),
+		redactionRules: z.array(z.string())
+	}),
+	logging: z.strictObject({
+		level: z.enum([
+			"debug",
+			"info",
+			"warn",
+			"error"
+		]),
+		file: z.string(),
+		debugContent: z.boolean()
+	}),
+	memoryPackage: z.strictObject({
+		path: z.string(),
+		node: z.string()
+	})
+});
+function defaultSettings() {
+	const engine = pluginConfigSchema.parse({});
+	return {
+		mode: engine.mode,
+		modelCalls: Object.fromEntries(Object.entries(MODEL_CALLS).map(([id, call]) => [id, call.destinations])),
+		user: {
+			id: "",
+			language: "en"
+		},
+		snoGpu: {
+			baseUrl: "https://rt3-llm.sno.ai",
+			apiKey: ""
+		},
+		rerank: {
+			mode: "lightweight",
+			provider: "voyage",
+			endpoint: "",
+			model: engine.retrieval.rerankModel,
+			apiKey: "",
+			timeoutMs: engine.retrieval.rerankTimeoutMs,
+			maxCandidates: 64
+		},
+		store: {
+			path: "",
+			encryptionKey: ""
+		},
+		embedding: {
+			model: EMBEDDER_MODEL_DEFAULT,
+			revision: LOCAL_EMBEDDING_MODEL_REVISION,
+			dtype: engine.embedding.dtype,
+			threads: 0,
+			cacheDir: "",
+			offline: false,
+			mirror: ""
+		},
+		recall: {
+			auto: true,
+			sessionStart: {
+				limit: 5,
+				maxChars: 3500,
+				timeoutMs: 8e3
+			},
+			prompt: {
+				limit: 3,
+				maxChars: 1500,
+				timeoutMs: 4e3,
+				minChars: 12,
+				minScore: 0
+			},
+			explicitLimit: 5
+		},
+		capture: {
+			assistant: true,
+			ambient: true,
+			sessionMemory: {
+				enabled: true,
+				messageCount: 15
+			},
+			sessionStrategy: "systemSessionMemory"
+		},
+		rem: {
+			tick: engine.remEnhanced?.trigger.tick ?? true,
+			operations: engine.remOperations
+		},
+		telemetry: {
+			memoryUsage: {
+				enabled: false,
+				key: "",
+				historicKeys: []
+			},
+			observe: {
+				enabled: true,
+				baseUrl: "https://www.sno.ai"
+			},
+			redactionRules: []
+		},
+		logging: {
+			level: "info",
+			file: "",
+			debugContent: false
+		},
+		memoryPackage: {
+			path: "",
+			node: ""
+		}
+	};
+}
+function settingsToPluginConfig(settings) {
+	return pluginConfigSchema.parse({
+		mode: settings.mode,
+		modelCalls: settings.modelCalls,
+		provider: { userId: settings.user.id || void 0 },
+		language: settings.user.language,
+		dbPath: settings.store.path,
+		embedding: {
+			model: settings.embedding.model,
+			revision: settings.embedding.revision || void 0,
+			dtype: settings.embedding.dtype,
+			cacheDir: settings.embedding.cacheDir || void 0,
+			offline: settings.embedding.offline,
+			mirror: settings.embedding.mirror,
+			sessionOptions: { intraOpNumThreads: settings.embedding.threads || void 0 }
+		},
+		retrieval: {
+			rerank: settings.rerank.mode,
+			rerankProvider: settings.rerank.provider,
+			recallTopK: settings.recall.prompt.limit,
+			minScore: settings.recall.prompt.minScore,
+			rerankEndpoint: settings.rerank.endpoint || void 0,
+			rerankModel: settings.rerank.model,
+			rerankApiKey: settings.rerank.apiKey,
+			rerankTimeoutMs: settings.rerank.timeoutMs,
+			rerankMaxCandidates: settings.rerank.maxCandidates
+		},
+		autoRecall: settings.recall.auto,
+		autoRecallTimeoutMs: settings.recall.prompt.timeoutMs,
+		autoRecallMinLength: settings.recall.prompt.minChars,
+		captureAssistant: settings.capture.assistant,
+		ambientLearning: settings.capture.ambient,
+		debugContent: settings.logging.debugContent,
+		sessionMemory: settings.capture.sessionMemory,
+		sessionStrategy: settings.capture.sessionStrategy,
+		remEnhanced: { trigger: { tick: settings.rem.tick } },
+		remOperations: settings.rem.operations,
+		memoryTelemetry: {
+			enabled: settings.telemetry.memoryUsage.enabled,
+			currentKeyVersion: settings.telemetry.memoryUsage.historicKeys.length + 1,
+			key: settings.telemetry.memoryUsage.key,
+			historicKeys: settings.telemetry.memoryUsage.historicKeys
+		},
+		observe: settings.telemetry.observe,
+		extraction: { llm: {
+			baseURL: settings.snoGpu.baseUrl,
+			apiKey: settings.snoGpu.apiKey
+		} }
+	});
+}
+//#endregion
+export { defaultSettings, settingsSchema, settingsToPluginConfig };

package/dist/internal/config/skill-categories.d.ts

@@ -0,0 +1,4 @@
+//#region config/skill-categories.d.ts
+export declare const SKILL_CATEGORIES: Record<string, "J" | "M" | "S" | "H" | "T" | "R" | "other">;
+export declare function skillVersionFor(skillDir: string): string;
+//#endregion

package/dist/internal/config/skill-categories.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { join } from "node:path";
+import { readFileSync } from "node:fs";
+//#region config/skill-categories.ts
+const SKILL_CATEGORIES = {
+	"peer-review": "J",
+	"agentic-walkthrough": "J",
+	"owner-intent-audit": "J",
+	"pr-review": "J",
+	"first-principles-review": "J",
+	"e2e": "J",
+	"e2e-environment-preflight": "J",
+	"e2e-red-triage": "J",
+	"heartbeat": "S",
+	"subscription-quota-check": "S",
+	"reach": "S",
+	"handoff": "S",
+	"join-talk": "S",
+	"rotate-agent": "S",
+	"prd-board": "H",
+	"insights-codex": "H",
+	"analysis": "R",
+	"tpm": "T",
+	"tpm-audit": "T",
+	"tpm-dispatch": "T",
+	"tpm-env": "T",
+	"tpm-watch": "T",
+	"tpm-task-evidence": "J",
+	"tpm-analyze": "R",
+	"cts": "T",
+	"cts-review": "T",
+	"cts-watch": "T",
+	"cts-evolve": "R",
+	"agentic-time-estimate": "H",
+	"codex-coder": "M",
+	"python-coder": "M",
+	"ts-coder": "M",
+	"shellscript-coder": "M",
+	"test-writer": "J",
+	"prd-creator": "T",
+	"prd-creator-mid": "T",
+	"prd-creator-small": "T",
+	"prd-discover": "M",
+	"adlc": "T",
+	"adlc-build": "T",
+	"adlc-mid": "T",
+	"adlc-quick": "T",
+	"adlc-route": "T",
+	"adlc-small": "T",
+	"prd-graph": "H",
+	"prdm": "H",
+	"rem-reflect": "R",
+	"bro": "T",
+	"managed-worktree": "T",
+	"lh-english-writer": "T"
+};
+const publishedSchema = z.object({ source: z.object({ commit: z.string().min(1) }) });
+function skillVersionFor(skillDir) {
+	try {
+		const text = readFileSync(join(skillDir, "PUBLISHED.json"), "utf8");
+		return publishedSchema.parse(JSON.parse(text)).source.commit.slice(0, 12);
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return "local";
+		throw error;
+	}
+}
+//#endregion
+export { SKILL_CATEGORIES, skillVersionFor };

package/dist/internal/config/skin-defaults.d.ts

@@ -0,0 +1,6 @@
+import { g as ProductMode, h as PRODUCT_MODES, u as DEFAULT_MODEL_MODE } from "../../plugin-config-schema-C0UUbOmG.js";
+//#region config/skin-defaults.d.ts
+export declare const HOST_MODEL_CALLBACK_HOST = "127.0.0.1";
+export declare const HOST_MODEL_CALLBACK_PATH = "/v1/chat/completions";
+//#endregion
+export { DEFAULT_MODEL_MODE, PRODUCT_MODES, type ProductMode };

package/dist/internal/config/skin-defaults.js

@@ -0,0 +1,6 @@
+import { DEFAULT_MODEL_MODE, PRODUCT_MODES } from "./product-mode.js";
+//#region config/skin-defaults.ts
+const HOST_MODEL_CALLBACK_HOST = "127.0.0.1";
+const HOST_MODEL_CALLBACK_PATH = "/v1/chat/completions";
+//#endregion
+export { DEFAULT_MODEL_MODE, HOST_MODEL_CALLBACK_HOST, HOST_MODEL_CALLBACK_PATH, PRODUCT_MODES };

package/dist/internal/contract/discovery.d.ts

@@ -0,0 +1,10 @@
+//#region src/contract/discovery.d.ts
+export interface Discovery {
+  pid: number;
+  port: number;
+  token: string;
+}
+export declare function readDiscovery(): Promise<Discovery | undefined>;
+export declare function processAlive(pid: number): boolean;
+export declare function checkDiscovery(discovery: Discovery): Promise<void>;
+//#endregion

package/dist/internal/contract/discovery.js

@@ -0,0 +1,53 @@
+import { t as ContractError } from "../../error-D-wb-rZw.js";
+import { MEMORY_HEALTH_TIMEOUT_MS } from "./routes.js";
+import { getDiscoveryPath } from "./profile.js";
+import { z } from "zod";
+import { readFile } from "node:fs/promises";
+//#region src/contract/discovery.ts
+const discoverySchema = z.strictObject({
+	pid: z.number().int().positive(),
+	port: z.number().int().min(1).max(65535),
+	token: z.string().regex(/^[a-f0-9]{64}$/)
+});
+async function readDiscovery() {
+	let text;
+	try {
+		text = await readFile(getDiscoveryPath(), "utf8");
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return void 0;
+		throw new ContractError("sidecar-unreachable");
+	}
+	try {
+		return discoverySchema.parse(JSON.parse(text));
+	} catch {
+		throw new ContractError("sidecar-unreachable");
+	}
+}
+function processAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error instanceof Error && "code" in error && error.code === "EPERM";
+	}
+}
+async function checkDiscovery(discovery) {
+	try {
+		const response = await fetch(`http://127.0.0.1:${discovery.port}/healthz`, {
+			headers: { Authorization: `Bearer ${discovery.token}` },
+			signal: AbortSignal.timeout(MEMORY_HEALTH_TIMEOUT_MS)
+		});
+		if (!response.ok) {
+			const body = await response.json();
+			if (body && typeof body === "object" && "error" in body && typeof body.error === "string") throw new ContractError("sidecar-unresponsive", body.error);
+			throw new ContractError("sidecar-unresponsive");
+		}
+		const health = await response.json();
+		if (!health || typeof health !== "object" || !("status" in health) || health.status !== "ok" && health.status !== "degraded") throw new ContractError("sidecar-unresponsive");
+	} catch (error) {
+		if (error instanceof ContractError) throw error;
+		throw new ContractError("sidecar-unresponsive");
+	}
+}
+//#endregion
+export { checkDiscovery, processAlive, readDiscovery };

package/dist/internal/contract/profile.d.ts

@@ -0,0 +1,2 @@
+import { a as getSidecarSocketPath, c as getStateDir, i as getSettingsPath, l as readSettings, n as getDiscoveryPath, o as getSnoStationMemStateDir, r as getPrincipal, s as getStartupLogPath, t as SettingsUnavailableError } from "../../profile-TWPJ_myr.js";
+export { SettingsUnavailableError, getDiscoveryPath, getPrincipal, getSettingsPath, getSidecarSocketPath, getSnoStationMemStateDir, getStartupLogPath, getStateDir, readSettings };

package/dist/internal/contract/profile.js

@@ -0,0 +1,44 @@
+import { settingsSchema } from "../config/settings.js";
+import path from "node:path";
+import { readFileSync } from "node:fs";
+import { homedir, userInfo } from "node:os";
+//#region src/contract/profile.ts
+function getStateDir(defaultStateDir) {
+	return path.resolve(process.env.SNO_PROFILE_DIR ?? defaultStateDir ?? path.join(homedir(), ".sno"));
+}
+function getSettingsPath() {
+	return path.join(getStateDir(), "settings.json");
+}
+var SettingsUnavailableError = class extends Error {};
+function readSettings() {
+	const settingsPath = getSettingsPath();
+	let raw;
+	try {
+		raw = JSON.parse(readFileSync(settingsPath, "utf8"));
+	} catch (error) {
+		throw new SettingsUnavailableError(`settings unavailable: ${settingsPath}: ${error instanceof Error && "code" in error && error.code === "ENOENT" ? "file" : error instanceof SyntaxError ? `JSON: ${error.message}` : "file"}; see https://github.com/sno-ai/sno-station/blob/main/docs/memory-setup.md`);
+	}
+	const parsed = settingsSchema.safeParse(raw);
+	if (!parsed.success) {
+		const issue = parsed.error.issues[0];
+		throw new SettingsUnavailableError(`settings unavailable: ${settingsPath}: ${issue?.code === "unrecognized_keys" ? [...issue.path, issue.keys[0]].join(".") : issue?.path.join(".") || "settings"}; see https://github.com/sno-ai/sno-station/blob/main/docs/memory-setup.md`);
+	}
+	return parsed.data;
+}
+function getSnoStationMemStateDir() {
+	return path.join(getStateDir(), "sno-station-mem");
+}
+function getPrincipal() {
+	return userInfo().username;
+}
+function getDiscoveryPath() {
+	return path.join(getStateDir(), "station", "sidecar.json");
+}
+function getSidecarSocketPath() {
+	return path.join(getStateDir(), "station", "sidecar.sock");
+}
+function getStartupLogPath() {
+	return path.join(getSnoStationMemStateDir(), "sidecar-startup.log");
+}
+//#endregion
+export { SettingsUnavailableError, getDiscoveryPath, getPrincipal, getSettingsPath, getSidecarSocketPath, getSnoStationMemStateDir, getStartupLogPath, getStateDir, readSettings };

package/dist/internal/contract/routes.d.ts

@@ -0,0 +1,2 @@
+import { c as MEMORY_ERROR_STATUS, d as MEMORY_ROUTES, f as MEMORY_SKIN_HEADER, h as memoryMethod, l as MEMORY_HEALTH_TIMEOUT_MS, m as REM_SIDECAR_TOKEN_HEADER, o as MEMORY_BODY_LIMIT_BYTES, p as MEMORY_START_TIMEOUT_MS, s as MEMORY_DEFAULT_SKIN_ID, u as MEMORY_RECONNECT_INTERVAL_MS } from "../../index-0aqS8pVF.js";
+export { MEMORY_BODY_LIMIT_BYTES, MEMORY_DEFAULT_SKIN_ID, MEMORY_ERROR_STATUS, MEMORY_HEALTH_TIMEOUT_MS, MEMORY_RECONNECT_INTERVAL_MS, MEMORY_ROUTES, MEMORY_SKIN_HEADER, MEMORY_START_TIMEOUT_MS, REM_SIDECAR_TOKEN_HEADER, memoryMethod };

package/dist/internal/contract/routes.js

@@ -0,0 +1,62 @@
+//#region src/contract/routes.ts
+const MEMORY_ROUTES = {
+	init: {
+		path: "/v1/init",
+		timeoutMs: 3e4
+	},
+	hostEvent: {
+		path: "/v1/host-event",
+		timeoutMs: 3e4
+	},
+	getRecall: {
+		path: "/v1/get-recall",
+		timeoutMs: 12e4
+	},
+	capture: {
+		path: "/v1/capture",
+		timeoutMs: 9e5
+	},
+	mutate: {
+		path: "/v1/mutate",
+		timeoutMs: 9e5
+	},
+	inspect: {
+		path: "/v1/inspect",
+		timeoutMs: 3e4
+	},
+	recordUsage: {
+		path: "/v1/record-usage",
+		timeoutMs: 3e4
+	},
+	onSessionEnd: {
+		path: "/v1/on-session-end",
+		timeoutMs: 9e5
+	},
+	staticBlock: {
+		path: "/v1/static-block",
+		timeoutMs: 3e4
+	}
+};
+const MEMORY_BODY_LIMIT_BYTES = 8388608;
+const MEMORY_SKIN_HEADER = "x-sno-station-mem-skin";
+const REM_SIDECAR_TOKEN_HEADER = "x-sidecar-token";
+const MEMORY_HEALTH_TIMEOUT_MS = 5e3;
+const MEMORY_START_TIMEOUT_MS = 3e4;
+function memoryMethod(pathname) {
+	return Object.keys(MEMORY_ROUTES).find((method) => MEMORY_ROUTES[method].path === pathname);
+}
+const MEMORY_ERROR_STATUS = {
+	"sidecar-unreachable": 503,
+	"sidecar-unresponsive": 503,
+	"principal-mismatch": 403,
+	"store-mismatch": 409,
+	"no-agent-endpoint": 503,
+	"invalid-input": 400,
+	timeout: 504,
+	"storage-unavailable": 503,
+	"engine-failed": 500
+};
+const MEMORY_RECONNECT_INTERVAL_MS = 1e3;
+const MEMORY_DEFAULT_SKIN_ID = "default";
+//#endregion
+export { MEMORY_BODY_LIMIT_BYTES, MEMORY_DEFAULT_SKIN_ID, MEMORY_ERROR_STATUS, MEMORY_HEALTH_TIMEOUT_MS, MEMORY_RECONNECT_INTERVAL_MS, MEMORY_ROUTES, MEMORY_SKIN_HEADER, MEMORY_START_TIMEOUT_MS, REM_SIDECAR_TOKEN_HEADER, memoryMethod };

package/dist/internal/engine/bindings/memory-cli-shared.d.ts

@@ -0,0 +1,47 @@
+import { h as MemoryCategory } from "../../../types-CWdhXLxr.js";
+import { t as Embedder } from "../../../embedding-provider-client-vynZMuit.js";
+import { t as MemoryRetriever } from "../../../retriever-Dxss5fRv.js";
+import { C as MemoryStore } from "../../../memory-store-base-CQ_bHlYA.js";
+import "../../../store-C8sUTssE.js";
+import { r as MemoryTelemetryUsageOutbox } from "../../../memory-telemetry-outbox-ddTdImt7.js";
+import { Writable } from "node:stream";
+//#region src/engine/bindings/memory-cli-shared.d.ts
+export interface CliContext {
+  store: MemoryStore;
+  retriever: MemoryRetriever;
+  embedder: Embedder;
+  stateDir: string;
+  usageOutbox?: MemoryTelemetryUsageOutbox;
+}
+export type ImportSpoolRow = {
+  id: string;
+  text: string;
+  category: MemoryCategory;
+  scope: string;
+  importance: number;
+  timestamp: string | undefined;
+  metadata: Record<string, unknown>;
+  vector: number[] | undefined;
+  hash: string;
+};
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function writeImportSpoolRow(writer: Writable, row: ImportSpoolRow): Promise<void>;
+export declare function createImportSpoolPath(filePath: string): string;
+export declare function parseImportSpoolRow(line: string): ImportSpoolRow;
+/** Parses category into the normalized shape used by slash-command registration. */
+export declare function parseCategory(value: string | undefined): MemoryCategory | undefined;
+/** Implements serialize entry as the local slash-command registration operation. */
+export declare function serializeEntry(entry: {
+  id: string;
+  text: string;
+  category: string;
+  projectId: string;
+  importance: number;
+  timestamp: number;
+  metadata: string;
+}): Record<string, unknown>;
+/** Parses metadata defensively and returns a safe fallback on bad input. */
+export declare function safeParseMetadata(raw: string): unknown;
+/** Implements confirm destructive action as the local slash-command registration operation. */
+export declare function confirmDestructiveAction(message: string): Promise<boolean>;
+//#endregion