@snoai/memory 0.0.0-stage → 1.0.1

package/dist/plugin-config-schema-YJLyIIcJ.js

@@ -0,0 +1,361 @@
+import { DEFAULT_AUTO_RECALL_MAX_QUERY_LENGTH, DEFAULT_BM25_WEIGHT, DEFAULT_REFLECTION_MAX_INPUT_CHARS, DEFAULT_REFLECTION_TIMEOUT_MS, DEFAULT_RERANK_MODEL, DEFAULT_RERANK_TIMEOUT_MS, DEFAULT_SCOPE, DEFAULT_VECTOR_WEIGHT, RECENCY_WEIGHT, RECENCY_WEIGHT_MAX, SNO_OBSERVE_DEFAULT_AGENT_ID, SNO_OBSERVE_DEFAULT_BASE_URL, VECTOR_DIMENSION_DEFAULT, recallLifecycleSchema } from "./internal/config/index.js";
+import { SUPPORTED_LOCALES } from "./internal/engine/i18n/locales.js";
+import { $ as FIXED_MEMORY_SNO_EXTRACT_PROFILE, Q as FIXED_MEMORY_SNO_EXTRACT_CHAT, X as FIXED_MEMORY_SNO_AI_EXTRACT, Z as FIXED_MEMORY_SNO_CONFLICT_VERDICT, dt as FIXED_PROTOCOL_VALUE_72, lt as FIXED_PROTOCOL_VALUE_70, ut as FIXED_PROTOCOL_VALUE_71, wt as PERSISTED_PROVIDER_SYSTEM } from "./signed-registry-constants-yq3DlG3B.js";
+import { DEFAULT_MODEL_MODE, PRODUCT_MODES, remEnhancedConfigSchema } from "./internal/config/product-mode.js";
+import { z } from "zod";
+import { createLogger } from "@snoai/utils/logger";
+//#region config/session-strategy.ts
+/** @file session-strategy.ts
+* @purpose Defines session-memory strategy constants without importing plugin config schemas.
+* @boundary Shared literal values only; no schema or runtime registration dependencies.
+*/
+const SESSION_STRATEGIES = [
+	"memoryReflection",
+	"systemSessionMemory",
+	"none"
+];
+//#endregion
+//#region config/plugin-config-embedding-schema.ts
+const localEmbedSessionOptionsSchema = z.object({
+	graphOptimizationLevel: z.enum([
+		"disabled",
+		"basic",
+		"extended",
+		"all"
+	]).default("extended"),
+	enableMemPattern: z.boolean().default(false),
+	enableCpuMemArena: z.boolean().default(false),
+	executionMode: z.enum(["sequential", "parallel"]).optional(),
+	interOpNumThreads: z.number().int().positive().optional(),
+	intraOpNumThreads: z.number().int().positive().optional()
+}).strict().prefault({});
+const embeddingConfigSchema = z.object({
+	provider: z.enum(["local-onnx"]).default("local-onnx"),
+	/** Hugging Face model id. Defaults to the bundled PPLX INT8 model. */
+	model: z.string().optional(),
+	/** Output dimension after optional truncation and re-normalization. */
+	dimensions: z.number().int().positive().default(VECTOR_DIMENSION_DEFAULT),
+	/** Native dimension produced by the local model. */
+	nativeDim: z.number().int().positive().optional(),
+	/** Pinned HuggingFace revision (commit SHA) for local-onnx supply-chain integrity. */
+	revision: z.string().optional(),
+	/**
+	* Pooling strategy for local-onnx. Read from the model's
+	* `1_Pooling/config.json`. Omit to use the provider default; the bundled
+	* PPLX model uses `mean`.
+	*/
+	pooling: z.enum([
+		"last_token",
+		"mean",
+		"cls"
+	]).optional(),
+	normalized: z.boolean().optional(),
+	/** Local ONNX model cache directory */
+	cacheDir: z.string().optional(),
+	offline: z.boolean().optional(),
+	mirror: z.string().optional(),
+	/** Quantization dtype: q4 | q8 | fp16 | fp32 */
+	dtype: z.enum([
+		"q4",
+		"q8",
+		"fp16",
+		"fp32"
+	]).default("q8"),
+	/** ONNX Runtime session options for local low-memory operation. */
+	sessionOptions: localEmbedSessionOptionsSchema,
+	/** Enable text chunking for long passages (default: true) */
+	chunking: z.boolean().default(true)
+}).prefault({});
+//#endregion
+//#region src/model/llm-client-types.ts
+const LLM_PRESETS = [
+	FIXED_MEMORY_SNO_AI_EXTRACT,
+	FIXED_MEMORY_SNO_EXTRACT_CHAT,
+	FIXED_MEMORY_SNO_EXTRACT_PROFILE,
+	FIXED_MEMORY_SNO_CONFLICT_VERDICT
+];
+//#endregion
+//#region config/plugin-config-feature-schema.ts
+const sessionMemoryConfigSchema = z.object({
+	enabled: z.boolean().default(true),
+	messageCount: z.number().int().min(1).max(100).default(15)
+}).prefault({});
+const selfImprovementConfigSchema = z.object({
+	enabled: z.boolean().default(true),
+	beforeResetNote: z.boolean().default(true),
+	skipSubagentBootstrap: z.boolean().default(true),
+	ensureLearningFiles: z.boolean().default(true)
+}).prefault({});
+const extractionConfigSchema = z.object({ llm: z.object({
+	preset: z.enum(LLM_PRESETS).default(FIXED_MEMORY_SNO_AI_EXTRACT),
+	/** Overrides provider default / env baseURL if set. */
+	baseURL: z.string().optional(),
+	/** Overrides provider-native env if set. */
+	apiKey: z.string().optional(),
+	timeoutMs: z.number().int().min(1e3).max(3e5).default(3e4)
+}).strict().prefault({}) }).strict().prefault({});
+const memoryReflectionConfigSchema = z.object({
+	messageCount: z.number().int().min(1).max(500).default(120),
+	maxInputChars: z.number().int().min(1e3).max(2e5).default(DEFAULT_REFLECTION_MAX_INPUT_CHARS),
+	timeoutMs: z.number().int().min(5e3).max(3e5).default(DEFAULT_REFLECTION_TIMEOUT_MS),
+	errorReminderMaxEntries: z.number().int().min(0).max(50).default(3),
+	dedupeErrorSignals: z.boolean().default(true),
+	injectMode: z.enum([
+		"inheritance+derived",
+		"inheritance-only",
+		"none"
+	]).default("inheritance+derived"),
+	storeToDb: z.boolean().default(true),
+	/**
+	* Inject reflection invariants/derived slices into agent prompts at recall
+	* time. Default `false` until the LoCoMo paired-arm gate validates eval-
+	* neutrality (PRD §4.4.1, §5 eval gate). Permanent kill switch even after
+	* the default flips.
+	*/
+	injectIntoPrompt: z.boolean().default(false),
+	agentId: z.string().optional()
+}).prefault({});
+//#endregion
+//#region config/plugin-config-observe-schema.ts
+const AGENT_IDS = [
+	PERSISTED_PROVIDER_SYSTEM,
+	FIXED_PROTOCOL_VALUE_70,
+	FIXED_PROTOCOL_VALUE_71,
+	FIXED_PROTOCOL_VALUE_72
+];
+const observeAgentIdSchema = z.enum(AGENT_IDS, { error: () => `observe.agentId must be one of ${AGENT_IDS.join(", ")}` });
+function isLoopbackUrl(url) {
+	return url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1" || url.hostname === "[::1]";
+}
+function validateObserveBaseUrl(value, ctx) {
+	let parsed;
+	try {
+		parsed = new URL(value);
+	} catch {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["baseUrl"],
+			message: `Invalid observe.baseUrl: "${value}"`
+		});
+		return;
+	}
+	const normalized = parsed.origin;
+	if (process.env.SNO_STATION_MEM_NODE_ENV === "test" && isLoopbackUrl(parsed)) {
+		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["baseUrl"],
+			message: "observe.baseUrl test fixture must use http or https"
+		});
+		return;
+	}
+	if (normalized !== "https://www.sno.ai") ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["baseUrl"],
+		message: `observe.baseUrl must be ${SNO_OBSERVE_DEFAULT_BASE_URL} outside loopback tests`
+	});
+}
+const observeConfigSchema = z.object({
+	enabled: z.boolean().default(true),
+	baseUrl: z.string().default(SNO_OBSERVE_DEFAULT_BASE_URL),
+	agentId: observeAgentIdSchema.default(SNO_OBSERVE_DEFAULT_AGENT_ID)
+}).prefault({}).superRefine((value, ctx) => {
+	if (value.enabled) validateObserveBaseUrl(value.baseUrl, ctx);
+});
+//#endregion
+//#region config/plugin-config-retrieval-schema.ts
+const log = createLogger("sno-station-mem:config:retrieval");
+const retrievalConfigSchema = z.object({
+	mode: z.enum(["precision-recall", "vector"]).default("precision-recall"),
+	/**
+	* Top-K memories injected per turn during auto-recall. Source of truth
+	* for the runtime retriever `limit`; AC5 drift test pins this default
+	* to AUTO_RECALL_INJECTION_TOP_K (currently 20). Lower (15) trades
+	* ~5pp accuracy for ~25% fewer prompt tokens.
+	*/
+	recallTopK: z.number().int().min(0).max(2e3).default(20),
+	vectorWeight: z.number().min(0).max(1).default(DEFAULT_VECTOR_WEIGHT),
+	bm25Weight: z.number().min(0).max(1).default(DEFAULT_BM25_WEIGHT),
+	minScore: z.number().min(0).max(1).default(0),
+	rerank: z.enum([
+		"cross-encoder",
+		"lightweight",
+		"none"
+	]).default("lightweight"),
+	candidatePoolSize: z.number().int().min(10).max(2e3).default(64),
+	rerankApiKey: z.string().optional(),
+	rerankModel: z.string().default(DEFAULT_RERANK_MODEL),
+	rerankTimeoutMs: z.number().int().min(1e3).max(12e4).default(DEFAULT_RERANK_TIMEOUT_MS),
+	recencyHalfLifeDays: z.number().min(0).max(365).default(14),
+	recencyWeight: z.number().min(0).max(RECENCY_WEIGHT_MAX).default(RECENCY_WEIGHT),
+	/** Drop memories past their valid_until timestamp (default OFF — needs A/B eval) */
+	temporalWeighting: z.boolean().default(false),
+	mmrWindowOnly: z.boolean().default(false),
+	temporalExpiry: z.boolean().default(false),
+	/** Dynamic memories decay 3× faster in time-decay scoring (default ON — low risk) */
+	temporalDecay: z.boolean().default(true),
+	lengthNormAnchor: z.number().int().min(0).max(5e3).default(0),
+	hardMinScore: z.number().min(0).max(1).default(0),
+	timeDecayHalfLifeDays: z.number().min(0).max(365).default(60),
+	/** Weight for fusion score in rerank blend */
+	rerankBlendVector: z.number().min(0).max(1).optional(),
+	/** Weight for cross-encoder score in rerank blend */
+	rerankBlendCross: z.number().min(0).max(1).optional(),
+	/** Fusion-score weight when rerank="lightweight" (local cosine blend) */
+	lightweightFusionWeight: z.number().min(0).max(1).optional(),
+	/** Cosine-score weight when rerank="lightweight" (local cosine blend) */
+	lightweightCosineWeight: z.number().min(0).max(1).optional(),
+	/** Base multiplier for importance weighting */
+	importanceWeightBase: z.number().min(0).max(1).optional(),
+	/** Minimum multiplier for old entries */
+	timeDecayFloor: z.number().min(0).max(1).optional(),
+	/** Relevance vs diversity tradeoff (default: 0.7) */
+	mmrLambda: z.number().min(0).max(1).optional(),
+	/** Custom rerank API endpoint URL. */
+	rerankEndpoint: z.string().optional(),
+	/** Rerank provider name */
+	rerankProvider: z.enum([
+		"jina",
+		"siliconflow",
+		"pinecone",
+		"voyage",
+		"dashscope",
+		"tei",
+		"custom"
+	]).optional(),
+	/** Hard cap on candidates sent per rerank API request (some deployments reject over-limit batches) */
+	rerankMaxCandidates: z.number().int().min(1).max(2e3).optional(),
+	/** Scaling factor for access-based reinforcement (0 = disabled, default: 0.5) */
+	reinforcementFactor: z.number().min(0).max(5).default(.5),
+	/** Hard cap: effective half-life <= baseHalfLife * maxHalfLifeMultiplier (default: 3) */
+	maxHalfLifeMultiplier: z.number().min(1).max(10).default(3)
+}).prefault({}).transform((ret, ctx) => {
+	if (ret.rerank === "none") return ret;
+	if ((ret.rerank === "cross-encoder" || ret.rerankEndpoint !== void 0) && ret.rerankProvider === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		path: ["rerankProvider"],
+		message: "retrieval.rerankProvider is required when retrieval.rerank is \"cross-encoder\" or retrieval.rerankEndpoint is set: the provider decides the request shape and the per-request batch limit"
+	});
+	if (ret.rerankEndpoint !== void 0) try {
+		new URL(ret.rerankEndpoint);
+	} catch {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["rerankEndpoint"],
+			message: `Invalid rerankEndpoint URL: "${ret.rerankEndpoint}"`
+		});
+	}
+	const rerankApiKey = ret.rerankApiKey;
+	if (ret.rerank === "cross-encoder" && !rerankApiKey?.trim()) {
+		log.error("memory.rerank.key.missing", { cause: "missing-rerank-key" }, {
+			event_name: "memory.rerank.key.missing",
+			file: "packages/memory/config/plugin-config-retrieval-schema.ts",
+			function: "retrievalConfigSchema",
+			site_id: "memory.rerank.key.missing"
+		});
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			path: ["rerankApiKey"],
+			message: "retrieval.rerankApiKey is required for cross-encoder reranking"
+		});
+	}
+	return ret;
+});
+//#endregion
+//#region config/plugin-config-schema.ts
+const scopesConfigSchema = z.object({
+	default: z.string().default(DEFAULT_SCOPE),
+	definitions: z.record(z.string(), z.object({
+		description: z.string().optional(),
+		metadata: z.record(z.string(), z.unknown()).optional()
+	})).prefault({ global: { description: "Shared knowledge across all agents" } }),
+	agentAccess: z.record(z.string(), z.array(z.string())).default({})
+}).prefault({});
+const providerConfigSchema = z.object({ userId: z.string().trim().optional() }).strict().prefault({});
+const ONBOARDING_PROFILES = [
+	"local-active",
+	"capture-only",
+	"manual-only",
+	"custom"
+];
+const REM_OPERATIONS = ["rem-replace", "rem-update"];
+const pluginConfigSchema = z.object({
+	embedding: embeddingConfigSchema,
+	observe: observeConfigSchema,
+	dbPath: z.string().optional(),
+	provider: providerConfigSchema,
+	ambientLearning: z.boolean().default(true),
+	autoRecall: z.boolean().default(false),
+	/** Minimum query length for auto-recall to fire (default: 15) */
+	autoRecallMinLength: z.number().int().min(0).max(200).default(2),
+	/** Skip re-injecting a memory if it was shown within the last N turns (0 = no dedup) */
+	autoRecallMinRepeated: z.number().int().min(0).max(100).default(0),
+	/** Maximum character length of auto-recall query before truncation */
+	autoRecallMaxQueryLength: z.number().int().min(100).max(1e4).default(DEFAULT_AUTO_RECALL_MAX_QUERY_LENGTH),
+	/** Timeout in ms for the entire auto-recall pipeline (embed + search + rerank) */
+	autoRecallTimeoutMs: z.number().int().min(500).max(6e4).default(5e3),
+	/**
+	* Whitelist: if non-empty, ONLY these agentIds receive auto-recall injection.
+	* Takes precedence over autoRecallExcludeAgents when both are set. Entries
+	* are trimmed; empty strings are dropped.
+	*/
+	autoRecallIncludeAgents: z.array(z.string().transform((s) => s.trim())).transform((arr) => arr.filter((s) => s.length > 0)).default([]),
+	/**
+	* Blocklist: agentIds excluded from auto-recall injection. The implicit
+	* "main" fallback used when hook context lacks a parseable agent identity
+	* is evaluated against this blocklist too.
+	*/
+	autoRecallExcludeAgents: z.array(z.string().transform((s) => s.trim())).transform((arr) => arr.filter((s) => s.length > 0)).default([]),
+	captureAssistant: z.boolean().default(false),
+	retrieval: retrievalConfigSchema,
+	scopes: scopesConfigSchema,
+	enableManagementTools: z.boolean().default(false),
+	/**
+	* Optional user-facing language for tool descriptions and other static
+	* locale-bound surface that cannot be derived from query text.
+	*/
+	language: z.enum(SUPPORTED_LOCALES).optional(),
+	sessionStrategy: z.enum(SESSION_STRATEGIES).default("systemSessionMemory"),
+	sessionMemory: sessionMemoryConfigSchema,
+	compression: z.object({ enabled: z.boolean().default(false) }).optional(),
+	selfImprovement: selfImprovementConfigSchema,
+	extraction: extractionConfigSchema,
+	memoryReflection: memoryReflectionConfigSchema,
+	/**
+	* Phase 0 lifecycle stub channel. All flags default false; enabling any
+	* lights up its dedicated wire site without altering the others.
+	*/
+	recallLifecycle: recallLifecycleSchema,
+	memoryTelemetry: z.object({
+		enabled: z.boolean().default(true),
+		currentKeyVersion: z.number().int().positive().default(1),
+		key: z.string().default(""),
+		historicKeys: z.array(z.string()).default([])
+	}).prefault({}),
+	debugContent: z.boolean().default(false),
+	/**
+	* Product LLM mode, tier-ordered: local-first → agent-native →
+	* rem-enhanced. A true bare config defaults to agent-native; model route
+	* config requires an explicit product mode.
+	*/
+	mode: z.enum(PRODUCT_MODES).default(DEFAULT_MODEL_MODE),
+	modelCalls: z.record(z.string(), z.record(z.enum(PRODUCT_MODES), z.enum([
+		"off",
+		"host",
+		"sno-gpu"
+	]))).optional(),
+	remOperations: z.array(z.enum(REM_OPERATIONS)).min(1).max(2).default([...REM_OPERATIONS]),
+	remEnhanced: remEnhancedConfigSchema,
+	/**
+	* Installer completion marker (bin/_onboarding-core.js writes it into
+	* this same config block). The runtime never reads it, but the strict
+	* schema must accept it or every installer-onboarded config fails to
+	* load.
+	*/
+	onboarding: z.object({
+		version: z.number().int().positive(),
+		completedAt: z.string(),
+		profile: z.enum(ONBOARDING_PROFILES)
+	}).strict().optional()
+}).strict();
+//#endregion
+export { memoryReflectionConfigSchema as a, embeddingConfigSchema as c, extractionConfigSchema as i, SESSION_STRATEGIES as l, retrievalConfigSchema as n, selfImprovementConfigSchema as o, observeConfigSchema as r, sessionMemoryConfigSchema as s, pluginConfigSchema as t };

package/dist/profile-TWPJ_myr.d.ts

@@ -0,0 +1,13 @@
+import { y as Settings } from "./plugin-config-schema-C0UUbOmG.js";
+//#region src/contract/profile.d.ts
+declare function getStateDir(defaultStateDir?: string): string;
+declare function getSettingsPath(): string;
+declare class SettingsUnavailableError extends Error {}
+declare function readSettings(): Settings;
+declare function getSnoStationMemStateDir(): string;
+declare function getPrincipal(): string;
+declare function getDiscoveryPath(): string;
+declare function getSidecarSocketPath(): string;
+declare function getStartupLogPath(): string;
+//#endregion
+export { getSidecarSocketPath as a, getStateDir as c, getSettingsPath as i, readSettings as l, getDiscoveryPath as n, getSnoStationMemStateDir as o, getPrincipal as r, getStartupLogPath as s, SettingsUnavailableError as t };