@snoai/memory 0.0.0-stage → 1.0.1

package/dist/reflection-command-hooks-ClUl-iv6.js

@@ -0,0 +1,644 @@
+import { _t as FIXED_PROTOCOL_VALUE_78 } from "./signed-registry-constants-yq3DlG3B.js";
+import { a as buildInsightMetadata, c as stringifyInsightMetadata } from "./memory-metadata-codec-DL1sbJiN.js";
+import { redactSecrets } from "./internal/engine/security/redact.js";
+import { t as checkMemoryOperation } from "./operation-cancellation-CTKWwNHk.js";
+import { setLruEntry } from "./internal/engine/shared/lru.js";
+import { i as createLlmClient } from "./llm-client-BSYUAcUb.js";
+import { pickLlmRoutingConfig } from "./internal/model/llm-mode-routing.js";
+import { appendSelfImprovementEntry } from "./internal/engine/operations/learning-file-maintenance.js";
+import { getSnoStationMemDataDir } from "./internal/store/data-paths.js";
+import { resolveHookAgentId } from "./internal/engine/bindings/sno-station-mem-runtime-mode.js";
+import { n as createRetireByNameRunBudget, r as runProfileSectionUpdate } from "./profile-section-writer-BhGKPBjw.js";
+import { a as generateReflectionText, c as shouldSkipReflectionMessage, l as writeReflectionToFilesystem, s as readSessionConversationWithResetFallback, u as extractTextContent } from "./daily-log-generator-CH_KuWHs.js";
+import { a as resolveWorkspaceDirFromEvent, f as setReflectionDerivedCacheEntry, l as isSessionBoundaryReflectionAction, n as createReflectionGenerator, o as DEFAULT_REFLECTION_BOUNDARY_DERIVED_SUPPRESSION_MS, t as DEFAULT_MEMORY_LLM_CONFIG, u as setReflectionDerivedSuppression } from "./reflection-embedded-generator-BRvqV5N-.js";
+import { i as buildReflectionMappedMetadata, n as createReflectionEventId, o as extractInjectableReflectionMappedMemoryItems, r as buildReflectionAntiPatternSignature, s as extractReflectionLearningGovernanceCandidates, t as storeReflectionEntries } from "./memory-entry-projector-DHo8jH10.js";
+import { createLogger, currentLogContext, privateLogReference, withLogContext } from "@snoai/utils/logger";
+import { basename, join } from "node:path";
+import { getSnoProfileDir } from "@snoai/observability";
+import { createHash, randomUUID } from "node:crypto";
+//#region src/engine/reflection/reflection-mapped-memory-loop.ts
+const diagnosticLog$2 = createLogger("sno-station-mem:reflection-mapped-memory-loop");
+const MAX_MAPPED_ENTRIES = 100;
+const MAPPED_DEDUP_THRESHOLD = .95;
+/**
+* Cosine similarity. Falls back to the raw dot product when either operand
+* has zero norm — that is a degenerate, fail-open path so a model that
+* returns an all-zero vector cannot crash the batch dedup scan.
+*/
+function cosineSimilarity(a, b) {
+	const length = Math.min(a.length, b.length);
+	let dot = 0;
+	let normA = 0;
+	let normB = 0;
+	for (let i = 0; i < length; i += 1) {
+		const x = a[i] ?? 0;
+		const y = b[i] ?? 0;
+		dot += x * y;
+		normA += x * x;
+		normB += y * y;
+	}
+	if (normA === 0 || normB === 0) return dot;
+	return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+async function runMappedMemoryLoop(params) {
+	const { writerAgentId } = params;
+	const allMapped = extractInjectableReflectionMappedMemoryItems(params.reflectionText);
+	const seen = /* @__PURE__ */ new Map();
+	for (const m of allMapped) {
+		const k = JSON.stringify([
+			m.category,
+			m.heading,
+			m.text
+		]);
+		if (!seen.has(k)) seen.set(k, m);
+	}
+	const deduped = [...seen.values()];
+	if (deduped.length < allMapped.length) diagnosticLog$2.info("Reflection duplicate input removed", {
+		input_count: allMapped.length,
+		output_count: deduped.length
+	}, {
+		event_name: "memory.reflection_mapped_memory_loop.reflection.duplicate.input.removed",
+		file: "packages/memory/src/engine/reflection/reflection-mapped-memory-loop.ts",
+		function: "runMappedMemoryLoop",
+		site_id: "reflection.reflection-mapped-memory-loop.runMappedMemoryLoop.d4cb1a8408"
+	});
+	if (deduped.length > MAX_MAPPED_ENTRIES) diagnosticLog$2.warn("Reflection input count limited", {
+		input_count: deduped.length,
+		limit: MAX_MAPPED_ENTRIES
+	}, {
+		event_name: "memory.reflection_mapped_memory_loop.reflection.input.count.limited",
+		file: "packages/memory/src/engine/reflection/reflection-mapped-memory-loop.ts",
+		function: "runMappedMemoryLoop",
+		site_id: "reflection.reflection-mapped-memory-loop.runMappedMemoryLoop.4f891b1d21"
+	});
+	const mapped = deduped.slice(0, MAX_MAPPED_ENTRIES);
+	if (mapped.length === 0) return;
+	const pending = [];
+	const pendingVectors = [];
+	const retireByNameBudget = createRetireByNameRunBudget();
+	for (const m of mapped) try {
+		const probeVector = await params.embedder.embed(m.text);
+		if ((await params.store.searchSemantic(probeVector, {
+			limit: 8,
+			minScore: .1,
+			projectIdFilter: [params.targetScope],
+			category: m.category
+		})).find((hit) => {
+			if (hit.score <= MAPPED_DEDUP_THRESHOLD) return false;
+			let hitKind;
+			try {
+				const meta = JSON.parse(hit.entry.metadata ?? "{}");
+				hitKind = typeof meta.mappedKind === "string" ? meta.mappedKind : void 0;
+			} catch {
+				hitKind = void 0;
+			}
+			if (hitKind !== void 0 && hitKind !== m.mappedKind) return false;
+			return true;
+		})) continue;
+		let skipped = false;
+		for (const prior of pendingVectors) {
+			if (prior.category !== m.category) continue;
+			if (prior.mappedKind !== m.mappedKind) continue;
+			const cosine = cosineSimilarity(probeVector, prior.vector);
+			if (cosine >= MAPPED_DEDUP_THRESHOLD) {
+				diagnosticLog$2.debug("Reflection duplicate candidate skipped", {
+					cosine,
+					category: m.category,
+					mapped_kind: m.mappedKind,
+					input_size: m.text.length
+				}, {
+					event_name: "memory.reflection_mapped_memory_loop.reflection.duplicate.candidate.skipped",
+					file: "packages/memory/src/engine/reflection/reflection-mapped-memory-loop.ts",
+					function: "runMappedMemoryLoop",
+					site_id: "reflection.reflection-mapped-memory-loop.runMappedMemoryLoop.78a7536d17"
+				});
+				skipped = true;
+				break;
+			}
+		}
+		if (skipped) continue;
+		const importance = m.mappedKind === "decision" ? .85 : .8;
+		const metadataPatch = {
+			...buildReflectionMappedMetadata({
+				mappedItem: m,
+				eventId: params.eventId,
+				agentId: params.sourceAgentId,
+				sessionKey: params.sessionKey,
+				sessionId: params.sessionId,
+				runAt: params.runAt,
+				usedFallback: params.usedFallback,
+				toolErrorSignals: params.toolErrorSignals
+			}),
+			...writerAgentId ? { writer_agent_id: writerAgentId } : {},
+			_reflectionHeading: m.heading
+		};
+		if (m.category === "profile") {
+			await runProfileSectionUpdate({
+				scope: params.targetScope,
+				sectionName: "preferences.general",
+				newAssertion: m.text,
+				evidence: m.text,
+				source: {
+					sessionKey: params.sessionKey,
+					source: "reflection",
+					agentId: writerAgentId
+				},
+				metadataPatch,
+				store: params.store,
+				llm: params.llm,
+				...params.routing ? { routing: params.routing } : {},
+				at: params.runAt,
+				retireByNameBudget
+			});
+			pendingVectors.push({
+				vector: probeVector,
+				category: m.category,
+				mappedKind: m.mappedKind
+			});
+			continue;
+		}
+		const metadata = buildInsightMetadata({
+			text: m.text,
+			category: m.category,
+			timestamp: params.runAt
+		}, {
+			...metadataPatch,
+			...m.category === "lesson" ? { anti_pattern_signature: buildReflectionAntiPatternSignature(m.mappedKind, m.text) } : {}
+		});
+		pending.push({
+			entry: {
+				text: m.text,
+				category: m.category,
+				offlineFamily: true,
+				projectId: params.targetScope,
+				importance,
+				metadata: stringifyInsightMetadata(metadata),
+				timestamp: params.runAt
+			},
+			vector: probeVector,
+			category: m.category,
+			mappedKind: m.mappedKind
+		});
+		pendingVectors.push({
+			vector: probeVector,
+			category: m.category,
+			mappedKind: m.mappedKind
+		});
+	} catch (err) {
+		diagnosticLog$2.warn("Reflection candidate failed", { error: err }, {
+			event_name: "memory.reflection_mapped_memory_loop.reflection.candidate.failed",
+			file: "packages/memory/src/engine/reflection/reflection-mapped-memory-loop.ts",
+			function: "runMappedMemoryLoop",
+			site_id: "reflection.reflection-mapped-memory-loop.runMappedMemoryLoop.38fe983443"
+		});
+	}
+	if (pending.length === 0) return;
+	const entries = pending.map((p) => p.entry);
+	try {
+		await params.store.bulkStore(entries);
+	} catch (err) {
+		diagnosticLog$2.warn("Reflection batch write failed", {
+			error: err,
+			input_count: entries.length,
+			committed_count: 0
+		}, {
+			event_name: "memory.reflection_mapped_memory_loop.reflection.batch.write.failed",
+			file: "packages/memory/src/engine/reflection/reflection-mapped-memory-loop.ts",
+			function: "runMappedMemoryLoop",
+			site_id: "reflection.reflection-mapped-memory-loop.runMappedMemoryLoop.b692a46de7"
+		});
+	}
+}
+function governanceEntryType(area) {
+	const a = area?.trim().toLowerCase() ?? "";
+	if (a === "error" || a === "errors" || a.includes("err")) return "error";
+	if (a === "feature" || a === "features" || a.includes("feat")) return "feature";
+	return "learning";
+}
+//#endregion
+//#region src/engine/reflection/session-serial-guard.ts
+/** @file session-serial-guard.ts
+* @purpose Serializes reflection runs per session via in-flight lock + post-completion debounce.
+* @boundary Reflection hook entry - called once per command:new / command:reset.
+* @see strategy-hook-runner.ts.
+*/
+const diagnosticLog$1 = createLogger("sno-station-mem:session-serial-guard");
+/**
+* Serial guard for reflection.
+*
+* Two distinct protections:
+*   (1) In-flight lock - boolean, no time bound, blocks parallel re-entry.
+*   (2) Post-completion debounce - 30s window after the previous run completed.
+*
+* State lives on `globalThis` via Symbol keys so the guard survives across
+* module reloads and is shared across plugin instances within a process.
+* On process crash both maps die with the process; no permanent lock risk.
+*
+* The single source of truth is `runWithSerialGuard`. Production code never
+* touches the in-flight Set or debounce Map directly.
+*/
+const REFLECTION_INFLIGHT = Symbol.for("sno-station-mem.reflection-inflight");
+const REFLECTION_DEBOUNCE = Symbol.for("sno-station-mem.reflection-debounce");
+/**
+* Backstop cap on the debounce Map size. The primary leak mitigation is the
+* TTL sweep (any stamp older than `SERIAL_WINDOW_MS` is dead and removed on
+* every insert). This cap only takes effect in the pathological case where
+* more than `MAX_DEBOUNCE_ENTRIES` distinct sessions complete within a single
+* 30s window — a regime the gateway is not expected to sustain. Sized at 1000
+* so that under realistic fan-out the TTL sweep keeps the Map well under the
+* cap and no still-active stamp gets evicted prematurely.
+*/
+const MAX_DEBOUNCE_ENTRIES = 1e3;
+/** Returns the in-flight Set, lazily creating it on first access. */
+function getInflightSet() {
+	const g = globalThis;
+	if (!(g[REFLECTION_INFLIGHT] instanceof Set)) g[REFLECTION_INFLIGHT] = /* @__PURE__ */ new Set();
+	return g[REFLECTION_INFLIGHT];
+}
+/** Returns the debounce Map, lazily creating it on first access. */
+function getDebounceMap() {
+	const g = globalThis;
+	if (!(g[REFLECTION_DEBOUNCE] instanceof Map)) g[REFLECTION_DEBOUNCE] = /* @__PURE__ */ new Map();
+	return g[REFLECTION_DEBOUNCE];
+}
+/**
+* Drops debounce stamps that have aged past `SERIAL_WINDOW_MS`. Such stamps
+* cannot gate any future call (the `Date.now() - last < SERIAL_WINDOW_MS`
+* check returns false past the window) so removing them is semantically a
+* no-op while it bounds Map growth.
+*
+* Map iteration is insertion-order; we walk in order and stop at the first
+* non-expired entry, since `setLruEntry` re-inserts at the tail so older
+* timestamps are always near the head.
+*/
+function pruneExpiredDebounceStamps(map, now) {
+	for (const [key, stamp] of map) {
+		if (now - stamp < 3e4) return;
+		map.delete(key);
+	}
+}
+/**
+* Run `work` under the serial guard for the given session key.
+*
+* Returns `true` when `work` ran (even if `work` threw - callers must use
+* try/catch on the awaited result to observe the throw), `false` when the
+* call was skipped by either the in-flight lock or the debounce window.
+*
+* Invariants:
+* - The in-flight lock is acquired as the FIRST statement inside the try
+*   block so no synchronous code between acquire and try can leak it.
+* - The debounce stamp is set unconditionally in the finally block, even on
+*   throw. This prevents an early-failing reflection run from being retried
+*   in a tight loop.
+* - The in-flight lock is released unconditionally in the same finally.
+*
+* If `sessionKey` is falsy, the guard is bypassed and `work` runs
+* unconditionally - there is nothing to key the lock on.
+*/
+async function runWithSerialGuard(sessionKey, work, logger = { info: () => {} }) {
+	if (!sessionKey) {
+		await work();
+		return true;
+	}
+	if (getInflightSet().has(sessionKey)) {
+		diagnosticLog$1.info("Reflection command already running", {
+			outcome: "skipped",
+			reason_code: "already_in_flight",
+			session_reference: privateLogReference(sessionKey)
+		}, {
+			event_name: "memory.session_serial_guard.reflection.command.already.running",
+			file: "packages/memory/src/engine/reflection/session-serial-guard.ts",
+			function: "runWithSerialGuard",
+			site_id: "reflection.session-serial-guard.runWithSerialGuard.edb3193695"
+		});
+		return false;
+	}
+	const last = getDebounceMap().get(sessionKey);
+	if (last !== void 0 && Date.now() - last < 3e4) {
+		diagnosticLog$1.info("Reflection command delayed by debounce", {
+			outcome: "skipped",
+			reason_code: "debounced",
+			session_reference: privateLogReference(sessionKey)
+		}, {
+			event_name: "memory.session_serial_guard.reflection.command.delayed.by.debounce",
+			file: "packages/memory/src/engine/reflection/session-serial-guard.ts",
+			function: "runWithSerialGuard",
+			site_id: "reflection.session-serial-guard.runWithSerialGuard.2e95bc0994"
+		});
+		return false;
+	}
+	try {
+		getInflightSet().add(sessionKey);
+		await work();
+	} finally {
+		const now = Date.now();
+		const debounce = getDebounceMap();
+		pruneExpiredDebounceStamps(debounce, now);
+		setLruEntry(debounce, sessionKey, now, MAX_DEBOUNCE_ENTRIES);
+		getInflightSet().delete(sessionKey);
+	}
+	return true;
+}
+//#endregion
+//#region src/engine/reflection/reflection-command-hooks.ts
+/** @file reflection-command-hooks.ts
+* @purpose Registers command hooks that write reflection logs and memories.
+*/
+const diagnosticLog = createLogger("sno-station-mem:reflection-command-hooks");
+function createRunMemoryReflection(params) {
+	return async (event) => {
+		const sessionKey = typeof event.sessionKey === "string" ? event.sessionKey : "";
+		return withLogContext({
+			operation_id: currentLogContext().operation_id ?? randomUUID(),
+			session_reference: sessionKey
+		}, async () => {
+			const started = performance.now();
+			const diagnostics = {
+				outcome: "skipped",
+				reason: "no_session_input",
+				inputSize: 0,
+				modelMs: 0,
+				writeMs: 0,
+				persisted: 0,
+				replayed: 0,
+				unclassifiedWrites: 0,
+				rowIds: [],
+				fileWritten: false
+			};
+			const action = String(event.action ?? "unknown");
+			const isBoundary = isSessionBoundaryReflectionAction(action);
+			if (sessionKey && isBoundary) armDerivedSuppression(params, sessionKey, action);
+			try {
+				if (!await runWithSerialGuard(sessionKey, async () => {
+					const context = event.context ?? {};
+					const workspaceDir = resolveWorkspaceDirFromEvent(context);
+					const sessionEntry = context.previousSessionEntry ?? context.sessionEntry ?? {};
+					const currentSessionFile = typeof sessionEntry.sessionFile === "string" ? sessionEntry.sessionFile : void 0;
+					const conversation = currentSessionFile ? await readSessionConversationWithResetFallback(currentSessionFile, params.reflectionCfg.messageCount) : Array.isArray(context.messages) ? context.messages.flatMap((message) => {
+						if (!message || typeof message !== "object") return [];
+						const record = message;
+						const role = record.role;
+						const text = extractTextContent(record.content);
+						return (role === "user" || role === "assistant") && text && !shouldSkipReflectionMessage(role, text) ? [`${role}: ${redactSecrets(text)}`] : [];
+					}).join("\n") : null;
+					if (!conversation) return;
+					diagnostics.inputSize = conversation.length;
+					await runMemoryReflectionBody(params, event, conversation, workspaceDir, diagnostics);
+				}, params.logger)) diagnostics.reason = "serial_guard";
+			} catch (error) {
+				diagnostics.outcome = "failed";
+				diagnostics.reason = "command_failed";
+				throw error;
+			} finally {
+				if (sessionKey && isBoundary) armDerivedSuppression(params, sessionKey, action);
+				diagnosticLog[diagnostics.outcome === "failed" ? "error" : "info"]("Reflection command completed", {
+					outcome: diagnostics.outcome,
+					reason_code: diagnostics.reason,
+					duration_ms: performance.now() - started,
+					input_size: diagnostics.inputSize,
+					model_duration_ms: diagnostics.modelMs,
+					model_duration_reason: "reflection_generation_calls_only",
+					write_duration_ms: diagnostics.writeMs,
+					persisted_count: diagnostics.unclassifiedWrites > 0 ? "unavailable" : diagnostics.persisted,
+					known_created_count: diagnostics.persisted,
+					replayed_count: diagnostics.replayed,
+					unclassified_write_count: diagnostics.unclassifiedWrites,
+					write_duration_reason: "layered_store_calls_only",
+					persisted_reason: diagnostics.unclassifiedWrites > 0 ? "store_write_outcome_unavailable" : "store_reported_created",
+					row_ids: diagnostics.rowIds.slice(0, 128),
+					file_written: diagnostics.fileWritten,
+					reflection_event_reference: diagnostics.eventId ?? "unavailable",
+					mapped_persisted_count: "unavailable",
+					mapped_persisted_reason: "mapped_writer_does_not_return_durable_count",
+					store_reference: privateLogReference(params.deps.store.dbPath)
+				}, {
+					event_name: "memory.reflection.completed",
+					file: "packages/memory/src/engine/reflection/reflection-command-hooks.ts",
+					function: "createRunMemoryReflection",
+					site_id: "memory.reflection.command.completed"
+				});
+			}
+		});
+	};
+}
+function armDerivedSuppression(params, sessionKey, action) {
+	const key = params.derivedKey(sessionKey);
+	params.derivedCache.delete(key);
+	const now = Date.now();
+	setReflectionDerivedSuppression(params.derivedSuppressionCache, key, {
+		updatedAt: now,
+		until: now + DEFAULT_REFLECTION_BOUNDARY_DERIVED_SUPPRESSION_MS,
+		reason: action
+	});
+}
+async function runMemoryReflectionBody(params, event, conversation, workspaceDir, diagnostics) {
+	const sessionKey = typeof event.sessionKey === "string" ? event.sessionKey : "";
+	let reflectionCompleted = false;
+	try {
+		params.doPrune();
+		const sessionEntry = event.context.previousSessionEntry ?? event.context.sessionEntry ?? {};
+		const currentSessionId = typeof sessionEntry.sessionId === "string" ? sessionEntry.sessionId : "unknown";
+		const nowTs = typeof event.timestamp === "number" ? event.timestamp : event.timestamp instanceof Date ? event.timestamp.getTime() : Date.now();
+		const sourceAgentId = params.deps.parseAgentIdFromSessionKey(sessionKey) || "main";
+		const writerAgentId = resolveHookAgentId(event.context.agentId, sessionKey).agentId;
+		const command = String(event.action ?? "unknown");
+		const errorReminderMax = params.reflectionCfg.errorReminderMaxEntries;
+		const toolErrorSignals = sessionKey && errorReminderMax > 0 ? params.errorTracker.getState(sessionKey).entries.slice(-errorReminderMax) : [];
+		const generate = createReflectionGenerator(params.config.extraction.llm ?? DEFAULT_MEMORY_LLM_CONFIG, pickLlmRoutingConfig(params.config), params.deps.agentPort);
+		const reflectionResult = await generateReflectionText({
+			conversation,
+			maxInputChars: params.reflectionCfg.maxInputChars,
+			timeoutMs: params.reflectionCfg.timeoutMs,
+			toolErrorSignals,
+			generate: async (...args) => {
+				const started = performance.now();
+				try {
+					return await generate(...args);
+				} finally {
+					diagnostics.modelMs += performance.now() - started;
+				}
+			},
+			logger: params.logger
+		});
+		if (reflectionResult.usedFallback) diagnosticLog.warn("Reflection generation used fallback", {
+			outcome: "partial",
+			error: reflectionResult.error,
+			session_reference: privateLogReference(currentSessionId)
+		}, {
+			event_name: "memory.reflection_command_hooks.reflection.generation.used.fallback",
+			file: "packages/memory/src/engine/reflection/reflection-command-hooks.ts",
+			function: "runMemoryReflectionBody",
+			site_id: "reflection.reflection-command-hooks.runMemoryReflectionBody.be803e8310"
+		});
+		checkMemoryOperation();
+		const skinId = event.context.reflectionSkinId;
+		const reflectionDir = skinId === "codex" || skinId === "claude-code" || skinId === "hermes" ? join(getSnoProfileDir(), "memory", "projects", `${basename(workspaceDir)}-${createHash("sha256").update(workspaceDir).digest("hex").slice(0, 12)}`) : workspaceDir;
+		const relPath = await writeReflectionToFilesystem({
+			workspaceDir: reflectionDir,
+			reflectionText: reflectionResult.text,
+			sessionKey,
+			sessionId: currentSessionId,
+			agentId: sourceAgentId,
+			command,
+			toolErrorSignals,
+			nowTs
+		});
+		diagnostics.fileWritten = true;
+		await maybeStoreReflection({
+			...params,
+			reflectionText: reflectionResult.text,
+			usedFallback: reflectionResult.usedFallback,
+			sourceAgentId,
+			writerAgentId,
+			sessionKey,
+			sessionId: currentSessionId,
+			command,
+			toolErrorSignals,
+			nowTs
+		}, diagnostics);
+		reflectionCompleted = true;
+		diagnostics.outcome = reflectionResult.usedFallback ? "partial" : "success";
+		diagnostics.reason = reflectionResult.usedFallback ? "generation_fallback" : "completed";
+		diagnosticLog.info("Reflection file written", {
+			artifact_reference: privateLogReference(relPath),
+			session_reference: privateLogReference(currentSessionId)
+		}, {
+			event_name: "memory.reflection_command_hooks.reflection.file.written",
+			file: "packages/memory/src/engine/reflection/reflection-command-hooks.ts",
+			function: "runMemoryReflectionBody",
+			site_id: "reflection.reflection-command-hooks.runMemoryReflectionBody.2a047c8826"
+		});
+	} catch (err) {
+		checkMemoryOperation();
+		diagnostics.outcome = diagnostics.fileWritten || diagnostics.persisted > 0 ? "partial" : "failed";
+		diagnostics.reason = "reflection_failed";
+		diagnosticLog.warn("Reflection command failed", { error: err }, {
+			event_name: "memory.reflection_command_hooks.reflection.command.failed",
+			file: "packages/memory/src/engine/reflection/reflection-command-hooks.ts",
+			function: "runMemoryReflectionBody",
+			site_id: "reflection.reflection-command-hooks.runMemoryReflectionBody.55c5adf2a5"
+		});
+	} finally {
+		if (sessionKey && reflectionCompleted) params.errorTracker.clearSession(sessionKey);
+		params.doPrune();
+	}
+}
+async function maybeStoreReflection(params, diagnostics) {
+	if (!params.reflectionCfg.storeToDb || params.usedFallback) {
+		if (params.sessionKey && params.usedFallback) params.derivedCache.delete(`${params.sourceAgentId}::${params.sessionKey}`);
+		return;
+	}
+	const targetScope = params.deps.scopePolicy.getDefaultScope(params.sourceAgentId);
+	const eventId = createReflectionEventId({
+		runAt: params.nowTs,
+		sessionKey: params.sessionKey,
+		sessionId: params.sessionId,
+		agentId: params.sourceAgentId,
+		command: params.command
+	});
+	diagnostics.eventId = eventId;
+	try {
+		const llmCfg = params.config.extraction.llm ?? DEFAULT_MEMORY_LLM_CONFIG;
+		const mappedLlm = createLlmClient({
+			preset: llmCfg.preset,
+			...llmCfg.apiKey ? { apiKey: llmCfg.apiKey } : {},
+			...llmCfg.baseURL ? { baseURL: llmCfg.baseURL } : {},
+			timeoutMs: llmCfg.timeoutMs,
+			routing: pickLlmRoutingConfig(params.config),
+			...params.deps.agentPort ? { agentPort: params.deps.agentPort } : {}
+		});
+		const layered = await storeReflectionEntries({
+			reflectionText: params.reflectionText,
+			sessionKey: params.sessionKey,
+			sessionId: params.sessionId,
+			agentId: params.sourceAgentId,
+			writerAgentId: params.writerAgentId,
+			command: params.command,
+			scope: targetScope,
+			toolErrorSignals: params.toolErrorSignals,
+			runAt: params.nowTs,
+			usedFallback: params.usedFallback,
+			eventId,
+			writeLegacyCombined: false,
+			dedupeThreshold: .97,
+			embed: (text) => params.deps.embedder.embed(text),
+			searchSemantic: (vector, options) => params.deps.store.searchSemantic(vector, options),
+			store: async (entry) => {
+				const started = performance.now();
+				try {
+					const result = await params.deps.store.store({
+						...entry,
+						offlineFamily: true
+					});
+					if (result.storeWriteOutcome === "created") {
+						diagnostics.persisted += 1;
+						diagnostics.rowIds.push(result.id);
+					} else if (result.storeWriteOutcome === "existing") diagnostics.replayed += 1;
+					else diagnostics.unclassifiedWrites += 1;
+					return {
+						id: result.id,
+						factId: result.factId,
+						category: result.category,
+						projectId: result.projectId
+					};
+				} finally {
+					diagnostics.writeMs += performance.now() - started;
+				}
+			}
+		});
+		await runMappedMemoryLoop({
+			reflectionText: params.reflectionText,
+			store: params.deps.store,
+			embedder: params.deps.embedder,
+			llm: mappedLlm,
+			routing: pickLlmRoutingConfig(params.config),
+			targetScope,
+			sourceAgentId: params.sourceAgentId,
+			writerAgentId: params.writerAgentId,
+			sessionKey: params.sessionKey,
+			sessionId: params.sessionId,
+			runAt: params.nowTs,
+			usedFallback: params.usedFallback,
+			toolErrorSignals: params.toolErrorSignals,
+			eventId,
+			logger: params.logger
+		});
+		await appendGovernanceEntries(params, eventId);
+		if (params.sessionKey && layered.slices.derived.length > 0 && !isSessionBoundaryReflectionAction(params.command)) setReflectionDerivedCacheEntry(params.derivedCache, `${params.sourceAgentId}::${params.sessionKey}`, {
+			updatedAt: params.nowTs,
+			derived: layered.slices.derived,
+			derivedSources: layered.derivedSources
+		});
+	} finally {
+		if (params.sourceAgentId === "main") params.clearAllSliceCache();
+		else params.clearSliceCacheForAgent(params.sourceAgentId);
+	}
+}
+async function appendGovernanceEntries(params, eventId) {
+	const governance = extractReflectionLearningGovernanceCandidates(params.reflectionText);
+	if (governance.length === 0) return;
+	const baseDir = getSnoStationMemDataDir();
+	for (const entry of governance) try {
+		await appendSelfImprovementEntry({
+			baseDir,
+			type: governanceEntryType(entry.area),
+			summary: entry.summary,
+			details: entry.details ?? "",
+			suggestedAction: entry.suggestedAction ?? "",
+			...entry.area !== void 0 ? { area: entry.area } : {},
+			...entry.priority !== void 0 ? { priority: entry.priority } : {},
+			...entry.status !== void 0 ? { status: entry.status } : {},
+			source: `${FIXED_PROTOCOL_VALUE_78}${eventId}`
+		});
+	} catch (err) {
+		checkMemoryOperation();
+		diagnosticLog.warn("Reflection learning append failed", { error: err }, {
+			event_name: "memory.reflection_command_hooks.reflection.learning.append.failed",
+			file: "packages/memory/src/engine/reflection/reflection-command-hooks.ts",
+			function: "appendGovernanceEntries",
+			site_id: "reflection.reflection-command-hooks.appendGovernanceEntries.805fa046d0"
+		});
+	}
+}
+//#endregion
+export { createRunMemoryReflection as t };

package/dist/reflection-command-hooks-G1-dI2Av.d.ts

@@ -0,0 +1,32 @@
+import { t as PluginConfig } from "./plugin-config-schema-C0UUbOmG.js";
+import "./types-CWdhXLxr.js";
+import { n as createErrorSignalTracker } from "./error-signals-D8_3vYu4.js";
+import { n as ReflectionDerivedCache, t as ReflectionDerivedSuppressionCache } from "./derived-suppression-cache-CI0durYx.js";
+import { t as ReflectionDeps } from "./reflection-deps-Ccm2Jf5W.js";
+//#region src/engine/reflection/reflection-command-hooks.d.ts
+declare function createRunMemoryReflection(params: ReflectionCommandParams): (event: {
+  sessionKey: string;
+  context: Record<string, unknown>;
+  action?: string;
+  timestamp?: Date | number;
+}) => Promise<void>;
+type ReflectionCommandParams = {
+  logger: {
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    debug?(message: string): void;
+  };
+  config: PluginConfig;
+  reflectionCfg: PluginConfig["memoryReflection"];
+  deps: ReflectionDeps;
+  errorTracker: ReturnType<typeof createErrorSignalTracker>;
+  derivedCache: ReflectionDerivedCache;
+  derivedSuppressionCache: ReflectionDerivedSuppressionCache;
+  derivedKey: (sessionKey: string) => string;
+  doPrune: () => void;
+  clearSliceCacheForAgent: (agentId: string) => void;
+  clearAllSliceCache: () => void;
+};
+//#endregion
+export { createRunMemoryReflection as n, ReflectionCommandParams as t };