@snoai/memory 0.0.0-stage → 1.0.1

package/dist/internal/engine/bindings/sno-station-mem-message-transcript.js

@@ -0,0 +1,145 @@
+import { nt as FIXED_PROTOCOL_VALUE_63, wt as PERSISTED_PROVIDER_SYSTEM } from "../../../signed-registry-constants-yq3DlG3B.js";
+import { parseIsoDateTimeMs } from "../shared/iso-date-time.js";
+import { t as normalizeAmbientLearningText } from "../../../ambient-learning-text-normalizer-CxjATmMp.js";
+import { a as escapeTranscriptRoleContinuations } from "../../../atomic-memory-extraction-C5rmogoY.js";
+import "../../../sno-station-mem-runtime-dependencies-CoWqUMbK.js";
+import { sanitizeContentIngress } from "@snoai/content-sanitizer";
+import { Temporal } from "@js-temporal/polyfill";
+//#region src/engine/bindings/sno-station-mem-message-transcript.ts
+/** @file sno-station-mem-message-transcript.ts
+* @purpose Normalizes SDK message records into capture transcripts and session timestamps.
+* @boundary Message-shape parsing and redaction for transcript construction only.
+*/
+/** Collects text chunks from SDK messages while ignoring unsupported content parts. */
+function extractAllMessageTexts(record) {
+	if (typeof record.content === "string") return [record.content];
+	if (!Array.isArray(record.content)) return [];
+	const texts = [];
+	for (const chunk of record.content) {
+		if (!chunk || typeof chunk !== "object") continue;
+		const chunkRecord = chunk;
+		if (chunkRecord.type === "text" && typeof chunkRecord.text === "string") texts.push(chunkRecord.text);
+	}
+	return texts;
+}
+/**
+* Marks a message this plugin injected into the host agent as its OWN model request.
+*
+* `sourceChannel` is the host's own message-origin field — optional, free-form, and part of the
+* persisted transcript schema (`sno-station-mem/dist/transcript-*.d.ts`). It is what survives the gap
+* that matters: the host records our turn, and ambient learning reads the session LATER, from an
+* unrelated async chain and possibly a later process. Nothing scoped to the originating call, and
+* nothing held in memory, is still observable there.
+*
+* Verified against a real recorded row on the E2E host, 2026-08-30: a persisted message is
+* `{role, timestamp, sourceChannel, content}` — this field is carried, an unknown field has no
+* such guarantee.
+*
+* This excludes text THIS PLUGIN authored and nothing else. A message without this origin is
+* untouched, so no incoming user turn can be dropped by this path — including one whose wording
+* happens to match ours.
+*/
+const PLUGIN_OWNED_SOURCE_CHANNEL = FIXED_PROTOCOL_VALUE_63;
+/** Whether a raw SDK message is one this plugin injected as its own model request. */
+function isPluginOwnedMessage(message) {
+	if (!message || typeof message !== "object") return false;
+	return message.sourceChannel === PLUGIN_OWNED_SOURCE_CHANNEL;
+}
+/** Narrows raw SDK messages to user/assistant turns eligible for ambient-learning. */
+function isAmbientLearningMessage(message) {
+	if (!message || typeof message !== "object") return false;
+	if (isPluginOwnedMessage(message)) return false;
+	const role = message.role;
+	return role === "user" || role === "assistant";
+}
+/**
+* Normalizes message timestamp ms at the boundary before plugin lifecycle orchestration uses
+* it.
+*/
+function normalizeMessageTimestampMs(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value < 1e11 ? value * 1e3 : value;
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (!trimmed) return void 0;
+		const asNumber = Number(trimmed);
+		if (Number.isFinite(asNumber)) return normalizeMessageTimestampMs(asNumber);
+		return parseIsoDateTimeMs(trimmed);
+	}
+	if (value instanceof Date) {
+		const timestampMs = value.getTime();
+		return Number.isNaN(timestampMs) ? void 0 : timestampMs;
+	}
+}
+/**
+* Derive a session anchor from the most recent conversational message so the
+* insight distiller can resolve relative dates like "yesterday" or "last year".
+*/
+function deriveSessionDateTime(messages, captureAssistant = true) {
+	let latestTimestampMs = Number.NEGATIVE_INFINITY;
+	for (const message of messages) {
+		if (!isAmbientLearningMessage(message)) continue;
+		if (message.role === "assistant" && !captureAssistant) continue;
+		const timestampMs = normalizeMessageTimestampMs(message.timestamp);
+		if (timestampMs === void 0) continue;
+		latestTimestampMs = Math.max(latestTimestampMs, timestampMs);
+	}
+	if (!Number.isFinite(latestTimestampMs)) return;
+	const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+	return Temporal.Instant.fromEpochMilliseconds(latestTimestampMs).toZonedDateTimeISO(timezone).toString({
+		smallestUnit: "millisecond",
+		timeZoneName: "never"
+	});
+}
+const TRANSCRIPT_SESSION_DATE_HEADER = /^session_date_time:[ \t]*(\S[^\n]*)$/m;
+/**
+* The session date a transcript states about itself. A replayed or imported log carries the date
+* it was actually spoken on; the gateway's message timestamps only say when it was replayed, and
+* anchoring "yesterday" to the replay day files every relative date years off. An ISO
+* `session_date_time:` line in a user message therefore outranks the message timestamps; a
+* header that does not parse as ISO is ignored, not guessed at.
+*/
+function transcriptSessionDateTime(messages) {
+	for (const message of messages) {
+		if (!isAmbientLearningMessage(message) || message.role !== "user") continue;
+		for (const text of extractAllMessageTexts(message)) {
+			const header = TRANSCRIPT_SESSION_DATE_HEADER.exec(text)?.[1];
+			if (header === void 0) continue;
+			const timestampMs = parseIsoDateTimeMs(header.trim());
+			if (timestampMs === void 0) return void 0;
+			const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+			return Temporal.Instant.fromEpochMilliseconds(timestampMs).toZonedDateTimeISO(timezone).toString({
+				smallestUnit: "millisecond",
+				timeZoneName: "never"
+			});
+		}
+	}
+}
+/** Builds the chronological transcript used by session summary and capture logic. */
+function buildConversationText(messages, captureAssistant) {
+	const lines = [];
+	let latestUserMemorySourceText;
+	for (const message of messages) {
+		if (!isAmbientLearningMessage(message)) continue;
+		if (message.role === "assistant" && !captureAssistant) continue;
+		const texts = extractAllMessageTexts(message);
+		const userChunks = [];
+		for (const text of texts) {
+			const normalized = normalizeAmbientLearningText(message.role, text);
+			if (!normalized) continue;
+			const sanitized = sanitizeContentIngress({
+				source: PERSISTED_PROVIDER_SYSTEM,
+				content: normalized
+			}).projections.plainText;
+			if (!sanitized) continue;
+			if (message.role === "user") userChunks.push(sanitized);
+			lines.push(`${message.role}: ${escapeTranscriptRoleContinuations(sanitized)}`);
+		}
+		if (message.role === "user" && userChunks.length > 0) latestUserMemorySourceText = userChunks.join("\n");
+	}
+	return {
+		text: lines.join("\n\n"),
+		latestUserMemorySourceText
+	};
+}
+//#endregion
+export { PLUGIN_OWNED_SOURCE_CHANNEL, buildConversationText, deriveSessionDateTime, extractAllMessageTexts, isAmbientLearningMessage, isPluginOwnedMessage, normalizeMessageTimestampMs, transcriptSessionDateTime };

