@snoai/memory 0.0.0-stage → 1.0.0

package/dist/strategy-hook-runner-gBtU47tX.d.ts

@@ -0,0 +1,16 @@
+import { t as PluginConfig } from "./plugin-config-schema-C0UUbOmG.js";
+import "./types-DxKqU60b.js";
+import "./reflection-embedded-generator-CxOex5xK.js";
+import { t as ReflectionLifecycleParams } from "./reflection-lifecycle-hooks-Ct5HBdSG.js";
+import { t as ReflectionInjectionParams } from "./reflection-injection-hooks-DfUgqu8f.js";
+import { t as ReflectionDeps } from "./reflection-deps-RpLPFrSc.js";
+import { t as ReflectionCommandParams } from "./reflection-command-hooks-C1Vxgb-O.js";
+//#region src/engine/reflection/strategy-hook-runner.d.ts
+declare function createReflectionStrategyState(config: PluginConfig, deps: ReflectionDeps): ReflectionStrategyState;
+type ReflectionStrategyState = {
+  lifecycle: ReflectionLifecycleParams;
+  injection: ReflectionInjectionParams;
+  command: Omit<ReflectionCommandParams, "logger">;
+};
+//#endregion
+export { createReflectionStrategyState as n, ReflectionStrategyState as t };

package/dist/strategy-hook-runner-zmdIYOmQ.js

@@ -0,0 +1,110 @@
+import { DEFAULT_REFLECTION_SESSION_TTL_MS } from "./internal/config/index.js";
+import { setLruEntry, touchLruEntry } from "./internal/engine/shared/lru.js";
+import { n as createErrorSignalTracker } from "./error-signals-lMH2uAdV.js";
+import { i as pruneReflectionState } from "./reflection-embedded-generator-CDUhgV96.js";
+import { a as loadAgentReflectionSlicesFromEntries } from "./memory-entry-projector-DHo8jH10.js";
+import { createLogger } from "@snoai/utils/logger";
+//#region src/engine/reflection/reflection-slice-loader.ts
+/** @file reflection-slice-loader.ts
+* @purpose Loads and caches reflection slices for prompt injection.
+*/
+function createReflectionSliceLoader(params) {
+	const reflectionSliceCache = /* @__PURE__ */ new Map();
+	async function loadAgentReflectionSlices(agentId, projectIdFilter) {
+		const effectiveScopes = agentId !== "main" ? (() => {
+			const mainScope = params.scopePolicy.getDefaultScope("main");
+			return projectIdFilter.includes(mainScope) ? projectIdFilter : [...projectIdFilter, mainScope];
+		})() : projectIdFilter;
+		const cacheKey = `${agentId}::${[...effectiveScopes].sort().join(",")}`;
+		const cached = touchLruEntry(reflectionSliceCache, cacheKey);
+		if (cached && Date.now() - cached.updatedAt < 15e3) return cached;
+		if (cached) reflectionSliceCache.delete(cacheKey);
+		const allEntries = [];
+		for (const scope of effectiveScopes) {
+			const recent = await params.store.list({
+				projectId: scope,
+				limit: 240
+			});
+			allEntries.push(...recent);
+		}
+		const slices = loadAgentReflectionSlicesFromEntries({
+			entries: allEntries,
+			agentId
+		});
+		const next = {
+			updatedAt: Date.now(),
+			invariants: slices.invariants.slice(0, 8),
+			derived: slices.derived.slice(0, 10),
+			invariantSources: limitSources(slices.invariantSources, 8),
+			derivedSources: limitSources(slices.derivedSources, 10)
+		};
+		setLruEntry(reflectionSliceCache, cacheKey, next, 200);
+		return next;
+	}
+	return {
+		loadAgentReflectionSlices,
+		clearAll: () => reflectionSliceCache.clear(),
+		clearAgent: (agentId) => {
+			for (const k of [...reflectionSliceCache.keys()]) if (k.startsWith(`${agentId}::`)) reflectionSliceCache.delete(k);
+		}
+	};
+}
+function limitSources(sources, limit) {
+	return sources.filter((source) => source.rank <= limit);
+}
+//#endregion
+//#region src/engine/reflection/strategy-hook-runner.ts
+/** @file strategy-hook-runner.ts
+* @purpose Connects runtime events to reflection storage and learning workflows.
+* @boundary Plugin hooks, reflection analysis, and self-improvement integration.
+* @see daily-log-generator.ts, learning-file-hooks.ts, sno-station-mem-plugin-runtime.ts.
+*/
+createLogger("sno-station-mem:strategy-hook-runner");
+function createReflectionStrategyState(config, deps) {
+	const reflectionCfg = config.memoryReflection;
+	const errorTracker = createErrorSignalTracker({ maxTrackedSessions: 200 });
+	const derivedCache = /* @__PURE__ */ new Map();
+	const derivedSuppressionCache = /* @__PURE__ */ new Map();
+	const derivedKey = (sessionKey) => `${deps.parseAgentIdFromSessionKey(sessionKey) || "main"}::${sessionKey}`;
+	const doPrune = () => pruneReflectionState(errorTracker, derivedCache, derivedSuppressionCache, DEFAULT_REFLECTION_SESSION_TTL_MS, 200);
+	const sliceLoader = createReflectionSliceLoader({
+		store: deps.store,
+		scopePolicy: deps.scopePolicy
+	});
+	deps.onSliceCacheReady?.(sliceLoader.clearAll);
+	return {
+		lifecycle: {
+			reflectionCfg,
+			errorTracker,
+			derivedCache,
+			derivedSuppressionCache,
+			derivedKey,
+			doPrune
+		},
+		injection: {
+			reflectionCfg,
+			scopePolicy: deps.scopePolicy,
+			errorTracker,
+			derivedCache,
+			derivedSuppressionCache,
+			derivedKey,
+			doPrune,
+			sliceLoader,
+			telemetryUsage: deps.telemetryUsage
+		},
+		command: {
+			config,
+			reflectionCfg,
+			deps,
+			errorTracker,
+			derivedCache,
+			derivedSuppressionCache,
+			derivedKey,
+			doPrune,
+			clearSliceCacheForAgent: sliceLoader.clearAgent,
+			clearAllSliceCache: sliceLoader.clearAll
+		}
+	};
+}
+//#endregion
+export { createReflectionStrategyState as t };

