@snoai/memory 0.0.0-stage → 1.0.1

package/dist/memory-entry-projector-DHo8jH10.js

@@ -0,0 +1,1015 @@
+import { a as buildInsightMetadata, c as stringifyInsightMetadata } from "./memory-metadata-codec-DL1sbJiN.js";
+import { n as RESOURCES_BY_LOCALE } from "./all-resources-BQK2ugjB.js";
+import { t as resolveLocale } from "./resolver-Dy-hnjCR.js";
+import { t as parseReflectionMetadata } from "./entry-metadata-parser-BIVSMCIk.js";
+import { createHash } from "node:crypto";
+import { sanitizeContentIngress } from "@snoai/content-sanitizer";
+//#region src/engine/reflection/reflection-entry-projector-types.ts
+const REFLECTION_DERIVE_LOGISTIC_K = 1.2;
+const REFLECTION_DERIVE_FALLBACK_BASE_WEIGHT = .35;
+const DEFAULT_REFLECTION_DERIVED_MAX_AGE_MS = 12096e5;
+//#endregion
+//#region src/engine/reflection/line-quality-ranker.ts
+/** @file line-quality-ranker.ts
+* @purpose Ranks reflection candidates by usefulness, severity, and recency signals.
+* @boundary Reflection metadata, cache state, and retrieval-style scoring rules.
+* @see daily-log-generator.ts, derived-line-cache.ts, entry-metadata-parser.ts.
+*/
+/**
+* Reflection relevance ranking — logistic decay scoring.
+*/
+const REFLECTION_FALLBACK_SCORE_FACTOR = .75;
+function finiteAtLeast(value, minimum, fallback) {
+	if (!Number.isFinite(value)) return fallback;
+	return Math.max(minimum, value);
+}
+function finitePositive(value, fallback) {
+	return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function clampUnit(value, fallback) {
+	if (!Number.isFinite(value)) return fallback;
+	return Math.max(0, Math.min(1, value));
+}
+/** Computes reflection logistic as a side-effect-free reflection result ranking value. */
+function computeReflectionLogistic(ageDays, midpointDays, k) {
+	const normalizedAgeDays = finiteAtLeast(ageDays, 0, 0);
+	const normalizedMidpointDays = finitePositive(midpointDays, 1);
+	const normalizedK = finitePositive(k, .1);
+	const distanceFromMidpoint = normalizedAgeDays - normalizedMidpointDays;
+	return 1 / (1 + Math.exp(normalizedK * distanceFromMidpoint));
+}
+/** Computes reflection score as a side-effect-free reflection result ranking value. */
+function computeReflectionScore(input) {
+	const recencyWeight = computeReflectionLogistic(input.ageDays, input.midpointDays, input.k);
+	const baseWeight = finitePositive(input.baseWeight, 1);
+	const qualityWeight = clampUnit(input.quality, 1);
+	const sourceReliability = input.usedFallback ? REFLECTION_FALLBACK_SCORE_FACTOR : 1;
+	return recencyWeight * baseWeight * qualityWeight * sourceReliability;
+}
+/**
+* Normalizes reflection line for aggregation at the boundary before reflection result ranking
+* uses it.
+*/
+function normalizeReflectionLineForAggregation(line) {
+	return String(line).trim().replace(/\s+/g, " ").toLowerCase();
+}
+//#endregion
+//#region src/engine/reflection/reflection-markdown-sections.ts
+/** @file reflection-markdown-sections.ts
+* @purpose Extracts named markdown sections and bullet lists from reflection payloads.
+* @boundary Raw markdown parsing only; no reflection-domain classification.
+*/
+/** Extracts section markdown from raw runtime payloads with partial-data tolerance. */
+function extractSectionMarkdown(markdown, heading) {
+	const lines = markdown.split(/\r?\n/);
+	const headingNeedle = `## ${heading}`.toLowerCase();
+	let inSection = false;
+	const collected = [];
+	for (const raw of lines) {
+		const lower = raw.trim().toLowerCase();
+		if (lower.startsWith("## ")) {
+			if (inSection && lower !== headingNeedle) break;
+			inSection = lower === headingNeedle;
+			continue;
+		}
+		if (!inSection) continue;
+		collected.push(raw);
+	}
+	return collected.join("\n").trim();
+}
+/** Parses section bullets into the normalized shape used by reflection text slicing. */
+function parseSectionBullets(markdown, heading) {
+	const lines = extractSectionMarkdown(markdown, heading).split(/\r?\n/);
+	const collected = [];
+	for (const raw of lines) {
+		const line = raw.trim();
+		if (line.startsWith("- ") || line.startsWith("* ")) {
+			const normalized = line.slice(2).trim();
+			if (normalized) collected.push(normalized);
+		}
+	}
+	return collected;
+}
+//#endregion
+//#region src/engine/reflection/reflection-markdown-types.ts
+const PARSER_HEADINGS = {
+	context: "Context",
+	decisionsDurable: "Decisions (durable)",
+	invariants: "Invariants",
+	invariantsAndReflections: "Invariants & Reflections",
+	derived: "Derived",
+	openLoops: "Open loops / next actions",
+	userModelDeltas: "User model deltas (about the human)",
+	agentModelDeltas: "Agent model deltas (about the assistant/system)",
+	lessonsAndPitfalls: "Lessons & pitfalls (symptom / cause / fix / prevention)",
+	learningGovernance: "Learning governance candidates (.learnings / promotion / skill extraction)"
+};
+//#endregion
+//#region src/engine/reflection/reflection-slice-sanitizer.ts
+/** @file reflection-slice-sanitizer.ts
+* @purpose Normalizes reflection slice lines and filters unsafe injectable text.
+* @boundary Line-level sanitization and injection detection only.
+*/
+/**
+* Tests whether is placeholder reflection slice line without mutating reflection text slicing
+* state.
+*/
+function isPlaceholderReflectionSliceLine(line) {
+	const normalized = line.replace(/\*\*/g, "").trim();
+	if (!normalized) return true;
+	if (/^\(none( captured)?\)$/i.test(normalized)) return true;
+	if (/^(invariants?|reflections?|derived)[:：]$/i.test(normalized)) return true;
+	if (/apply this session'?s deltas next run/i.test(normalized)) return true;
+	if (/apply this session'?s distilled changes next run/i.test(normalized)) return true;
+	if (/investigate why embedded reflection generation failed/i.test(normalized)) return true;
+	return false;
+}
+/** Normalizes reflection slice line at the boundary before reflection text slicing uses it. */
+function normalizeReflectionSliceLine(line) {
+	return sanitizeContentIngress({
+		source: "generic-text",
+		content: line
+	}).projections.plainText.replace(/\*\*/g, "").replace(/^(invariants?|reflections?|derived)[:：]\s*/i, "").trim();
+}
+/**
+* Implements sanitize reflection slice lines as the local reflection text slicing operation.
+*/
+function sanitizeReflectionSliceLines(lines) {
+	return lines.map(normalizeReflectionSliceLine).filter((line) => !isPlaceholderReflectionSliceLine(line));
+}
+const INJECTABLE_REFLECTION_BLOCK_PATTERNS = [
+	/^\s*(?:(?:next|this)(?:\s+run)?\s+)?(?:ignore|disregard|forget|override|bypass)\b[\s\S]{0,80}\b(?:instructions?|guardrails?|policy|developer|system)\b/i,
+	/\b(?:reveal|print|dump|show|output)\b[\s\S]{0,80}\b(?:system prompt|developer prompt|hidden prompt|hidden instructions?|full prompt|prompt verbatim|secrets?|keys?|tokens?)\b/i,
+	/<\s*\/?\s*(?:system|assistant|user|tool|developer|inherited-rules|derived-focus)\b[^>]*>/i,
+	/^(?:system|assistant|user|developer|tool)\s*:/i
+];
+function stripReflectionListPrefix(line) {
+	return line.replace(/^\s*(?:[-*•]+|\d+[.)])\s+/, "").trim();
+}
+/**
+* Tests whether is unsafe injectable reflection line without mutating reflection text slicing
+* state.
+*/
+function isUnsafeInjectableReflectionLine(line) {
+	const normalized = stripReflectionListPrefix(normalizeReflectionSliceLine(line));
+	if (!normalized) return true;
+	return INJECTABLE_REFLECTION_BLOCK_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+/**
+* Implements sanitize injectable reflection lines as the local reflection text slicing operation.
+*/
+function sanitizeInjectableReflectionLines(lines) {
+	return sanitizeReflectionSliceLines(lines).filter((line) => !isUnsafeInjectableReflectionLine(line));
+}
+//#endregion
+//#region src/engine/reflection/reflection-governance-parser.ts
+/** @file reflection-governance-parser.ts
+* @purpose Parses reflection lessons and learning-governance candidates.
+* @boundary Governance markdown extraction only; storage and promotion are out of scope.
+*/
+/**
+* Extracts reflection learning governance candidates from raw inputs while tolerating partial
+* data.
+*/
+function extractReflectionLearningGovernanceCandidates(reflectionText) {
+	const section = extractSectionMarkdown(reflectionText, PARSER_HEADINGS.learningGovernance);
+	if (!section) return [];
+	const parsed = section.split(/(?=^###\s+Entry(?![\p{L}\p{N}]))/gimu).map((block) => block.trim()).filter(Boolean).map(parseReflectionGovernanceEntry).filter((entry) => entry !== null);
+	if (parsed.length > 0) return parsed;
+	const fallbackBullets = sanitizeReflectionSliceLines(parseSectionBullets(reflectionText, PARSER_HEADINGS.learningGovernance));
+	if (fallbackBullets.length === 0) return [];
+	return [{
+		priority: "medium",
+		status: "pending",
+		area: "config",
+		summary: "Reflection learning governance candidates",
+		details: fallbackBullets.map((line) => `- ${line}`).join("\n"),
+		suggestedAction: "Review the governance candidates, promote durable rules to AGENTS.md / SOUL.md / TOOLS.md when stable, and extract a skill if the pattern becomes reusable."
+	}];
+}
+/**
+* Parses reflection governance entry into the normalized shape used by reflection text
+* slicing.
+*/
+function parseReflectionGovernanceEntry(block) {
+	const body = block.replace(/^###\s+Entry(?![\p{L}\p{N}])[^\n]*\n?/iu, "").trim();
+	if (!body) return null;
+	/** Reads field and applies reflection text slicing fallback behavior for missing data. */
+	const readField = (label) => {
+		const value = body.match(new RegExp(`^\\*\\*${label}\\*\\*:\\s*(.+)$`, "im"))?.[1]?.trim();
+		return value ? value : void 0;
+	};
+	/** Reads section and applies reflection text slicing fallback behavior for missing data. */
+	const readSection = (label) => {
+		const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		const value = body.match(new RegExp(`^###\\s+${escaped}\\s*\\n([\\s\\S]*?)(?=^###\\s+|$)`, "im"))?.[1]?.trim();
+		return value ? value : void 0;
+	};
+	const summary = readSection("Summary");
+	if (!summary) return null;
+	return {
+		priority: readField("Priority"),
+		status: readField("Status"),
+		area: readField("Area"),
+		summary,
+		details: readSection("Details"),
+		suggestedAction: readSection("Suggested Action")
+	};
+}
+//#endregion
+//#region src/engine/reflection/reflection-mapped-memory-parser.ts
+/** @file reflection-mapped-memory-parser.ts
+* @purpose Extracts mapped memory rows from reflection markdown sections.
+* @boundary Reflection markdown to mapped-memory DTOs only.
+*/
+/**
+* Extracts reflection mapped memory items with sanitizer from raw inputs while tolerating
+* partial data.
+*/
+function extractReflectionMappedMemoryItemsWithSanitizer(reflectionText, sanitizeLines) {
+	return [
+		{
+			heading: PARSER_HEADINGS.userModelDeltas,
+			category: "profile",
+			mappedKind: "user-model"
+		},
+		{
+			heading: PARSER_HEADINGS.agentModelDeltas,
+			category: "lesson",
+			mappedKind: "agent-model"
+		},
+		{
+			heading: PARSER_HEADINGS.lessonsAndPitfalls,
+			category: "lesson",
+			mappedKind: "lesson"
+		},
+		{
+			heading: PARSER_HEADINGS.decisionsDurable,
+			category: "episodic",
+			mappedKind: "decision"
+		}
+	].flatMap(({ heading, category, mappedKind }) => {
+		const lines = sanitizeLines(parseSectionBullets(reflectionText, heading));
+		const groupSize = lines.length;
+		return lines.map((text, ordinal) => ({
+			text,
+			category,
+			heading,
+			mappedKind,
+			ordinal,
+			groupSize
+		}));
+	});
+}
+/**
+* Extracts injectable reflection mapped memory items from raw inputs while tolerating partial
+* data.
+*/
+function extractInjectableReflectionMappedMemoryItems(reflectionText) {
+	return extractReflectionMappedMemoryItemsWithSanitizer(reflectionText, sanitizeInjectableReflectionLines);
+}
+//#endregion
+//#region src/engine/reflection/reflection-slice-extractor.ts
+/** @file reflection-slice-extractor.ts
+* @purpose Classifies reflection markdown into invariant and derived slice items.
+* @boundary Slice extraction only; mapped-memory parsing lives separately.
+*/
+/** Tests whether is invariant rule like without mutating reflection text slicing state. */
+function isInvariantRuleLike(line, classifiers) {
+	return classifiers.invariantSignals.some((pattern) => testPattern(pattern, line));
+}
+/** Tests whether is derived delta like without mutating reflection text slicing state. */
+function isDerivedDeltaLike(line, classifiers) {
+	return classifiers.derivedSignals.some((pattern) => testPattern(pattern, line));
+}
+/** Tests whether is open loop action without mutating reflection text slicing state. */
+function isOpenLoopAction(line, classifiers) {
+	return classifiers.openLoopSignals.some((pattern) => testPattern(pattern, line));
+}
+function testPattern(pattern, text) {
+	pattern.lastIndex = 0;
+	const matches = pattern.test(text);
+	pattern.lastIndex = 0;
+	return matches;
+}
+/**
+* Extracts reflection slices with sanitizer from raw runtime payloads with partial-data
+* tolerance.
+*/
+function extractReflectionSlicesWithSanitizer(reflectionText, sanitizeLines) {
+	const classifiers = RESOURCES_BY_LOCALE[resolveLocale({ text: reflectionText })].reflectionSliceClassifiers;
+	const invariantSection = parseSectionBullets(reflectionText, PARSER_HEADINGS.invariants);
+	const derivedSection = parseSectionBullets(reflectionText, PARSER_HEADINGS.derived);
+	const mergedSection = parseSectionBullets(reflectionText, PARSER_HEADINGS.invariantsAndReflections);
+	const invariantsPrimary = sanitizeLines(invariantSection);
+	const derivedPrimary = sanitizeLines(derivedSection);
+	const invariantLinesLegacy = sanitizeLines(mergedSection.filter((line) => classifiers.invariantLegacySignals.some((pattern) => testPattern(pattern, line)))).filter((line) => isInvariantRuleLike(line, classifiers));
+	const reflectionLinesLegacy = sanitizeLines(mergedSection.filter((line) => classifiers.derivedLegacySignals.some((pattern) => testPattern(pattern, line)))).filter((line) => isDerivedDeltaLike(line, classifiers));
+	const openLoopLines = sanitizeLines(parseSectionBullets(reflectionText, PARSER_HEADINGS.openLoops)).filter((line) => isOpenLoopAction(line, classifiers));
+	const durableDecisionLines = sanitizeLines(parseSectionBullets(reflectionText, PARSER_HEADINGS.decisionsDurable)).filter((line) => isInvariantRuleLike(line, classifiers));
+	const invariants = invariantsPrimary.length > 0 ? invariantsPrimary : invariantSection.length > 0 ? [] : invariantLinesLegacy.length > 0 ? invariantLinesLegacy : mergedSection.length > 0 ? [] : durableDecisionLines;
+	const derived = derivedPrimary.length > 0 ? derivedPrimary : [...reflectionLinesLegacy, ...openLoopLines];
+	return {
+		invariants: invariants.slice(0, 8),
+		derived: derived.slice(0, 10)
+	};
+}
+/** Extracts injectable reflection slices from raw inputs while tolerating partial data. */
+function extractInjectableReflectionSlices(reflectionText) {
+	return extractReflectionSlicesWithSanitizer(reflectionText, sanitizeInjectableReflectionLines);
+}
+/**
+* Assembles reflection slice items from slices from validated inputs for deterministic reflection
+* text slicing.
+*/
+function buildReflectionSliceItemsFromSlices(slices) {
+	const invariantGroupSize = slices.invariants.length;
+	const derivedGroupSize = slices.derived.length;
+	const invariantItems = slices.invariants.map((text, ordinal) => ({
+		text,
+		itemKind: "invariant",
+		section: "Invariants",
+		ordinal,
+		groupSize: invariantGroupSize
+	}));
+	const derivedItems = slices.derived.map((text, ordinal) => ({
+		text,
+		itemKind: "derived",
+		section: "Derived",
+		ordinal,
+		groupSize: derivedGroupSize
+	}));
+	return [...invariantItems, ...derivedItems];
+}
+/**
+* Extracts injectable reflection slice items from raw inputs while tolerating partial data.
+*/
+function extractInjectableReflectionSliceItems(reflectionText) {
+	return buildReflectionSliceItemsFromSlices(extractInjectableReflectionSlices(reflectionText));
+}
+const REFLECTION_ITEM_DECAY_DEFAULTS = {
+	invariant: {
+		midpointDays: 45,
+		k: .22,
+		baseWeight: 1.1,
+		quality: 1
+	},
+	derived: {
+		midpointDays: 7,
+		k: .65,
+		baseWeight: 1,
+		quality: .95
+	}
+};
+/**
+* Returns reflection item decay defaults from reflection item persistence state without side
+* effects.
+*/
+function getReflectionItemDecayDefaults(itemKind) {
+	return { ...REFLECTION_ITEM_DECAY_DEFAULTS[itemKind] };
+}
+function itemPayloadKind(itemKind) {
+	return itemKind === "invariant" ? "item-invariant" : "item-derived";
+}
+function itemPlansFromParams(params) {
+	const errorSignals = params.toolErrorSignals.map((signal) => signal.signatureHash);
+	return params.items.map((source) => ({
+		source,
+		payloadKind: itemPayloadKind(source.itemKind),
+		defaults: getReflectionItemDecayDefaults(source.itemKind),
+		errorSignals
+	}));
+}
+function metadataFromItemPlan(params, plan) {
+	const { source, defaults } = plan;
+	return {
+		type: "memory-reflection-item",
+		reflectionVersion: 4,
+		stage: "reflect-store",
+		eventId: params.eventId,
+		itemKind: source.itemKind,
+		section: source.section,
+		ordinal: source.ordinal,
+		groupSize: source.groupSize,
+		agentId: params.agentId,
+		sessionKey: params.sessionKey,
+		sessionId: params.sessionId,
+		storedAt: params.runAt,
+		usedFallback: params.usedFallback,
+		errorSignals: plan.errorSignals,
+		decayModel: "logistic",
+		decayMidpointDays: defaults.midpointDays,
+		decayK: defaults.k,
+		baseWeight: defaults.baseWeight,
+		quality: defaults.quality,
+		...params.sourceReflectionPath ? { sourceReflectionPath: params.sourceReflectionPath } : {}
+	};
+}
+/**
+* Assembles reflection item payloads from validated inputs for deterministic reflection item
+* persistence.
+*/
+function buildReflectionItemPayloads(params) {
+	return itemPlansFromParams(params).map((plan) => {
+		return {
+			kind: plan.payloadKind,
+			text: plan.source.text,
+			metadata: metadataFromItemPlan(params, plan)
+		};
+	});
+}
+//#endregion
+//#region src/engine/reflection/reflection-entry-utils.ts
+function isReflectionMetadataType(type) {
+	return type === "memory-reflection-item" || type === "memory-reflection";
+}
+function isOwnedByAgent(metadata, agentId) {
+	const owner = typeof metadata.agentId === "string" ? metadata.agentId.trim() : "";
+	const itemKind = metadata.itemKind;
+	if (itemKind === "derived") {
+		if (!owner) return agentId === "main";
+		return owner === agentId;
+	}
+	if (itemKind === void 0 || itemKind === "invariant") {
+		if (!owner) return agentId === "main";
+		return owner === agentId || owner === "main";
+	}
+	return false;
+}
+function toStringArray(value) {
+	if (!Array.isArray(value)) return [];
+	return value.map((item) => String(item).trim()).filter(Boolean);
+}
+function metadataTimestamp(metadata, fallbackTs) {
+	const storedAt = Number(metadata.storedAt);
+	if (Number.isFinite(storedAt) && storedAt > 0) return storedAt;
+	return Number.isFinite(fallbackTs) ? fallbackTs : Date.now();
+}
+function readPositiveNumber(value, fallback) {
+	const num = Number(value);
+	if (!Number.isFinite(num) || num <= 0) return fallback;
+	return num;
+}
+function readClampedNumber(value, fallback, min, max) {
+	const num = Number(value);
+	return Math.max(min, Math.min(max, Number.isFinite(num) ? num : fallback));
+}
+//#endregion
+//#region src/engine/reflection/reflection-line-loader.ts
+/** @file reflection-line-loader.ts
+* @purpose Load, score, and rank invariant and derived reflection lines.
+* @boundary Reads in-memory entries only; no persistence or I/O.
+*/
+function loadAgentReflectionSlicesFromEntries(params) {
+	const now = Number.isFinite(params.now) ? Number(params.now) : Date.now();
+	const deriveMaxAgeMs = Number.isFinite(params.deriveMaxAgeMs) ? Math.max(0, Number(params.deriveMaxAgeMs)) : DEFAULT_REFLECTION_DERIVED_MAX_AGE_MS;
+	const invariantMaxAgeMs = Number.isFinite(params.invariantMaxAgeMs) ? Math.max(0, Number(params.invariantMaxAgeMs)) : void 0;
+	const reflectionRows = params.entries.map((entry) => ({
+		entry,
+		metadata: parseReflectionMetadata(entry.metadata)
+	})).filter(({ metadata }) => isReflectionMetadataType(metadata.type) && isOwnedByAgent(metadata, params.agentId)).sort((a, b) => b.entry.timestamp - a.entry.timestamp).slice(0, 160);
+	const itemRows = reflectionRows.filter(({ metadata }) => metadata.type === "memory-reflection-item");
+	const legacyRows = reflectionRows.filter(({ metadata }) => metadata.type === "memory-reflection");
+	const unresolvedItemRows = itemRows.filter(({ metadata }) => metadata.resolvedAt === void 0);
+	const resolvedItemRows = itemRows.filter(({ metadata }) => metadata.resolvedAt !== void 0);
+	const hasItemRows = itemRows.length > 0;
+	const hasLegacyRows = legacyRows.length > 0;
+	const resolvedInvariantTexts = new Set(resolvedItemRows.filter(({ metadata }) => metadata.itemKind === "invariant").flatMap(({ entry }) => sanitizeInjectableReflectionLines([entry.text])).map((line) => normalizeReflectionLineForAggregation(line)));
+	const resolvedDerivedTexts = new Set(resolvedItemRows.filter(({ metadata }) => metadata.itemKind === "derived").flatMap(({ entry }) => sanitizeInjectableReflectionLines([entry.text])).map((line) => normalizeReflectionLineForAggregation(line)));
+	const legacyHasUniqueInvariant = legacyRows.some(({ metadata }) => sanitizeInjectableReflectionLines(toStringArray(metadata.invariants)).some((line) => !resolvedInvariantTexts.has(normalizeReflectionLineForAggregation(line))));
+	const legacyHasUniqueDerived = legacyRows.some(({ metadata }) => sanitizeInjectableReflectionLines(toStringArray(metadata.derived)).some((line) => !resolvedDerivedTexts.has(normalizeReflectionLineForAggregation(line))));
+	if (hasItemRows && unresolvedItemRows.length === 0 && (!hasLegacyRows || !legacyHasUniqueInvariant && !legacyHasUniqueDerived)) return {
+		invariants: [],
+		derived: [],
+		invariantSources: [],
+		derivedSources: []
+	};
+	const invariantLegacyRows = legacyRows.filter(({ metadata }) => {
+		const lines = sanitizeInjectableReflectionLines(toStringArray(metadata.invariants));
+		if (lines.length === 0) return false;
+		return lines.some((line) => !resolvedInvariantTexts.has(normalizeReflectionLineForAggregation(line)));
+	});
+	const derivedLegacyRows = legacyRows.filter(({ metadata }) => {
+		const lines = sanitizeInjectableReflectionLines(toStringArray(metadata.derived));
+		if (lines.length === 0) return false;
+		return lines.some((line) => !resolvedDerivedTexts.has(normalizeReflectionLineForAggregation(line)));
+	});
+	const invariantLines = rankReflectionLines(buildInvariantCandidates(unresolvedItemRows, invariantLegacyRows, resolvedInvariantTexts), {
+		now,
+		maxAgeMs: invariantMaxAgeMs,
+		limit: 8
+	});
+	const derivedLines = rankReflectionLines(buildDerivedCandidates(unresolvedItemRows, derivedLegacyRows, params.agentId, resolvedDerivedTexts), {
+		now,
+		maxAgeMs: deriveMaxAgeMs,
+		limit: 10
+	});
+	return {
+		invariants: invariantLines.lines,
+		derived: derivedLines.lines,
+		invariantSources: invariantLines.sources,
+		derivedSources: derivedLines.sources
+	};
+}
+function buildInvariantCandidates(itemRows, legacyRows, resolvedTexts) {
+	const itemCandidates = itemRows.filter(({ metadata }) => metadata.itemKind === "invariant").flatMap(({ entry, metadata }) => {
+		const safeLines = sanitizeInjectableReflectionLines([entry.text]);
+		if (safeLines.length === 0) return [];
+		const defaults = getReflectionItemDecayDefaults("invariant");
+		const timestamp = metadataTimestamp(metadata, entry.timestamp);
+		return safeLines.map((line) => ({
+			line,
+			timestamp,
+			midpointDays: readPositiveNumber(metadata.decayMidpointDays, defaults.midpointDays),
+			k: readPositiveNumber(metadata.decayK, defaults.k),
+			baseWeight: readPositiveNumber(metadata.baseWeight, defaults.baseWeight),
+			quality: readClampedNumber(metadata.quality, defaults.quality, .2, 1),
+			usedFallback: metadata.usedFallback === true,
+			source: buildReflectionLineSource(entry, line, metadata)
+		}));
+	});
+	if (itemCandidates.length > 0) return itemCandidates;
+	return legacyRows.flatMap(({ entry, metadata }) => {
+		const defaults = getReflectionItemDecayDefaults("invariant");
+		const timestamp = metadataTimestamp(metadata, entry.timestamp);
+		return sanitizeInjectableReflectionLines(toStringArray(metadata.invariants)).filter((line) => !resolvedTexts.has(normalizeReflectionLineForAggregation(line))).map((line) => ({
+			line,
+			timestamp,
+			midpointDays: defaults.midpointDays,
+			k: defaults.k,
+			baseWeight: defaults.baseWeight,
+			quality: defaults.quality,
+			usedFallback: metadata.usedFallback === true,
+			source: buildReflectionLineSource(entry, line, metadata)
+		}));
+	});
+}
+function buildDerivedCandidates(itemRows, legacyRows, queryingAgentId, resolvedTexts) {
+	const itemCandidates = itemRows.filter(({ metadata }) => metadata.itemKind === "derived").flatMap(({ entry, metadata }) => {
+		const safeLines = sanitizeInjectableReflectionLines([entry.text]);
+		if (safeLines.length === 0) return [];
+		const defaults = getReflectionItemDecayDefaults("derived");
+		const timestamp = metadataTimestamp(metadata, entry.timestamp);
+		return safeLines.map((line) => ({
+			line,
+			timestamp,
+			midpointDays: readPositiveNumber(metadata.decayMidpointDays, defaults.midpointDays),
+			k: readPositiveNumber(metadata.decayK, defaults.k),
+			baseWeight: readPositiveNumber(metadata.baseWeight, defaults.baseWeight),
+			quality: readClampedNumber(metadata.quality, defaults.quality, .2, 1),
+			usedFallback: metadata.usedFallback === true,
+			source: buildReflectionLineSource(entry, line, metadata)
+		}));
+	});
+	if (itemCandidates.length > 0) return itemCandidates;
+	return legacyRows.filter(({ metadata }) => {
+		if (sanitizeInjectableReflectionLines(toStringArray(metadata.derived)).length === 0) return true;
+		const owner = typeof metadata.agentId === "string" ? metadata.agentId.trim() : "";
+		return owner !== "" && owner === queryingAgentId;
+	}).flatMap(({ entry, metadata }) => {
+		const timestamp = metadataTimestamp(metadata, entry.timestamp);
+		const lines = sanitizeInjectableReflectionLines(toStringArray(metadata.derived));
+		if (lines.length === 0) return [];
+		const defaults = {
+			midpointDays: 3,
+			k: REFLECTION_DERIVE_LOGISTIC_K,
+			baseWeight: resolveLegacyDeriveBaseWeight(metadata),
+			quality: computeDerivedLineQuality(lines.length)
+		};
+		return lines.filter((line) => !resolvedTexts.has(normalizeReflectionLineForAggregation(line))).map((line) => ({
+			line,
+			timestamp,
+			midpointDays: readPositiveNumber(metadata.decayMidpointDays, defaults.midpointDays),
+			k: readPositiveNumber(metadata.decayK, defaults.k),
+			baseWeight: readPositiveNumber(metadata.deriveBaseWeight, defaults.baseWeight),
+			quality: readClampedNumber(metadata.deriveQuality, defaults.quality, .2, 1),
+			usedFallback: metadata.usedFallback === true,
+			source: buildReflectionLineSource(entry, line, metadata)
+		}));
+	});
+}
+function rankReflectionLines(candidates, options) {
+	const lineScores = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) {
+		const timestamp = Number.isFinite(candidate.timestamp) ? candidate.timestamp : options.now;
+		const maxAge = options.maxAgeMs;
+		if (maxAge !== void 0 && Number.isFinite(maxAge) && maxAge >= 0 && options.now - timestamp > maxAge) continue;
+		const score = computeReflectionScore({
+			ageDays: Math.max(0, (options.now - timestamp) / 864e5),
+			midpointDays: candidate.midpointDays,
+			k: candidate.k,
+			baseWeight: candidate.baseWeight,
+			quality: candidate.quality,
+			usedFallback: candidate.usedFallback
+		});
+		if (!Number.isFinite(score) || score <= 0) continue;
+		const key = normalizeReflectionLineForAggregation(candidate.line);
+		if (!key) continue;
+		const current = lineScores.get(key);
+		if (!current) {
+			lineScores.set(key, {
+				line: candidate.line,
+				score,
+				latestTs: timestamp,
+				source: candidate.source
+			});
+			continue;
+		}
+		current.score += score;
+		if (timestamp > current.latestTs) {
+			current.latestTs = timestamp;
+			current.line = candidate.line;
+			current.source = candidate.source;
+		}
+	}
+	const ranked = [...lineScores.values()].sort((a, b) => {
+		if (b.score !== a.score) return b.score - a.score;
+		if (b.latestTs !== a.latestTs) return b.latestTs - a.latestTs;
+		return a.line.localeCompare(b.line);
+	}).slice(0, options.limit);
+	return {
+		lines: ranked.map((item) => item.line),
+		sources: ranked.flatMap((item, index) => item.source ? [{
+			...item.source,
+			line: item.line,
+			rank: index + 1,
+			score: item.score
+		}] : [])
+	};
+}
+function buildReflectionLineSource(entry, line, metadata) {
+	if (!entry.factId) return void 0;
+	const sourceAgentId = typeof metadata.agentId === "string" && metadata.agentId.trim() ? metadata.agentId.trim() : "main";
+	return {
+		line,
+		rowId: entry.id,
+		factId: entry.factId,
+		sourceAgentId,
+		memoryKind: entry.category,
+		projectId: entry.projectId
+	};
+}
+function computeDerivedLineQuality(nonPlaceholderLineCount) {
+	const n = Number.isFinite(nonPlaceholderLineCount) ? Math.max(0, Math.floor(nonPlaceholderLineCount)) : 0;
+	if (n <= 0) return .2;
+	return Math.min(1, .55 + Math.min(6, n) * .075);
+}
+function resolveLegacyDeriveBaseWeight(metadata) {
+	const explicit = Number(metadata.deriveBaseWeight);
+	if (Number.isFinite(explicit) && explicit > 0) return Math.max(.1, Math.min(1.2, explicit));
+	if (metadata.usedFallback === true) return REFLECTION_DERIVE_FALLBACK_BASE_WEIGHT;
+	return 1;
+}
+//#endregion
+//#region src/engine/reflection/mapped-memory-metadata-builder.ts
+/** @file mapped-memory-metadata-builder.ts
+* @purpose Maps raw reflection metadata into typed fields used by ranking and storage.
+* @boundary Reflection extraction output and schema-compatible persistence.
+* @see entry-metadata-parser.ts, slice-item-payload-builder.ts, types.ts.
+*/
+/**
+* Reflection mapped metadata builder.
+*
+* Builds metadata for "mapped" reflection items (user-model, agent-model,
+* lesson, decision) with kind-specific decay defaults.
+*/
+const REFLECTION_MAPPED_DECAY_DEFAULTS = {
+	decision: {
+		midpointDays: 45,
+		k: .25,
+		baseWeight: 1.1,
+		quality: 1
+	},
+	"user-model": {
+		midpointDays: 21,
+		k: .3,
+		baseWeight: 1,
+		quality: .95
+	},
+	"agent-model": {
+		midpointDays: 10,
+		k: .35,
+		baseWeight: .95,
+		quality: .93
+	},
+	lesson: {
+		midpointDays: 7,
+		k: .45,
+		baseWeight: .9,
+		quality: .9
+	}
+};
+/**
+* Returns reflection mapped decay defaults from reflection metadata mapping state without side
+* effects.
+*/
+function getReflectionMappedDecayDefaults(kind) {
+	return { ...REFLECTION_MAPPED_DECAY_DEFAULTS[kind] };
+}
+function buildReflectionAntiPatternSignature(kind, text) {
+	const normalized = text.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim().replace(/\s+/g, " ");
+	return `reflection:${kind}:${createHash("sha256").update(`${kind}\0${normalized}`).digest("hex").slice(0, 20)}`;
+}
+function mappedSessionFields(params) {
+	return {
+		agentId: params.agentId,
+		sessionKey: params.sessionKey,
+		sessionId: params.sessionId,
+		storedAt: params.runAt,
+		usedFallback: params.usedFallback
+	};
+}
+function mappedItemFields(item) {
+	return {
+		mappedKind: item.mappedKind,
+		mappedCategory: item.category,
+		section: item.heading,
+		ordinal: item.ordinal,
+		groupSize: item.groupSize
+	};
+}
+function mappedDecayFields(defaults) {
+	return {
+		decayModel: "logistic",
+		decayMidpointDays: defaults.midpointDays,
+		decayK: defaults.k,
+		baseWeight: defaults.baseWeight,
+		quality: defaults.quality
+	};
+}
+/**
+* Assembles reflection mapped metadata from validated inputs for deterministic reflection
+* metadata mapping.
+*/
+function buildReflectionMappedMetadata(params) {
+	const defaults = getReflectionMappedDecayDefaults(params.mappedItem.mappedKind);
+	const sessionFields = mappedSessionFields(params);
+	return {
+		type: "memory-reflection-mapped",
+		reflectionVersion: 4,
+		stage: "reflect-store",
+		eventId: params.eventId,
+		...mappedItemFields(params.mappedItem),
+		...sessionFields,
+		errorSignals: params.toolErrorSignals.map((signal) => signal.signatureHash),
+		...mappedDecayFields(defaults),
+		...params.sourceReflectionPath ? { sourceReflectionPath: params.sourceReflectionPath } : {}
+	};
+}
+function normalizeRunAt(runAt) {
+	if (!Number.isFinite(runAt)) return Date.now();
+	return Math.max(0, Math.floor(runAt));
+}
+function formatReflectionEventDate(runAt) {
+	return new Date(runAt).toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
+}
+function hashReflectionEventIdentity(identity) {
+	return createHash("sha1").update(`${identity.runAt}|${identity.sessionKey}|${identity.sessionId}|${identity.agentId}|${identity.command}`).digest("hex").slice(0, 8);
+}
+function eventIdentityFromParams(params) {
+	return {
+		runAt: params.runAt,
+		sessionKey: params.sessionKey,
+		sessionId: params.sessionId,
+		agentId: params.agentId,
+		command: params.command
+	};
+}
+function collectErrorSignalHashes(signals) {
+	return signals.map((signal) => signal.signatureHash);
+}
+/** Creates a deterministic event id from run time, session, agent, and command. */
+function createReflectionEventId(params) {
+	const identity = {
+		...params,
+		runAt: normalizeRunAt(params.runAt)
+	};
+	return `refl-${formatReflectionEventDate(identity.runAt)}-${hashReflectionEventIdentity(identity)}`;
+}
+function buildReflectionEventMetadata(params, eventId) {
+	return {
+		type: "memory-reflection-event",
+		reflectionVersion: 4,
+		kind: "episodic",
+		memory_category: "episodic",
+		stage: "reflect-store",
+		eventId,
+		sessionKey: params.sessionKey,
+		sessionId: params.sessionId,
+		agentId: params.agentId,
+		command: params.command,
+		storedAt: params.runAt,
+		asserted_at: params.runAt,
+		event_at: new Date(params.runAt).toISOString(),
+		usedFallback: params.usedFallback,
+		errorSignals: collectErrorSignalHashes(params.toolErrorSignals),
+		...params.sourceReflectionPath ? { sourceReflectionPath: params.sourceReflectionPath } : {}
+	};
+}
+function renderReflectionEventText(params, eventId) {
+	return [
+		`reflection-event · ${params.scope}`,
+		`eventId=${eventId}`,
+		`session=${params.sessionId}`,
+		`agent=${params.agentId}`,
+		`command=${params.command}`,
+		`usedFallback=${params.usedFallback ? "true" : "false"}`
+	].join("\n");
+}
+/**
+* Assembles reflection event payload from validated inputs for deterministic reflection event
+* persistence.
+*/
+function buildReflectionEventPayload(params) {
+	const eventId = params.eventId || createReflectionEventId(eventIdentityFromParams(params));
+	const metadata = buildReflectionEventMetadata(params, eventId);
+	return {
+		kind: "episodic-reflection",
+		text: renderReflectionEventText(params, eventId),
+		metadata
+	};
+}
+//#endregion
+//#region src/engine/reflection/reflection-store-payload-builder.ts
+/** @file reflection-store-payload-builder.ts
+* @purpose Build reflection event, item, and legacy payloads for storage.
+* @boundary Pure payload assembly from parsed reflection text and caller context.
+*/
+function buildReflectionStorePayloads(params) {
+	const slices = extractInjectableReflectionSlices(params.reflectionText);
+	const eventId = params.eventId || createReflectionEventId({
+		runAt: params.runAt,
+		sessionKey: params.sessionKey,
+		sessionId: params.sessionId,
+		agentId: params.agentId,
+		command: params.command
+	});
+	const payloads = [buildReflectionEventPayload({
+		eventId,
+		scope: params.scope,
+		sessionKey: params.sessionKey,
+		sessionId: params.sessionId,
+		agentId: params.agentId,
+		command: params.command,
+		toolErrorSignals: params.toolErrorSignals,
+		runAt: params.runAt,
+		usedFallback: params.usedFallback,
+		sourceReflectionPath: params.sourceReflectionPath
+	})];
+	payloads.push(...buildReflectionItemPayloads({
+		items: extractInjectableReflectionSliceItems(params.reflectionText),
+		eventId,
+		agentId: params.agentId,
+		sessionKey: params.sessionKey,
+		sessionId: params.sessionId,
+		runAt: params.runAt,
+		usedFallback: params.usedFallback,
+		toolErrorSignals: params.toolErrorSignals,
+		sourceReflectionPath: params.sourceReflectionPath
+	}));
+	if (params.writeLegacyCombined === true && (slices.invariants.length > 0 || slices.derived.length > 0)) payloads.push(buildLegacyCombinedPayload({
+		slices,
+		scope: params.scope,
+		sessionKey: params.sessionKey,
+		sessionId: params.sessionId,
+		agentId: params.agentId,
+		command: params.command,
+		toolErrorSignals: params.toolErrorSignals,
+		runAt: params.runAt,
+		usedFallback: params.usedFallback,
+		sourceReflectionPath: params.sourceReflectionPath
+	}));
+	return {
+		eventId,
+		slices,
+		payloads
+	};
+}
+function buildLegacyCombinedPayload(params) {
+	const dateYmd = new Date(params.runAt).toISOString().split("T")[0];
+	const deriveQuality = computeDerivedLineQuality(params.slices.derived.length);
+	const deriveBaseWeight = params.usedFallback ? resolveLegacyDeriveBaseWeight({ usedFallback: true }) : 1;
+	return {
+		kind: "combined-legacy",
+		text: [
+			`reflection · ${params.scope} · ${dateYmd}`,
+			`Session Reflection (${new Date(params.runAt).toISOString()})`,
+			`Session Key: ${params.sessionKey}`,
+			`Session ID: ${params.sessionId}`,
+			"",
+			"Invariants:",
+			...params.slices.invariants.length > 0 ? params.slices.invariants.map((x) => `- ${x}`) : ["- (none captured)"],
+			"",
+			"Derived:",
+			...params.slices.derived.length > 0 ? params.slices.derived.map((x) => `- ${x}`) : ["- (none captured)"]
+		].join("\n"),
+		metadata: {
+			type: "memory-reflection",
+			stage: "reflect-store",
+			reflectionVersion: 3,
+			sessionKey: params.sessionKey,
+			sessionId: params.sessionId,
+			agentId: params.agentId,
+			command: params.command,
+			storedAt: params.runAt,
+			invariants: params.slices.invariants,
+			derived: params.slices.derived,
+			usedFallback: params.usedFallback,
+			errorSignals: params.toolErrorSignals.map((s) => s.signatureHash),
+			decayModel: "logistic",
+			decayMidpointDays: 3,
+			decayK: REFLECTION_DERIVE_LOGISTIC_K,
+			deriveBaseWeight,
+			deriveQuality,
+			deriveSource: params.usedFallback ? "fallback" : "normal",
+			...params.sourceReflectionPath ? { sourceReflectionPath: params.sourceReflectionPath } : {}
+		}
+	};
+}
+//#endregion
+//#region src/engine/reflection/reflection-store-writer.ts
+/** @file reflection-store-writer.ts
+* @purpose Persist reflection payloads with semantic duplicate protection.
+* @boundary Store embedding, duplicate search, and write orchestration.
+*/
+async function storeReflectionEntries(params) {
+	const { eventId, slices, payloads } = buildReflectionStorePayloads(params);
+	const storedKinds = [];
+	const derivedSources = [];
+	const dedupeThreshold = Number.isFinite(params.dedupeThreshold) ? Number(params.dedupeThreshold) : .97;
+	for (const payload of payloads) {
+		const vector = await params.embed(payload.text);
+		const existing = await params.searchSemantic(vector, {
+			limit: 12,
+			minScore: .1,
+			projectIdFilter: [params.scope]
+		});
+		if (payload.kind === "combined-legacy") {
+			const topMatch = existing[0];
+			if (topMatch && topMatch.score > dedupeThreshold) continue;
+		}
+		if (hasDuplicateReflectionPayload(payload, existing)) continue;
+		const stored = await params.store({
+			text: payload.text,
+			category: categoryForPayload(payload.kind),
+			projectId: params.scope,
+			importance: resolveReflectionImportance(payload.kind),
+			metadata: metadataForPayload(payload, params.runAt, params.writerAgentId),
+			timestamp: params.runAt
+		});
+		storedKinds.push(payload.kind);
+		if (payload.kind === "item-derived" && stored.factId) derivedSources.push({
+			line: payload.text,
+			rowId: stored.id,
+			factId: stored.factId,
+			sourceAgentId: params.agentId,
+			memoryKind: stored.category ?? categoryForPayload(payload.kind),
+			projectId: stored.projectId ?? params.scope,
+			rank: derivedSources.length + 1,
+			score: resolveReflectionImportance(payload.kind)
+		});
+	}
+	return {
+		stored: storedKinds.length > 0,
+		eventId,
+		slices,
+		storedKinds,
+		derivedSources
+	};
+}
+function categoryForPayload(kind) {
+	return kind === "episodic-reflection" ? "episodic" : "lesson";
+}
+function metadataForPayload(payload, runAt, writerAgentId) {
+	const category = categoryForPayload(payload.kind);
+	const metadataPatch = {
+		...payload.metadata,
+		...writerAgentId ? { writer_agent_id: writerAgentId } : {},
+		...category === "lesson" ? { anti_pattern_signature: buildReflectionAntiPatternSignature(payload.kind === "combined-legacy" ? "combined-legacy" : "reflection-item", payload.text) } : { event_at: new Date(runAt).toISOString() }
+	};
+	return stringifyInsightMetadata(buildInsightMetadata({
+		text: payload.text,
+		category,
+		timestamp: runAt
+	}, metadataPatch));
+}
+function resolveReflectionImportance(kind) {
+	if (kind === "episodic-reflection") return .55;
+	if (kind === "item-invariant") return .82;
+	if (kind === "item-derived") return .78;
+	return .75;
+}
+function hasDuplicateReflectionPayload(payload, matches) {
+	if (payload.kind === "combined-legacy") return false;
+	return matches.some((match) => {
+		const existingMetadata = parseReflectionMetadata(match.entry.metadata);
+		if (payload.kind === "episodic-reflection") {
+			const eventMetadata = payload.metadata;
+			return existingMetadata.type === "memory-reflection-event" && existingMetadata.sessionKey === eventMetadata.sessionKey && existingMetadata.sessionId === eventMetadata.sessionId && existingMetadata.agentId === eventMetadata.agentId && existingMetadata.command === eventMetadata.command;
+		}
+		const itemMetadata = payload.metadata;
+		return existingMetadata.type === "memory-reflection-item" && existingMetadata.sessionId === itemMetadata.sessionId && existingMetadata.agentId === itemMetadata.agentId && existingMetadata.itemKind === itemMetadata.itemKind && match.entry.text === payload.text;
+	});
+}
+//#endregion
+export { loadAgentReflectionSlicesFromEntries as a, buildReflectionMappedMetadata as i, createReflectionEventId as n, extractInjectableReflectionMappedMemoryItems as o, buildReflectionAntiPatternSignature as r, extractReflectionLearningGovernanceCandidates as s, storeReflectionEntries as t };