package/dist/internal/engine/bindings/sno-station-mem-reset-hook.d.ts

@@ -0,0 +1,10 @@
+import { t as PluginConfig } from "../../../plugin-config-schema-C0UUbOmG.js";
+import { t as Embedder } from "../../../embedding-provider-client-vynZMuit.js";
+import { C as MemoryStore } from "../../../memory-store-base-CQ_bHlYA.js";
+import { n as createScopePolicy } from "../../../memory-scope-policy-1gg5QlWZ.js";
+import { PluginHookAgentContext, PluginHookBeforeResetEvent } from "./sno-station-mem-hook-types.js";
+import { t as SnoStationMemPluginApi } from "../../../sno-station-mem-runtime-dependencies-DHESIuPn.js";
+//#region src/engine/bindings/sno-station-mem-reset-hook.d.ts
+/** Stores reset-time session context before the host discards conversation state. */
+export declare function onBeforeReset(_api: SnoStationMemPluginApi, _config: PluginConfig, _store: MemoryStore, _embedder: Embedder, _scopePolicy: ReturnType<typeof createScopePolicy>, recallHistory: Map<string, Map<string, number>>, turnCounter: Map<string, number>, _event: PluginHookBeforeResetEvent, ctx: PluginHookAgentContext, _stateDir: string): Promise<void>;
+//#endregion