package/dist/token-counter-BD1f48Km.js

@@ -0,0 +1,73 @@
+import { LOCAL_EMBEDDING_MODEL } from "@snoai/embedder";
+import { encodingForModel, getEncoding } from "js-tiktoken";
+//#region src/engine/observability/token-counter.ts
+/** @file token-counter.ts
+* @purpose Selects the token counter labels accepted by sno.ai analytics.
+* @boundary Counts metadata only; never affects embedding or retrieval behavior.
+*/
+const qwenTokenizerPromises = /* @__PURE__ */ new Map();
+async function defaultQwenTokenizerLoader(model) {
+	const { AutoTokenizer } = await import("@huggingface/transformers");
+	return AutoTokenizer.from_pretrained(model);
+}
+let qwenTokenizerLoader = defaultQwenTokenizerLoader;
+function hasProviderUsage(providerUsageTokens) {
+	return providerUsageTokens !== void 0 && Number.isFinite(providerUsageTokens);
+}
+function isQwenEmbedding(config) {
+	const model = config.model ?? LOCAL_EMBEDDING_MODEL;
+	return (config.provider ?? "local-onnx") === "local-onnx" && /qwen/i.test(model);
+}
+async function getQwenTokenizer(model) {
+	const cached = qwenTokenizerPromises.get(model);
+	if (cached) return cached;
+	const tokenizer = qwenTokenizerLoader(model).catch((error) => {
+		qwenTokenizerPromises.delete(model);
+		throw error;
+	});
+	qwenTokenizerPromises.set(model, tokenizer);
+	return tokenizer;
+}
+function countWithTiktoken(text, model) {
+	try {
+		return encodingForModel(model ?? "text-embedding-3-small").encode(text).length;
+	} catch {
+		return getEncoding("cl100k_base").encode(text).length;
+	}
+}
+function charApproximation(text) {
+	return Math.ceil(Buffer.byteLength(text, "utf8") / 4);
+}
+async function countEmbeddingTokens(text, config, providerUsageTokens) {
+	if (hasProviderUsage(providerUsageTokens)) return {
+		count: Math.max(0, Math.trunc(providerUsageTokens)),
+		method: "provider_reported"
+	};
+	if (isQwenEmbedding(config)) return {
+		count: (await getQwenTokenizer(config.model ?? LOCAL_EMBEDDING_MODEL)).encode(text, { add_special_tokens: false }).length,
+		method: "qwen_tokenizer"
+	};
+	return {
+		count: charApproximation(text),
+		method: "char_approximation"
+	};
+}
+async function countManyEmbeddingTokens(values, config) {
+	const counts = await Promise.all(values.map((value) => countEmbeddingTokens(value, config)));
+	return {
+		count: counts.reduce((sum, item) => sum + item.count, 0),
+		method: counts[0]?.method ?? "char_approximation"
+	};
+}
+function countTextTokens(text, model) {
+	if (model?.startsWith("gpt-") || model?.startsWith("text-") || /qwen/i.test(model ?? "")) return {
+		count: countWithTiktoken(text, model),
+		method: "tiktoken"
+	};
+	return {
+		count: charApproximation(text),
+		method: "char_approximation"
+	};
+}
+//#endregion
+export { countManyEmbeddingTokens as n, countTextTokens as r, countEmbeddingTokens as t };

