@snoai/memory 0.0.0-stage → 1.0.0

package/dist/embedding-provider-client-vynZMuit.d.ts

@@ -0,0 +1,94 @@
+import { LocalEmbedDtype, LocalEmbedSessionOptions } from "@snoai/embedder";
+//#region src/engine/extraction/embedding-provider-factory.d.ts
+type EmbeddingProviderKind = "local-onnx";
+interface EmbeddingConfig {
+  /** Which provider to instantiate. Defaults to local-onnx. */
+  provider?: EmbeddingProviderKind;
+  /** Hugging Face model id. Defaults to the bundled PPLX INT8 model. */
+  model?: string;
+  /** Output dimension. Smaller values truncate and re-normalize the native vector. */
+  dimensions?: number;
+  /** Native model dimension. Defaults to 1024 for bundled PPLX. */
+  nativeDim?: number;
+  /** Pinned HuggingFace revision SHA for local-onnx (defaults to bundled 0.6B revision). */
+  revision?: string;
+  /**
+   * Pooling strategy for local-onnx. Defaults to `mean` for bundled PPLX.
+   * Read the model's `1_Pooling/config.json`.
+   */
+  pooling?: "last_token" | "mean" | "cls";
+  normalized?: boolean;
+  /** Local ONNX model cache directory (default: ./embedding/models) */
+  cacheDir?: string;
+  offline?: boolean;
+  mirror?: string;
+  /** Quantization dtype. Default: q8. */
+  dtype?: LocalEmbedDtype;
+  /** ONNX Runtime session options for local low-memory operation. */
+  sessionOptions?: LocalEmbedSessionOptions;
+  /** Enable text chunking for long passages (default: true) */
+  chunking?: boolean;
+}
+//#endregion
+//#region src/engine/extraction/embedding-provider-client.d.ts
+declare class Embedder {
+  private readonly provider;
+  private readonly chunkingEnabled;
+  readonly dimensions: number;
+  readonly providerKind: EmbeddingProviderKind;
+  readonly model: string;
+  private warmupPromise;
+  private readonly modelDownload;
+  /**
+   * Initializes embedding generation collaborators while keeping runtime work in explicit
+   * methods.
+   */
+  constructor(config: EmbeddingConfig, _stateDir: string);
+  /** Converts float32 into the transport shape expected by embedding generation. */
+  private toFloat32;
+  private buildEmbedderChunkConfig;
+  /**
+   * Exact token count under the embedding model's own tokenizer — the count the model
+   * sees, so `DEFAULT_MAX_CONTEXT_TOKENS` checked against it is a hard limit. Synchronous;
+   * throws until the model has loaded, which `warmup()` does at plugin register time.
+   */
+  countTokens(text: string): number;
+  /** Longest prefix of `text` within `maxTokens` under {@link countTokens}. */
+  truncateToTokens(text: string, maxTokens: number): string;
+  /**
+   * Wait for warmup before issuing real embedding work. Calls `warmup()`
+   * itself so callers that bypass register-time warmup (tests, ad-hoc
+   * scripts) still get the same fail-loud probe — `warmup()` is memoized,
+   * so repeated calls reuse the in-flight or completed promise.
+   */
+  private awaitWarmup;
+  /** Implements embed as the local embedding generation operation. */
+  embed(text: string): Promise<Float32Array>;
+  /** Implements embed direct as the local embedding generation operation. */
+  protected embedDirect(text: string): Promise<Float32Array>;
+  /** Implements embed many as the local embedding generation operation. */
+  embedMany(values: string[]): Promise<Float32Array[]>;
+  /**
+   * Embed each input text individually as a passage. Used by chunk-level
+   * ingestion in `MemoryStore` — one vector per chunk, no averaging. Reuses
+   * the batch primitive and its cache.
+   */
+  embedChunks(texts: string[]): Promise<Float32Array[]>;
+  /**
+   * Force the underlying ONNX model to load and run one real inference.
+   *
+   * LocalEmbedProvider lazy-loads the model on first `embed()` call. That
+   * means `new Embedder(...)` succeeds even if the model file is missing —
+   * the failure only surfaces later, per-turn, during ambient-learning, where
+   * the error is swallowed by `Promise.allSettled`. Calling `warmup()` at
+   * plugin-register time turns a latent misconfiguration into a hard,
+   * loud registration failure. Caller should let the error propagate.
+   */
+  warmup(): Promise<void>;
+  /** Implements dispose as the local embedding generation operation. */
+  dispose(): Promise<void>;
+}
+/** Creates the embedder facade around the local ONNX provider. */
+declare function createEmbedder(config: EmbeddingConfig, stateDir: string): Embedder;
+//#endregion
+export { EmbeddingProviderKind as i, createEmbedder as n, EmbeddingConfig as r, Embedder as t };