package/dist/internal/engine/bindings/sno-station-mem-reset-hook.js

@@ -0,0 +1,9 @@
+import { clearSessionState, resolveRuntimeSessionId } from "./sno-station-mem-session-state.js";
+//#region src/engine/bindings/sno-station-mem-reset-hook.ts
+/** Stores reset-time session context before the host discards conversation state. */
+async function onBeforeReset(_api, _config, _store, _embedder, _scopePolicy, recallHistory, turnCounter, _event, ctx, _stateDir) {
+	const sessionId = resolveRuntimeSessionId(ctx);
+	clearSessionState(sessionId, recallHistory, turnCounter);
+}
+//#endregion
+export { onBeforeReset };

package/dist/internal/engine/bindings/sno-station-mem-runtime-mode.d.ts

@@ -0,0 +1,36 @@
+import { t as SnoStationMemPluginApi } from "../../../sno-station-mem-runtime-dependencies-DHESIuPn.js";
+//#region src/engine/bindings/sno-station-mem-runtime-mode.d.ts
+/** Detects completion bootstrap mode so plugin startup can expose only completion wiring. */
+export declare function isCompletionMode(): boolean;
+/** Detects gateway mode before starting host services that are not needed there. */
+export declare function isGatewayMode(): boolean;
+/**
+ * Extracts an agent id from supported session-key formats while ignoring system bypass ids.
+ */
+export declare function parseAgentIdFromSessionKey(sessionKey: string | undefined): string | undefined;
+export declare function runObserveLifecycleTask(label: string, logger: SnoStationMemPluginApi["logger"], timeoutMs: number, task: () => Promise<void>): Promise<void>;
+/**
+ * Detects pure-digit agentIds that almost always come from a chat_id / user-id
+ * extraction (e.g. Discord snowflake `657229412030480397`, Telegram numeric
+ * user_id `5108601505`). Treating these as agent identities triggers spurious
+ * recall lookups against ids that have no memory rows.
+ *
+ * Returns true only for non-empty strings that are exclusively ASCII digits.
+ * Empty/whitespace inputs are handled separately by `resolveHookAgentId`.
+ */
+export declare function isChatIdBasedAgentId(agentId: string | undefined): boolean;
+/**
+ * Resolve the agentId for hook-level filtering: prefer an explicit ctx.agentId,
+ * then fall back to parsing the sessionKey. Callers supply defaults when no identity is found.
+ */
+export type HookAgentResolutionSource = "explicit" | "sessionKey" | "missing";
+/**
+ * Derives the effective hook agent id with explicit then session-key ordering.
+ */
+export declare function resolveHookAgentId(explicitAgentId: unknown, sessionKey: unknown): {
+  agentId?: string;
+  source: HookAgentResolutionSource;
+};
+/** Emits a scoped audit breadcrumb when hook metadata is missing or unparseable. */
+export declare function auditMissingHookAgentIdentity(api: SnoStationMemPluginApi, hookName: "agent_end" | "before_prompt_build" | "before_reset", stateDir: string, event: "ambient_learning" | "auto_recall" | "session_summary"): void;
+//#endregion

package/dist/internal/engine/bindings/sno-station-mem-runtime-mode.js