package/dist/trace-1t1n_wUm.d.ts

@@ -0,0 +1,86 @@
+import { LogContext } from "@snoai/utils/logger";
+//#region src/engine/eval/trace.d.ts
+interface QaTrace {
+  context?: Readonly<LogContext>;
+  qaId?: string | undefined;
+  query: string;
+  retrievedChunkIds: string[];
+  retrievedParentMemoryIds: string[];
+  denseScores?: number[] | undefined;
+  bm25Scores?: number[] | undefined;
+  fusedScores?: number[] | undefined;
+  rerankScores?: number[] | undefined;
+  mmrScores?: number[] | undefined;
+  finalMemoryScores: number[];
+  embedderProvider: string;
+  embedderModel: string;
+  embedderDim: number;
+  chunkingVersion: string;
+  configHash: string;
+  timestampMs: number;
+  latencyMs?: number | undefined;
+  /**
+   * Diagnostic side-channel for partial-population stages (PRD §4 trace
+   * population rule + F4 host finding). When a per-stage score array is
+   * incomplete (some results have the value, others don't), the array is
+   * omitted from the top-level fields and the missing-result chunk ids are
+   * recorded here so post-deploy debugging can see which chunk failed which
+   * stage rather than losing all of N scores silently.
+   */
+  traceMetadata?: {
+    omittedScoreArrays?: Record<string, string[]>;
+  };
+  /**
+   * What each retrieval stage received and what survived it, in pipeline order.
+   *
+   * The score arrays above describe only the SURVIVORS, so a memory removed part-way
+   * through leaves no record at all — which is why a wrong answer could never be attributed
+   * to the stage that dropped its evidence. `droppedIds` is the field that closes that.
+   * `skipped` names the config key that turned a stage off, because a disabled stage and a
+   * stage that ran and changed nothing are otherwise identical from outside.
+   */
+  stages?: {
+    name: string;
+    inputCount: number;
+    outputCount: number;
+    droppedIds: string[];
+    outputIds: string[];
+    scoreRange: [number, number] | null;
+    durationMs: number;
+    skipped?: string;
+  }[];
+}
+/**
+ * Returns true when the eval-trace surface should write. Reads the env var at
+ * call time so harness-flipped values take effect without a re-import.
+ */
+declare function isTraceEnabled(): boolean;
+/**
+ * Resolves the active trace directory. Prefers `EVAL_TRACE_DIR` env var; falls
+ * back to the explicit override argument. Returns undefined when neither is
+ * set; callers treat that as "no trace this run".
+ */
+declare function resolveTraceDir(override?: string): string | undefined;
+/**
+ * Append one trace row to `qa_traces.jsonl`. No-op when tracing is disabled
+ * or no `traceDir` is resolvable. Failures are logged but do not throw;
+ * eval traces are diagnostic, not load-bearing.
+ */
+declare function appendQaTrace(trace: QaTrace, traceDirOverride?: string): void;
+/**
+ * Composes the active retrieval-pipeline tunables snapshot. Returned object
+ * has alphabetically-sorted keys so the resulting JSON is stable across
+ * repeat calls, which is required for the SHA-256 fingerprint.
+ */
+declare function buildConfigSnapshot(): Record<string, unknown>;
+/**
+ * Writes `config-snapshot.json` to `traceDir` and returns the SHA-256 hex
+ * digest of its content for join with `config_hash` in `qa_traces.jsonl`.
+ * Idempotent; overwrites on each call. Throws on filesystem failure because
+ * a missing snapshot invalidates the eval run per PRD §11.2.1.
+ */
+declare function writeConfigSnapshot(traceDir: string): string;
+/** Computes the SHA-256 hex digest of the current config snapshot in-memory. */
+declare function computeConfigHash(): string;
+//#endregion
+export { isTraceEnabled as a, computeConfigHash as i, appendQaTrace as n, resolveTraceDir as o, buildConfigSnapshot as r, writeConfigSnapshot as s, QaTrace as t };