package/dist/entry-metadata-parser-BIVSMCIk.js

@@ -0,0 +1,20 @@
+//#region src/engine/reflection/entry-metadata-parser.ts
+/** @file entry-metadata-parser.ts
+* @purpose Defines metadata helpers for reflection provenance, severity, and grouping.
+* @boundary Reflection item storage, retry handling, and reporting surfaces.
+* @see daily-log-generator.ts, slice-item-payload-builder.ts, transient-generation-retry.ts.
+*/
+/**
+* Reflection metadata parsing utilities.
+*/
+function parseReflectionMetadata(metadataRaw) {
+	if (!metadataRaw) return {};
+	try {
+		const parsed = JSON.parse(metadataRaw);
+		return parsed && typeof parsed === "object" ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+//#endregion
+export { parseReflectionMetadata as t };

package/dist/error-D-wb-rZw.js

@@ -0,0 +1,23 @@
+//#region src/contract/error.ts
+const DEGRADED_REASONS = [
+	"sidecar-unreachable",
+	"sidecar-unresponsive",
+	"principal-mismatch",
+	"store-mismatch",
+	"no-agent-endpoint",
+	"invalid-input",
+	"timeout",
+	"storage-unavailable",
+	"engine-failed"
+];
+var ContractError = class extends Error {
+	reason;
+	degraded = true;
+	constructor(reason, message = reason) {
+		super(message);
+		this.reason = reason;
+		this.name = "ContractError";
+	}
+};
+//#endregion
+export { DEGRADED_REASONS as n, ContractError as t };

package/dist/error-signals-D8_3vYu4.d.ts

@@ -0,0 +1,28 @@
+//#region src/engine/security/error-signals.d.ts
+type ReflectionErrorSignal = {
+  at: number;
+  toolName: string;
+  summary: string;
+  source: "tool_error" | "tool_output";
+  signature: string;
+  signatureHash: string;
+};
+type ReflectionErrorState = {
+  entries: ReflectionErrorSignal[];
+  lastInjectedCount: number;
+  signatureSet: Set<string>;
+  updatedAt: number;
+};
+type CreateErrorSignalTrackerOptions = {
+  maxTrackedSessions?: number;
+};
+/** Creates the per-session tracker that batches runtime errors for reflection feedback. */
+declare function createErrorSignalTracker(options?: CreateErrorSignalTrackerOptions): {
+  getState: (sessionKey: string) => ReflectionErrorState;
+  addSignal: (sessionKey: string, signal: ReflectionErrorSignal, dedupeEnabled: boolean) => void;
+  getPendingSignals: (sessionKey: string, maxEntries: number) => ReflectionErrorSignal[];
+  clearSession: (sessionKey: string) => void;
+  prune: (ttlMs: number, maxSessions: number) => void;
+};
+//#endregion
+export { createErrorSignalTracker as n, ReflectionErrorSignal as t };

package/dist/error-signals-lMH2uAdV.js

@@ -0,0 +1,134 @@
+import "./internal/config/index.js";
+import { redactSecrets } from "./internal/engine/security/redact.js";
+import { createHash } from "node:crypto";
+//#region src/engine/security/error-signals.ts
+/** @file error-signals.ts
+* @purpose Classifies error-like text patterns used by capture and retrieval heuristics.
+* @boundary Multilingual runtime regexes and operational signal extraction.
+* @see capture-policy-detector.ts, intent-analyzer.ts, memory-noise-classifier.ts.
+*/
+const ERROR_SIGNAL_PATTERNS = [
+	/\[error\]|error:|exception:|fatal:|traceback|syntaxerror|typeerror|referenceerror|npm err!/,
+	/command not found|no such file|permission denied|non-zero|exit code/,
+	/"status"\s*:\s*"error"|"status"\s*:\s*"failed"|\biserror\b/,
+	/错误\s*[：:]|异常\s*[：:]|报错\s*[：:]|失败\s*[：:]/
+];
+const SUMMARY_MAX_LEN = 220;
+const SIGNATURE_MAX_LEN = 240;
+const MAX_ENTRIES_PER_SESSION = 30;
+/** Implements touch session state as the local runtime error signal extraction operation. */
+function touchSessionState(sessions, key, state) {
+	sessions.delete(key);
+	sessions.set(key, state);
+	return state;
+}
+/** Filters oldest sessions before it affects runtime error signal extraction decisions. */
+function pruneOldestSessions(sessions, maxSessions) {
+	const cappedMaxSessions = Math.max(0, maxSessions);
+	while (sessions.size > cappedMaxSessions) {
+		const oldestKey = sessions.keys().next().value;
+		if (oldestKey === void 0) break;
+		sessions.delete(oldestKey);
+	}
+}
+/** Implements contains error signal as the local runtime error signal extraction operation. */
+function containsErrorSignal(text) {
+	const normalized = text.toLowerCase();
+	return ERROR_SIGNAL_PATTERNS.some((p) => p.test(normalized));
+}
+/**
+* Normalizes error signature at the boundary before runtime error signal extraction uses it.
+*/
+function normalizeErrorSignature(text) {
+	return redactSecrets(String(text || "")).toLowerCase().replace(/[a-z]:\\[^ \n\r\t]+/gi, "<path>").replace(/\/[^ \n\r\t]+/g, "<path>").replace(/\b0x[0-9a-f]+\b/gi, "<hex>").replace(/\b\d+\b/g, "<n>").replace(/\s+/g, " ").trim().slice(0, SIGNATURE_MAX_LEN);
+}
+/** Implements summarize error text as the local runtime error signal extraction operation. */
+function summarizeErrorText(text, maxLen = SUMMARY_MAX_LEN) {
+	const oneLine = redactSecrets(text).replace(/\s+/g, " ").trim();
+	if (!oneLine) return "(empty tool error)";
+	return oneLine.length <= maxLen ? oneLine : `${oneLine.slice(0, maxLen - 3)}...`;
+}
+/** Implements sha256 hex as the local runtime error signal extraction operation. */
+function sha256Hex(text) {
+	return createHash("sha256").update(text, "utf8").digest("hex");
+}
+/** Extracts text from tool result from raw inputs while tolerating partial data. */
+function extractTextFromToolResult(result) {
+	if (result == null) return "";
+	if (typeof result === "string") return result;
+	if (typeof result !== "object") return "";
+	const obj = result;
+	const content = obj.content;
+	if (!Array.isArray(content)) return typeof obj.text === "string" ? obj.text : "";
+	const parts = [];
+	for (const item of content) {
+		if (!item || typeof item !== "object") continue;
+		const rec = item;
+		if (rec.type === "text" && typeof rec.text === "string") parts.push(rec.text);
+	}
+	return parts.join("\n");
+}
+/** Creates the per-session tracker that batches runtime errors for reflection feedback. */
+function createErrorSignalTracker(options = {}) {
+	const sessions = /* @__PURE__ */ new Map();
+	const maxTrackedSessions = Math.max(0, options.maxTrackedSessions ?? 200);
+	/** Returns state from runtime error signal extraction state without side effects. */
+	const getState = (sessionKey) => {
+		const key = sessionKey.trim();
+		const current = sessions.get(key);
+		if (current) {
+			current.updatedAt = Date.now();
+			return touchSessionState(sessions, key, current);
+		}
+		pruneOldestSessions(sessions, Math.max(0, maxTrackedSessions - 1));
+		return touchSessionState(sessions, key, {
+			entries: [],
+			lastInjectedCount: 0,
+			signatureSet: /* @__PURE__ */ new Set(),
+			updatedAt: Date.now()
+		});
+	};
+	return {
+		getState,
+		/** Adds signal to the local runtime error signal extraction accumulator. */
+		addSignal(sessionKey, signal, dedupeEnabled) {
+			if (!sessionKey.trim()) return;
+			const state = getState(sessionKey);
+			if (dedupeEnabled && state.signatureSet.has(signal.signatureHash)) return;
+			state.entries.push(signal);
+			state.signatureSet.add(signal.signatureHash);
+			state.updatedAt = Date.now();
+			if (state.entries.length > MAX_ENTRIES_PER_SESSION) {
+				const removed = state.entries.length - MAX_ENTRIES_PER_SESSION;
+				state.entries.splice(0, removed);
+				state.lastInjectedCount = Math.max(0, state.lastInjectedCount - removed);
+				state.signatureSet = new Set(state.entries.map((e) => e.signatureHash));
+			}
+		},
+		/** Drains the not-yet-injected error signals, advancing the injection marker so callers never re-receive them. */
+		getPendingSignals(sessionKey, maxEntries) {
+			if (maxEntries <= 0) return [];
+			const key = sessionKey.trim();
+			const state = sessions.get(key);
+			if (!state) return [];
+			state.updatedAt = Date.now();
+			touchSessionState(sessions, key, state);
+			const start = Math.min(Math.max(0, state.lastInjectedCount), state.entries.length);
+			const pending = state.entries.slice(start);
+			state.lastInjectedCount = state.entries.length;
+			return pending.length > maxEntries ? pending.slice(-maxEntries) : pending;
+		},
+		/** Removes session while preserving runtime error signal extraction invariants. */
+		clearSession(sessionKey) {
+			sessions.delete(sessionKey.trim());
+		},
+		/** Implements prune as the local runtime error signal extraction operation. */
+		prune(ttlMs, maxSessions) {
+			const now = Date.now();
+			for (const [key, state] of sessions.entries()) if (now - state.updatedAt > ttlMs) sessions.delete(key);
+			pruneOldestSessions(sessions, maxSessions);
+		}
+	};
+}
+//#endregion
+export { sha256Hex as a, normalizeErrorSignature as i, createErrorSignalTracker as n, summarizeErrorText as o, extractTextFromToolResult as r, containsErrorSignal as t };

package/dist/errors-CeVRxf9V.d.ts

@@ -0,0 +1,49 @@
+//#region src/engine/shared/errors.d.ts
+/** @file errors.ts
+ * @purpose Defines typed plugin errors and stable codes for callers and CLI output.
+ * @boundary Runtime boundaries, CLI error mapping, and test assertions.
+ * @see memory-management-cli.ts, sno-station-mem-plugin-runtime.ts, memory-tool-registration.ts.
+ */
+declare class SnoStationMemError extends Error {
+  readonly code: string;
+  /**
+   * Initializes typed error reporting collaborators while keeping runtime work in explicit
+   * methods.
+   */
+  constructor(code: string, message: string, cause?: unknown);
+}
+declare class StorageError extends SnoStationMemError {
+  /**
+   * Initializes typed error reporting collaborators while keeping runtime work in explicit
+   * methods.
+   */
+  constructor(message: string, cause?: unknown);
+}
+declare class EmbeddingError extends SnoStationMemError {
+  /**
+   * Initializes typed error reporting collaborators while keeping runtime work in explicit
+   * methods.
+   */
+  constructor(message: string, cause?: unknown);
+}
+declare class RetrievalError extends SnoStationMemError {
+  /**
+   * Carries the cause's own message in `message`, not only in `cause`.
+   *
+   * Retrieval wraps every failure as "Failed to retrieve memories", and every consumer that
+   * reports one — a tool result, an eval harness, an HTTP boundary — reports `message` and drops
+   * the Error. Measured 2026-09-04: a whole evaluation round scored nothing and the only trace
+   * on disk was fifteen identical copies of that sentence, so the reason had to be re-derived by
+   * reproducing the run. The cause stays attached as well; this only makes it survive the trip.
+   */
+  constructor(message: string, cause?: unknown);
+}
+declare class ConfigError extends SnoStationMemError {
+  /**
+   * Initializes typed error reporting collaborators while keeping runtime work in explicit
+   * methods.
+   */
+  constructor(message: string, cause?: unknown);
+}
+//#endregion
+export { StorageError as a, SnoStationMemError as i, EmbeddingError as n, RetrievalError as r, ConfigError as t };

package/dist/extraction-text-sanitizer-B_AhIecT.d.ts

@@ -0,0 +1,32 @@
+//#region src/engine/extraction/extraction-text-sanitizer.d.ts
+/**
+ * Keeps a section's clause list inside `DEFAULT_MAX_CONTEXT_TOKENS`, the repository-wide
+ * per-record ceiling the store refuses to write past.
+ *
+ * A profile section is one row by design (`getByFactKey` is singular), and merging appends, so
+ * a long-lived section grows without bound — measured 2026-09-14 on a real persona store, five
+ * successive versions of `preferences.general` ran 516 → 533 → 538 → 540 → 576 tokens. Past the
+ * ceiling the embedder and the reranker both truncate silently, so the tail of such a section is
+ * already invisible to retrieval; dropping it here is the same loss made honest, and it keeps the
+ * merge writing instead of throwing.
+ *
+ * Oldest clauses go first: `mergeProfileSection` seeds the map with the stored clauses and then
+ * the incoming ones, so insertion order runs oldest to newest. The abstract is kept whatever
+ * happens — it is the section's only summary and it leads the indexed text.
+ */
+declare function boundSectionContent(content: string, abstract: string, countRecordTokens: (text: string) => number): string;
+/**
+ * Build the string that goes into the `text` column of `nodix_memories`.
+ *
+ * The FTS5 BM25 index is derived from this column only (see
+ * drizzle/0001_virtual_tables.sql). Concatenating abstract and content gives
+ * BM25 the same source surface used for vector embedding.
+ */
+declare function buildIndexedText(abstract: string, content: string): string;
+/**
+ * Strip platform envelope metadata injected by SnoStationMem channels before the
+ * conversation text reaches the extraction LLM.
+ */
+declare function stripEnvelopeMetadata(text: string): string;
+//#endregion
+export { buildIndexedText as n, stripEnvelopeMetadata as r, boundSectionContent as t };

package/dist/i18n-text-DbD6Qify.d.ts

@@ -0,0 +1,13 @@
+//#region src/engine/shared/i18n-text.d.ts
+declare const HTML_TAG_PATTERN: RegExp;
+/** Builds a Unicode-aware left/right token-boundary regex around a regex body. */
+declare function unicodeBoundaryRegex(body: string, flags?: string): RegExp;
+/** Matches CJK terms by substring and alphabetic terms by Unicode token boundaries. */
+declare function boundaryAwareRegex(term: string, flags?: string): RegExp;
+declare function stripHtmlTags(text: string): string;
+declare function stripRoleLabelPrefix(text: string): string;
+declare function normalizeForCompare(text: string): string;
+declare function truncateGraphemes(text: string, maxGraphemes: number, suffix?: string): string;
+declare function tokenizeForFts(rawQuery: string): string[];
+//#endregion
+export { stripRoleLabelPrefix as a, unicodeBoundaryRegex as c, stripHtmlTags as i, boundaryAwareRegex as n, tokenizeForFts as o, normalizeForCompare as r, truncateGraphemes as s, HTML_TAG_PATTERN as t };