@@ -0,0 +1,104 @@
+import { i as isSystemBypassId } from "../../../memory-scope-policy-DICSCURA.js";
+import { t as appendAuditEntry } from "../../../runtime-audit-log-BCeujlEp.js";
+import "../../../scopes-CSOn6zdd.js";
+import { createLogger } from "@snoai/utils/logger";
+//#region src/engine/bindings/sno-station-mem-runtime-mode.ts
+const diagnosticLog = createLogger("sno-station-mem:sno-station-mem-runtime-mode");
+/** Detects completion bootstrap mode so plugin startup can expose only completion wiring. */
+function isCompletionMode() {
+	return process.argv.slice(1, 4).includes("completion");
+}
+/** Detects gateway mode before starting host services that are not needed there. */
+function isGatewayMode() {
+	return process.argv.includes("gateway");
+}
+/**
+* Extracts an agent id from supported session-key formats while ignoring system bypass ids.
+*/
+function parseAgentIdFromSessionKey(sessionKey) {
+	const parts = (sessionKey ?? "").trim().split(":");
+	if (parts.length >= 2 && (parts[0] === "agent" || parts[0] === "session")) {
+		const agentId = parts[1]?.trim();
+		if (agentId && !isSystemBypassId(agentId)) return agentId;
+	}
+}
+async function runObserveLifecycleTask(label, logger, timeoutMs, task) {
+	let timeoutHandle;
+	const run = Promise.resolve().then(task);
+	run.catch(() => void 0);
+	try {
+		await Promise.race([run, new Promise((resolve) => {
+			timeoutHandle = setTimeout(() => {
+				diagnosticLog.warn("Memory observation task timed out", {
+					operation: label,
+					timeout_ms: timeoutMs
+				}, {
+					event_name: "memory.sno-station-mem_runtime_mode.memory.observation.task.timed.out",
+					file: "packages/memory/src/engine/bindings/sno-station-mem-runtime-mode.ts",
+					function: "runObserveLifecycleTask",
+					site_id: "plugin.sno-station-mem-runtime-mode.runObserveLifecycleTask.d1856ccb13"
+				});
+				resolve();
+			}, timeoutMs);
+			timeoutHandle.unref?.();
+		})]);
+	} finally {
+		if (timeoutHandle) clearTimeout(timeoutHandle);
+	}
+}
+/**
+* Detects pure-digit agentIds that almost always come from a chat_id / user-id
+* extraction (e.g. Discord snowflake `657229412030480397`, Telegram numeric
+* user_id `5108601505`). Treating these as agent identities triggers spurious
+* recall lookups against ids that have no memory rows.
+*
+* Returns true only for non-empty strings that are exclusively ASCII digits.
+* Empty/whitespace inputs are handled separately by `resolveHookAgentId`.
+*/
+function isChatIdBasedAgentId(agentId) {
+	if (typeof agentId !== "string") return false;
+	const trimmed = agentId.trim();
+	if (trimmed.length === 0) return false;
+	return /^\d+$/.test(trimmed);
+}
+/**
+* Derives the effective hook agent id with explicit then session-key ordering.
+*/
+function resolveHookAgentId(explicitAgentId, sessionKey) {
+	if (typeof explicitAgentId === "string" && explicitAgentId.trim()) {
+		const agentId = explicitAgentId.trim();
+		if (isSystemBypassId(agentId)) return { source: "missing" };
+		return {
+			agentId,
+			source: "explicit"
+		};
+	}
+	if (typeof sessionKey === "string") {
+		const parsed = parseAgentIdFromSessionKey(sessionKey);
+		if (parsed) return {
+			agentId: parsed,
+			source: "sessionKey"
+		};
+	}
+	return { source: "missing" };
+}
+/** Emits a scoped audit breadcrumb when hook metadata is missing or unparseable. */
+function auditMissingHookAgentIdentity(api, hookName, stateDir, event) {
+	diagnosticLog.warn("Memory hook lacks agent identity", {
+		operation: hookName,
+		reason_code: "missing_agent_identity"
+	}, {
+		event_name: "memory.sno-station-mem_runtime_mode.memory.hook.lacks.agent.identity",
+		file: "packages/memory/src/engine/bindings/sno-station-mem-runtime-mode.ts",
+		function: "auditMissingHookAgentIdentity",
+		site_id: "plugin.sno-station-mem-runtime-mode.auditMissingHookAgentIdentity.f06795892a"
+	});
+	appendAuditEntry(stateDir, {
+		event,
+		hook: hookName,
+		resultStatus: "skipped",
+		decision: "rejected_missing_agent_identity"
+	});
+}
+//#endregion
+export { auditMissingHookAgentIdentity, isChatIdBasedAgentId, isCompletionMode, isGatewayMode, parseAgentIdFromSessionKey, resolveHookAgentId, runObserveLifecycleTask };

package/dist/internal/engine/bindings/sno-station-mem-session-state.d.ts

@@ -0,0 +1,10 @@
+import { PluginHookAgentContext } from "./sno-station-mem-hook-types.js";
+//#region src/engine/bindings/sno-station-mem-session-state.d.ts
+/** Normalizes SDK session identifiers into the key used by local LRU state. */
+export declare function resolveRuntimeSessionId(ctx: PluginHookAgentContext): string;
+/** Returns only host-provided session identity for observability correlation. */
+export declare function resolveObserveRuntimeSessionId(ctx: PluginHookAgentContext): string | undefined;
+export declare function resolveObserveRuntimeSessionIds(ctx: PluginHookAgentContext): string[];
+/** Drops recall history and turn counters together when a session lifecycle ends. */
+export declare function clearSessionState(sessionId: string, recallHistory: Map<string, Map<string, number>>, turnCounter: Map<string, number>): void;
+//#endregion

package/dist/internal/engine/bindings/sno-station-mem-session-state.js

@@ -0,0 +1,27 @@
+//#region src/engine/bindings/sno-station-mem-session-state.ts
+/** Normalizes SDK session identifiers into the key used by local LRU state. */
+function resolveRuntimeSessionId(ctx) {
+	return (ctx.sessionKey?.trim() ? ctx.sessionKey : ctx.sessionId) ?? "default";
+}
+/** Returns only host-provided session identity for observability correlation. */
+function resolveObserveRuntimeSessionId(ctx) {
+	return resolveObserveRuntimeSessionIds(ctx)[0];
+}
+function resolveObserveRuntimeSessionIds(ctx) {
+	const runtimeSessionIds = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const value of [ctx.sessionId, ctx.sessionKey]) {
+		const normalized = value?.trim();
+		if (!normalized || seen.has(normalized)) continue;
+		seen.add(normalized);
+		runtimeSessionIds.push(normalized);
+	}
+	return runtimeSessionIds;
+}
+/** Drops recall history and turn counters together when a session lifecycle ends. */
+function clearSessionState(sessionId, recallHistory, turnCounter) {
+	recallHistory.delete(sessionId);
+	turnCounter.delete(sessionId);
+}
+//#endregion
+export { clearSessionState, resolveObserveRuntimeSessionId, resolveObserveRuntimeSessionIds, resolveRuntimeSessionId };

package/dist/internal/engine/eval/trace.d.ts

@@ -0,0 +1,2 @@
+import { a as isTraceEnabled, i as computeConfigHash, n as appendQaTrace, o as resolveTraceDir, r as buildConfigSnapshot, s as writeConfigSnapshot, t as QaTrace } from "../../../trace-C1JxMfs-.js";
+export { QaTrace, appendQaTrace, buildConfigSnapshot, computeConfigHash, isTraceEnabled, resolveTraceDir, writeConfigSnapshot };

package/dist/internal/engine/eval/trace.js

@@ -0,0 +1,151 @@
+import { ADJACENCY_BONUS_CAP, ADJACENCY_BONUS_PER_PAIR, BONUS_TOTAL_INVARIANT, CHUNKING_VERSION, CHUNK_MAX_TOKENS, CHUNK_MIN_TOKENS, CHUNK_OVERLAP_TOKENS, CHUNK_TARGET_TOKENS, CHUNK_TOKENIZER_MODE, DEFAULT_BM25_WEIGHT, DEFAULT_VECTOR_WEIGHT, EMBEDDER_DIM, EMBEDDER_MODEL_DEFAULT, EMBEDDER_PROVIDER_DEFAULT, EVAL_CONFIG_SNAPSHOT_FILENAME, EVAL_QA_TRACES_FILENAME, HEAD_EXTRACT_MIN_CONTENT_TOKENS, HEAD_EXTRACT_OVERLAP_DROP_RATIO, HEAD_EXTRACT_TOKEN_BUDGET, INTRA_MEMORY_COSINE_THRESHOLD, LIGHTWEIGHT_COSINE_WEIGHT, LIGHTWEIGHT_FUSION_WEIGHT, LIGHTWEIGHT_RERANK_PENALTY, MMR_LAMBDA, MULTI_HIT_BONUS_CAP, MULTI_HIT_BONUS_PER_HIT } from "../../config/index.js";
+import { createLogger, currentLogContext, privateLogReference, withLogContext } from "@snoai/utils/logger";
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { appendFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+//#region src/engine/eval/trace.ts
+/** @file trace.ts
+* @purpose Emits per-QA retrieval traces and the active config snapshot for eval runs.
+* @boundary Filesystem (JSONL/JSON write) and config constants surface.
+* @see ../retrieval/retriever.ts, ../../config/index.ts.
+*
+* Minimum-viable trace emission. Off by default; enabled by the
+* eval harness via `EVAL_TRACE_ENABLED=true` (env or build constant) and a
+* run-dir provided via `EVAL_TRACE_DIR` (env). Phase 0 instrumentation
+* (MRR/Recall, gold-rank, miss classification) remains explicitly waived.
+*/
+const log = createLogger("sno-station-mem:eval-trace");
+/**
+* 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.
+*/
+function isTraceEnabled() {
+	return process.env.EVAL_TRACE_ENABLED === "true" || false;
+}
+/**
+* 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".
+*/
+function resolveTraceDir(override) {
+	const envDir = process.env.EVAL_TRACE_DIR;
+	if (envDir && envDir.length > 0) return envDir;
+	if (override && override.length > 0) return override;
+}
+/**
+* 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.
+*/
+function appendQaTrace(trace, traceDirOverride) {
+	if (!isTraceEnabled()) return;
+	const traceDir = resolveTraceDir(traceDirOverride);
+	if (!traceDir) return;
+	try {
+		if (!existsSync(traceDir)) mkdirSync(traceDir, { recursive: true });
+		const filePath = path.join(traceDir, EVAL_QA_TRACES_FILENAME);
+		appendFileSync(filePath, `${JSON.stringify({
+			...trace,
+			context: currentLogContext()
+		})}\n`, "utf8");
+	} catch (err) {
+		log.warn("failed to append qa trace", { error: err }, {
+			event_name: "sno_station_mem.trace.failed.to.append.qa.trace",
+			file: "packages/memory/src/engine/eval/trace.ts",
+			function: "appendQaTrace",
+			site_id: "trace.appendQaTrace.164bcaddd4"
+		});
+	}
+}
+/**
+* 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.
+*/
+function buildConfigSnapshot() {
+	const raw = {
+		ADJACENCY_BONUS_CAP,
+		ADJACENCY_BONUS_PER_PAIR,
+		BONUS_TOTAL_INVARIANT,
+		CHUNK_MAX_TOKENS,
+		CHUNK_MIN_TOKENS,
+		CHUNK_OVERLAP_TOKENS,
+		CHUNK_TARGET_TOKENS,
+		CHUNK_TOKENIZER_MODE,
+		CHUNKING_VERSION,
+		DEFAULT_BM25_WEIGHT,
+		DEFAULT_HARD_MIN_SCORE: 0,
+		DEFAULT_MIN_SCORE: 0,
+		DEFAULT_TOP_K: 10,
+		DEFAULT_VECTOR_WEIGHT,
+		EMBEDDER_DIM,
+		EMBEDDER_MODEL_DEFAULT,
+		EMBEDDER_PROVIDER_DEFAULT,
+		HEAD_EXTRACT_MIN_CONTENT_TOKENS,
+		HEAD_EXTRACT_OVERLAP_DROP_RATIO,
+		HEAD_EXTRACT_TOKEN_BUDGET,
+		INTRA_MEMORY_COSINE_THRESHOLD,
+		LIGHTWEIGHT_COSINE_WEIGHT,
+		LIGHTWEIGHT_FUSION_WEIGHT,
+		LIGHTWEIGHT_RERANK_PENALTY,
+		MAX_CHUNKS_PER_PARENT: 16,
+		MMR_LAMBDA,
+		MULTI_HIT_BONUS_CAP,
+		MULTI_HIT_BONUS_PER_HIT,
+		SNIPPET_NEIGHBOR_AFTER: 2,
+		SNIPPET_NEIGHBOR_BEFORE: 2
+	};
+	const sorted = {};
+	for (const key of Object.keys(raw).sort()) sorted[key] = raw[key];
+	return sorted;
+}
+/**
+* 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.
+*/
+function writeConfigSnapshot(traceDir) {
+	return withLogContext({ operation_id: currentLogContext().operation_id ?? randomUUID() }, () => {
+		const started = performance.now();
+		let hash;
+		let filePath;
+		let outcome = "failed";
+		let failure;
+		try {
+			const snapshot = buildConfigSnapshot();
+			const json = JSON.stringify(snapshot, null, 2);
+			hash = sha256Hex(json);
+			if (!existsSync(traceDir)) mkdirSync(traceDir, { recursive: true });
+			filePath = path.join(traceDir, EVAL_CONFIG_SNAPSHOT_FILENAME);
+			writeFileSync(filePath, json, "utf8");
+			outcome = "success";
+			return hash;
+		} catch (error) {
+			failure = error;
+			throw error;
+		} finally {
+			log[outcome === "failed" ? "error" : "info"]("Configuration snapshot write completed", {
+				outcome,
+				error: failure,
+				config_hash: hash ?? "unavailable",
+				artifact_reference: privateLogReference(filePath ?? traceDir),
+				duration_ms: performance.now() - started
+			}, {
+				event_name: "memory.config.snapshot.completed",
+				file: "packages/memory/src/engine/eval/trace.ts",
+				function: "writeConfigSnapshot",
+				site_id: "trace.writeConfigSnapshot.completed"
+			});
+		}
+	});
+}
+/** Computes the SHA-256 hex digest of the current config snapshot in-memory. */
+function computeConfigHash() {
+	return sha256Hex(JSON.stringify(buildConfigSnapshot(), null, 2));
+}
+function sha256Hex(input) {
+	return createHash("sha256").update(input).digest("hex");
+}
+//#endregion
+export { appendQaTrace, buildConfigSnapshot, computeConfigHash, isTraceEnabled, resolveTraceDir, writeConfigSnapshot };

package/dist/internal/engine/extraction/ambient-learning-text-normalizer.d.ts

@@ -0,0 +1,2 @@
+import { n as stripAmbientLearningInjectedPrefix, t as normalizeAmbientLearningText } from "../../../ambient-learning-text-normalizer-_fH3LeuK.js";
+export { normalizeAmbientLearningText, stripAmbientLearningInjectedPrefix };

package/dist/internal/engine/extraction/ambient-learning-text-normalizer.js

@@ -0,0 +1,2 @@
+import { n as stripAmbientLearningInjectedPrefix, t as normalizeAmbientLearningText } from "../../../ambient-learning-text-normalizer-CxjATmMp.js";
+export { normalizeAmbientLearningText, stripAmbientLearningInjectedPrefix };

package/dist/internal/engine/extraction/atomic-memory-extraction.d.ts

@@ -0,0 +1,2 @@
+import { a as AtomicMemoryExtractionTransports, c as ClaimedSpan, d as createAtomicResplitTransport, f as createSignedAtomicMemoryExtractionTransports, i as AtomicMemoryExtractionResult, l as DocumentName, n as AtomicExtractPersistResult, o as AtomicRetirementVerdictTransport, p as runAtomicMemoryExtraction, r as AtomicInsightDistiller, s as ClaimedFact, t as AtomicExtractPersistOptions, u as RunAtomicMemoryExtractionInput } from "../../../atomic-memory-extraction-d9EG-4ti.js";
+export { AtomicExtractPersistOptions, AtomicExtractPersistResult, AtomicInsightDistiller, AtomicMemoryExtractionResult, AtomicMemoryExtractionTransports, AtomicRetirementVerdictTransport, ClaimedFact, ClaimedSpan, DocumentName, RunAtomicMemoryExtractionInput, createAtomicResplitTransport, createSignedAtomicMemoryExtractionTransports, runAtomicMemoryExtraction };

package/dist/internal/engine/extraction/atomic-memory-extraction.js

@@ -0,0 +1,2 @@
+import { i as runAtomicMemoryExtraction, n as createAtomicResplitTransport, r as createSignedAtomicMemoryExtractionTransports, t as AtomicInsightDistiller } from "../../../atomic-memory-extraction-C5rmogoY.js";
+export { AtomicInsightDistiller, createAtomicResplitTransport, createSignedAtomicMemoryExtractionTransports, runAtomicMemoryExtraction };

package/dist/internal/engine/extraction/b-profile-section-dictionary-provider.d.ts

@@ -0,0 +1,2 @@
+import { a as computeSectionRegistryHash, c as loadSectionDictionary, i as bProfileSectionRegistrySchema, l as normalizeTopicToSectionName, n as SectionDictionaryCache, o as createSectionDictionaryCache, r as SectionDictionaryCacheState, s as getActiveSectionRegistry, t as LoadSectionDictionaryResult, u as restoreCachedSectionDictionary } from "../../../b-profile-section-dictionary-provider-BxbksLj3.js";
+export { LoadSectionDictionaryResult, SectionDictionaryCache, SectionDictionaryCacheState, bProfileSectionRegistrySchema, computeSectionRegistryHash, createSectionDictionaryCache, getActiveSectionRegistry, loadSectionDictionary, normalizeTopicToSectionName, restoreCachedSectionDictionary };

package/dist/internal/engine/extraction/b-profile-section-dictionary-provider.js

@@ -0,0 +1,2 @@
+import { a as loadSectionDictionary, i as getActiveSectionRegistry, n as computeSectionRegistryHash, o as normalizeTopicToSectionName, r as createSectionDictionaryCache, s as restoreCachedSectionDictionary, t as bProfileSectionRegistrySchema } from "../../../b-profile-section-dictionary-provider-BHkoNqgk.js";
+export { bProfileSectionRegistrySchema, computeSectionRegistryHash, createSectionDictionaryCache, getActiveSectionRegistry, loadSectionDictionary, normalizeTopicToSectionName, restoreCachedSectionDictionary };

package/dist/internal/engine/extraction/b-profile-section-rekey.d.ts

@@ -0,0 +1,49 @@
+import { g as ProductMode } from "../../../plugin-config-schema-C0UUbOmG.js";
+import { g as MemoryEntry } from "../../../types-CWdhXLxr.js";
+import { C as MemoryStore } from "../../../memory-store-base-CQ_bHlYA.js";
+import "../../../store-C8sUTssE.js";
+import { n as SectionDictionaryCache } from "../../../b-profile-section-dictionary-provider-BxbksLj3.js";
+//#region src/engine/extraction/b-profile-section-rekey.d.ts
+export declare const B_PROFILE_CANONICAL_FORM_REPAIR_VERSION = 1;
+export interface BProfileSectionRekeyReport {
+  sourceRows: number;
+  targetKeys: number;
+  collisions: number;
+  migrated: number;
+  merged: number;
+  rejected: number;
+  missingRawPhrase: number;
+  unchanged: number;
+  finalCount: number;
+  separatorSplitGroups: number;
+  domainPrefixSplitGroups: number;
+  crossPathSplitGroups: number;
+}
+export interface BProfileSectionRekeyResult {
+  dryRun: BProfileSectionRekeyReport;
+  applied: BProfileSectionRekeyReport;
+  skippedByVersion: boolean;
+}
+type PlannedAction = {
+  kind: "migrate" | "merge";
+  source: MemoryEntry;
+  targetFactKey: string;
+  newSection: string;
+};
+type RekeyPlan = {
+  report: BProfileSectionRekeyReport;
+  actions: PlannedAction[];
+  projectIdFilter: string[] | undefined;
+};
+export declare function runBProfileSectionRekey(args: {
+  store: MemoryStore;
+  cache: SectionDictionaryCache;
+  projectIdFilter?: string[];
+}): Promise<BProfileSectionRekeyResult>;
+export declare function scheduleBProfileSectionRekey(args: {
+  mode: ProductMode;
+  store: MemoryStore;
+  cache: SectionDictionaryCache;
+}): void;
+export declare function applyRekeyPlan(store: MemoryStore, plan: RekeyPlan): Promise<BProfileSectionRekeyReport>;
+//#endregion