@agentmemory/agentmemory 0.7.3 → 0.7.5

package/dist/index.mjs

@@ -826,6 +826,7 @@ const KV = {
 	sentinels: "mem:sentinels",
 	crystals: "mem:crystals",
 	lessons: "mem:lessons",
+	insights: "mem:insights",
 	graphEdgeHistory: "mem:graph:edge-history",
 	enrichedChunks: (sessionId) => `mem:enriched:${sessionId}`,
 	latentEmbeddings: (obsId) => `mem:latent:${obsId}`,
@@ -3739,7 +3740,7 @@ function registerAutoForgetFunction(sdk, kv) {
 
 //#endregion
 //#region src/version.ts
-const VERSION = "0.7.3";
+const VERSION = "0.7.5";
 
 //#endregion
 //#region src/functions/export-import.ts
@@ -3767,7 +3768,7 @@ function registerExportImportFunction(sdk, kv) {
 		const uniqueProjects = [...new Set(paginatedSessions.map((s) => s.project))];
 		const profileResults = await Promise.all(uniqueProjects.map((project) => kv.get(KV.profiles, project).catch(() => null)));
 		for (const profile of profileResults) if (profile) profiles.push(profile);
-		const [graphNodes, graphEdges, semanticMemories, proceduralMemories, actions, actionEdges, sentinels, sketches, crystals, facets, lessons, routines, signals, checkpoints] = await Promise.all([
+		const [graphNodes, graphEdges, semanticMemories, proceduralMemories, actions, actionEdges, sentinels, sketches, crystals, facets, lessons, insights, routines, signals, checkpoints] = await Promise.all([
 			kv.list(KV.graphNodes).catch(() => []),
 			kv.list(KV.graphEdges).catch(() => []),
 			kv.list(KV.semantic).catch(() => []),
@@ -3779,6 +3780,7 @@ function registerExportImportFunction(sdk, kv) {
 			kv.list(KV.crystals).catch(() => []),
 			kv.list(KV.facets).catch(() => []),
 			kv.list(KV.lessons).catch(() => []),
+			kv.list(KV.insights).catch(() => []),
 			kv.list(KV.routines).catch(() => []),
 			kv.list(KV.signals).catch(() => []),
 			kv.list(KV.checkpoints).catch(() => [])
@@ -3802,6 +3804,7 @@ function registerExportImportFunction(sdk, kv) {
 			crystals: crystals.length > 0 ? crystals : void 0,
 			facets: facets.length > 0 ? facets : void 0,
 			lessons: lessons.length > 0 ? lessons : void 0,
+			insights: insights.length > 0 ? insights : void 0,
 			routines: routines.length > 0 ? routines : void 0,
 			signals: signals.length > 0 ? signals : void 0,
 			checkpoints: checkpoints.length > 0 ? checkpoints : void 0
@@ -3837,7 +3840,9 @@ function registerExportImportFunction(sdk, kv) {
 			"0.6.1",
 			"0.7.0",
 			"0.7.2",
-			"0.7.3"
+			"0.7.3",
+			"0.7.4",
+			"0.7.5"
 		]).has(importData.version)) return {
 			success: false,
 			error: `Unsupported export version: ${importData.version}`
@@ -3924,6 +3929,7 @@ function registerExportImportFunction(sdk, kv) {
 			for (const c of await kv.list(KV.crystals).catch(() => [])) await kv.delete(KV.crystals, c.id);
 			for (const f of await kv.list(KV.facets).catch(() => [])) await kv.delete(KV.facets, f.id);
 			for (const l of await kv.list(KV.lessons).catch(() => [])) await kv.delete(KV.lessons, l.id);
+			for (const i of await kv.list(KV.insights).catch(() => [])) await kv.delete(KV.insights, i.id);
 			for (const n of await kv.list(KV.graphNodes).catch(() => [])) await kv.delete(KV.graphNodes, n.id);
 			for (const e of await kv.list(KV.graphEdges).catch(() => [])) await kv.delete(KV.graphEdges, e.id);
 			for (const s of await kv.list(KV.semantic).catch(() => [])) await kv.delete(KV.semantic, s.id);
@@ -4095,6 +4101,15 @@ function registerExportImportFunction(sdk, kv) {
 			}
 			await kv.set(KV.lessons, lesson.id, lesson);
 		}
+		if (importData.insights) for (const insight of importData.insights) {
+			if (strategy === "skip") {
+				if (await kv.get(KV.insights, insight.id).catch(() => null)) {
+					stats.skipped++;
+					continue;
+				}
+			}
+			await kv.set(KV.insights, insight.id, insight);
+		}
 		ctx.logger.info("Import complete", {
 			strategy,
 			...stats
@@ -4649,6 +4664,16 @@ function registerConsolidationPipelineFunction(sdk, kv, provider) {
 				reason: "fewer than 5 summaries"
 			};
 		}
+		if (tier === "all" || tier === "reflect") try {
+			results.reflect = await sdk.trigger("mem::reflect", {
+				maxClusters: 10,
+				project: data?.project
+			});
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			ctx.logger.warn("Reflect tier failed", { error: msg });
+			results.reflect = { error: msg };
+		}
 		if (tier === "all" || tier === "procedural") {
 			const patterns = (await kv.list(KV.memories)).filter((m) => m.isLatest && m.type === "pattern").map((m) => ({
 				content: m.content,
@@ -8405,6 +8430,320 @@ function registerObsidianExportFunction(sdk, kv) {
 	});
 }
 
+//#endregion
+//#region src/prompts/reflect.ts
+const REFLECT_SYSTEM = `You are a higher-order reasoning engine. Given a cluster of related concepts, facts, lessons, and action outcomes, synthesize cross-cutting insights that span multiple individual memories.
+
+Output format (XML):
+<insights>
+  <insight confidence="0.0-1.0" title="Short descriptive title">
+    The higher-order observation or principle. Should be actionable and non-obvious — something that only becomes visible when viewing multiple memories together.
+  </insight>
+</insights>
+
+Rules:
+- Identify patterns, principles, or strategies that span 2+ source items
+- Confidence reflects how well-supported the insight is across sources
+- Title should be a concise label (under 60 chars)
+- Content should be the actual observation (1-3 sentences)
+- Prefer actionable insights over abstract summaries
+- Skip insights that merely restate a single source item
+- Always emit confidence attribute before title attribute`;
+function buildReflectPrompt(cluster) {
+	const sections = [];
+	sections.push(`## Concept Cluster: ${cluster.concepts.join(", ")}`);
+	if (cluster.facts.length > 0) sections.push("\n## Known Facts", ...cluster.facts.map((f) => `- [confidence=${f.confidence}] ${f.fact}`));
+	if (cluster.lessons.length > 0) sections.push("\n## Lessons Learned", ...cluster.lessons.map((l) => `- [confidence=${l.confidence}] ${l.content}`));
+	if (cluster.crystalNarratives.length > 0) sections.push("\n## Completed Work Summaries", ...cluster.crystalNarratives.map((n) => `- ${n}`));
+	return `Synthesize higher-order insights from this cluster of related memories:\n\n${sections.join("\n")}`;
+}
+
+//#endregion
+//#region src/functions/reflect.ts
+function reinforceInsight(insight) {
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	insight.reinforcements++;
+	insight.confidence = Math.min(1, insight.confidence + .1 * (1 - insight.confidence));
+	insight.lastReinforcedAt = now;
+	insight.updatedAt = now;
+}
+function buildGraphClusters(nodes, edges, maxClusters) {
+	const conceptNodes = nodes.filter((n) => n.type === "concept" && !n.stale);
+	if (conceptNodes.length === 0) return [];
+	const edgeMap = /* @__PURE__ */ new Map();
+	for (const edge of edges) {
+		if (edge.stale) continue;
+		if (!edgeMap.has(edge.sourceNodeId)) edgeMap.set(edge.sourceNodeId, /* @__PURE__ */ new Set());
+		if (!edgeMap.has(edge.targetNodeId)) edgeMap.set(edge.targetNodeId, /* @__PURE__ */ new Set());
+		edgeMap.get(edge.sourceNodeId).add(edge.targetNodeId);
+		edgeMap.get(edge.targetNodeId).add(edge.sourceNodeId);
+	}
+	const degree = /* @__PURE__ */ new Map();
+	for (const node of conceptNodes) degree.set(node.id, edgeMap.get(node.id)?.size || 0);
+	const sorted = [...conceptNodes].sort((a, b) => (degree.get(b.id) || 0) - (degree.get(a.id) || 0));
+	const visited = /* @__PURE__ */ new Set();
+	const clusters = [];
+	const conceptNodeIds = new Set(conceptNodes.map((n) => n.id));
+	for (const seed of sorted) {
+		if (visited.has(seed.id) || clusters.length >= maxClusters) break;
+		const cluster = [];
+		const queue = [seed.id];
+		const seen = /* @__PURE__ */ new Set();
+		let depth = 0;
+		while (queue.length > 0 && depth <= 2) {
+			const levelCount = queue.length;
+			for (let i = 0; i < levelCount; i++) {
+				const current = queue.shift();
+				if (seen.has(current)) continue;
+				seen.add(current);
+				if (conceptNodeIds.has(current)) {
+					const node = conceptNodes.find((n) => n.id === current);
+					if (node) cluster.push(node.name);
+					visited.add(current);
+				}
+				const neighbors = edgeMap.get(current) || /* @__PURE__ */ new Set();
+				for (const neighbor of neighbors) if (!seen.has(neighbor)) queue.push(neighbor);
+			}
+			depth++;
+		}
+		if (cluster.length >= 2) clusters.push(cluster);
+	}
+	return clusters;
+}
+function buildJaccardClusters(semanticMemories, lessons, maxClusters) {
+	const allConcepts = /* @__PURE__ */ new Map();
+	for (const sem of semanticMemories) {
+		const terms = sem.fact.toLowerCase().split(/\s+/).filter((t) => t.length > 3);
+		for (const term of terms) {
+			if (!allConcepts.has(term)) allConcepts.set(term, /* @__PURE__ */ new Set());
+			allConcepts.get(term).add(sem.id);
+		}
+	}
+	for (const lesson of lessons) for (const tag of lesson.tags) {
+		const key = tag.toLowerCase();
+		if (!allConcepts.has(key)) allConcepts.set(key, /* @__PURE__ */ new Set());
+		allConcepts.get(key).add(lesson.id);
+	}
+	const conceptList = [...allConcepts.keys()].filter((k) => (allConcepts.get(k)?.size || 0) >= 2);
+	const visited = /* @__PURE__ */ new Set();
+	const clusters = [];
+	for (const concept of conceptList) {
+		if (visited.has(concept) || clusters.length >= maxClusters) break;
+		const cluster = [concept];
+		visited.add(concept);
+		const docsA = allConcepts.get(concept) || /* @__PURE__ */ new Set();
+		for (const other of conceptList) {
+			if (visited.has(other)) continue;
+			const docsB = allConcepts.get(other) || /* @__PURE__ */ new Set();
+			let intersection = 0;
+			for (const d of docsA) if (docsB.has(d)) intersection++;
+			const union = docsA.size + docsB.size - intersection;
+			if ((union > 0 ? intersection / union : 0) > .3) {
+				cluster.push(other);
+				visited.add(other);
+			}
+		}
+		if (cluster.length >= 2) clusters.push(cluster);
+	}
+	return clusters;
+}
+function registerReflectFunctions(sdk, kv, provider) {
+	sdk.registerFunction({ id: "mem::reflect" }, async (data) => {
+		const maxClusters = Math.min(data?.maxClusters ?? 10, 20);
+		const maxInsightsPerCluster = 5;
+		const maxTotal = 50;
+		const [graphNodes, graphEdges, semanticMemories, lessons, crystals] = await Promise.all([
+			kv.list(KV.graphNodes).catch(() => []),
+			kv.list(KV.graphEdges).catch(() => []),
+			kv.list(KV.semantic).catch(() => []),
+			kv.list(KV.lessons).catch(() => []),
+			kv.list(KV.crystals).catch(() => [])
+		]);
+		let activeLessons = lessons.filter((l) => !l.deleted);
+		if (data?.project) activeLessons = activeLessons.filter((l) => l.project === data.project);
+		let conceptClusters = buildGraphClusters(graphNodes, graphEdges, maxClusters);
+		const usedFallback = conceptClusters.length === 0;
+		if (usedFallback) conceptClusters = buildJaccardClusters(semanticMemories, activeLessons, maxClusters);
+		let newInsights = 0;
+		let reinforced = 0;
+		let clustersSkipped = 0;
+		let totalInsights = 0;
+		for (const conceptNames of conceptClusters) {
+			if (totalInsights >= maxTotal) break;
+			const conceptSet = new Set(conceptNames.map((c) => c.toLowerCase()));
+			const clusterFacts = semanticMemories.filter((s) => {
+				return s.fact.toLowerCase().split(/\s+/).some((t) => conceptSet.has(t));
+			});
+			const clusterLessons = activeLessons.filter((l) => l.tags.some((t) => conceptSet.has(t.toLowerCase())) || conceptNames.some((c) => l.content.toLowerCase().includes(c.toLowerCase())));
+			const clusterCrystals = crystals.filter((c) => (c.lessons || []).some((l) => conceptNames.some((cn) => l.toLowerCase().includes(cn.toLowerCase()))));
+			if (clusterFacts.length + clusterLessons.length + clusterCrystals.length < 3) {
+				clustersSkipped++;
+				continue;
+			}
+			const cluster = {
+				concepts: conceptNames,
+				facts: clusterFacts.map((f) => ({
+					fact: f.fact,
+					confidence: f.confidence
+				})),
+				lessons: clusterLessons.map((l) => ({
+					content: l.content,
+					confidence: l.confidence
+				})),
+				crystalNarratives: clusterCrystals.map((c) => c.narrative),
+				factIds: clusterFacts.map((f) => f.id),
+				lessonIds: clusterLessons.map((l) => l.id),
+				crystalIds: clusterCrystals.map((c) => c.id)
+			};
+			try {
+				const prompt = buildReflectPrompt(cluster);
+				const response = await provider.summarize(REFLECT_SYSTEM, prompt);
+				const insightRegex = /<insight\s+confidence="([^"]+)"\s+title="([^"]+)">([\s\S]*?)<\/insight>/g;
+				let match;
+				let clusterCount = 0;
+				while ((match = insightRegex.exec(response)) !== null && clusterCount < maxInsightsPerCluster && totalInsights < maxTotal) {
+					const parsedConf = parseFloat(match[1]);
+					const confidence = Number.isNaN(parsedConf) ? .5 : Math.max(0, Math.min(1, parsedConf));
+					const title = match[2].trim();
+					const content = match[3].trim();
+					if (!content) continue;
+					const fp = fingerprintId("ins", content.trim().toLowerCase());
+					const existing = await kv.get(KV.insights, fp);
+					if (existing && !existing.deleted) {
+						reinforceInsight(existing);
+						await kv.set(KV.insights, existing.id, existing);
+						reinforced++;
+					} else {
+						const now = (/* @__PURE__ */ new Date()).toISOString();
+						const insight = {
+							id: fp,
+							title,
+							content,
+							confidence,
+							reinforcements: 0,
+							sourceConceptCluster: conceptNames,
+							sourceMemoryIds: cluster.factIds,
+							sourceLessonIds: cluster.lessonIds,
+							sourceCrystalIds: cluster.crystalIds,
+							project: data?.project,
+							tags: conceptNames,
+							createdAt: now,
+							updatedAt: now,
+							decayRate: .05
+						};
+						await kv.set(KV.insights, insight.id, insight);
+						newInsights++;
+					}
+					clusterCount++;
+					totalInsights++;
+				}
+			} catch {
+				continue;
+			}
+		}
+		try {
+			await recordAudit(kv, "reflect", "mem::reflect", [], {
+				newInsights,
+				reinforced,
+				clustersProcessed: conceptClusters.length - clustersSkipped,
+				clustersSkipped,
+				usedFallback
+			});
+		} catch {}
+		return {
+			success: true,
+			newInsights,
+			reinforced,
+			clustersProcessed: conceptClusters.length - clustersSkipped,
+			clustersSkipped,
+			usedFallback
+		};
+	});
+	sdk.registerFunction({ id: "mem::insight-list" }, async (data) => {
+		const limit = data?.limit ?? 50;
+		const minConfidence = data?.minConfidence ?? 0;
+		let items = await kv.list(KV.insights);
+		items = items.filter((i) => !i.deleted && i.confidence >= minConfidence);
+		if (data?.project) items = items.filter((i) => i.project === data.project);
+		items.sort((a, b) => b.confidence - a.confidence);
+		return {
+			success: true,
+			insights: items.slice(0, limit)
+		};
+	});
+	sdk.registerFunction({ id: "mem::insight-search" }, async (data) => {
+		if (!data?.query?.trim()) return {
+			success: false,
+			error: "query is required"
+		};
+		const query = data.query.toLowerCase();
+		const minConfidence = data.minConfidence ?? .1;
+		const limit = data.limit ?? 10;
+		let items = await kv.list(KV.insights);
+		items = items.filter((i) => !i.deleted && i.confidence >= minConfidence);
+		if (data.project) items = items.filter((i) => i.project === data.project);
+		const terms = query.split(/\s+/).filter((t) => t.length > 1);
+		const scored = items.map((i) => {
+			const text = `${i.title} ${i.content} ${i.tags.join(" ")}`.toLowerCase();
+			const matchCount = terms.filter((t) => text.includes(t)).length;
+			if (matchCount === 0) return null;
+			const relevance = matchCount / terms.length;
+			const recencyBoost = 1 / (1 + (i.lastReinforcedAt ? (Date.now() - new Date(i.lastReinforcedAt).getTime()) / (1e3 * 60 * 60 * 24) : (Date.now() - new Date(i.createdAt).getTime()) / (1e3 * 60 * 60 * 24)) * .01);
+			return {
+				insight: i,
+				score: i.confidence * relevance * recencyBoost
+			};
+		}).filter(Boolean);
+		scored.sort((a, b) => b.score - a.score);
+		try {
+			await recordAudit(kv, "insight_search", "mem::insight-search", [], {
+				query: data.query,
+				resultCount: scored.length
+			});
+		} catch {}
+		return {
+			success: true,
+			insights: scored.slice(0, limit).map((s) => ({
+				...s.insight,
+				score: Math.round(s.score * 1e3) / 1e3
+			}))
+		};
+	});
+	sdk.registerFunction({ id: "mem::insight-decay-sweep" }, async () => {
+		const items = await kv.list(KV.insights);
+		let decayed = 0;
+		let softDeleted = 0;
+		const now = Date.now();
+		const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+		const dirty = [];
+		for (const insight of items) {
+			if (insight.deleted) continue;
+			const baseline = insight.lastDecayedAt || insight.lastReinforcedAt || insight.createdAt;
+			const weeksSince = (now - new Date(baseline).getTime()) / (1e3 * 60 * 60 * 24 * 7);
+			if (weeksSince < 1) continue;
+			const decay = insight.decayRate * weeksSince;
+			const newConfidence = Math.max(.05, insight.confidence - decay);
+			if (newConfidence !== insight.confidence) {
+				insight.confidence = Math.round(newConfidence * 1e3) / 1e3;
+				insight.lastDecayedAt = timestamp;
+				insight.updatedAt = timestamp;
+				if (insight.confidence <= .1 && insight.reinforcements === 0) {
+					insight.deleted = true;
+					softDeleted++;
+				} else decayed++;
+				dirty.push(insight);
+			}
+		}
+		await Promise.all(dirty.map((i) => kv.set(KV.insights, i.id, i)));
+		return {
+			success: true,
+			decayed,
+			softDeleted,
+			total: items.length
+		};
+	});
+}
+
 //#endregion
 //#region src/functions/sliding-window.ts
 const SLIDING_WINDOW_SYSTEM = `You are a contextual enrichment engine. Given a primary observation and its surrounding context window (previous and next observations from the same session), produce an enriched version.
@@ -11193,6 +11532,73 @@ function registerApiTriggers(sdk, kv, secret, metricsStore, provider) {
 			http_method: "POST"
 		}
 	});
+	sdk.registerFunction({ id: "api::reflect" }, async (req) => {
+		const denied = checkAuth$1(req, secret);
+		if (denied) return denied;
+		const body = req.body || {};
+		return {
+			status_code: 200,
+			body: await sdk.trigger("mem::reflect", {
+				project: typeof body.project === "string" ? body.project : void 0,
+				maxClusters: typeof body.maxClusters === "number" ? body.maxClusters : void 0
+			})
+		};
+	});
+	sdk.registerTrigger({
+		type: "http",
+		function_id: "api::reflect",
+		config: {
+			api_path: "/agentmemory/reflect",
+			http_method: "POST"
+		}
+	});
+	sdk.registerFunction({ id: "api::insight-list" }, async (req) => {
+		const denied = checkAuth$1(req, secret);
+		if (denied) return denied;
+		const params = req.query_params || {};
+		return {
+			status_code: 200,
+			body: await sdk.trigger("mem::insight-list", {
+				project: params.project,
+				minConfidence: params.minConfidence ? parseFloat(params.minConfidence) : void 0,
+				limit: params.limit ? parseInt(params.limit, 10) : void 0
+			})
+		};
+	});
+	sdk.registerTrigger({
+		type: "http",
+		function_id: "api::insight-list",
+		config: {
+			api_path: "/agentmemory/insights",
+			http_method: "GET"
+		}
+	});
+	sdk.registerFunction({ id: "api::insight-search" }, async (req) => {
+		const denied = checkAuth$1(req, secret);
+		if (denied) return denied;
+		const body = req.body;
+		if (!body?.query || typeof body.query !== "string") return {
+			status_code: 400,
+			body: { error: "query is required" }
+		};
+		return {
+			status_code: 200,
+			body: await sdk.trigger("mem::insight-search", {
+				query: body.query,
+				project: typeof body.project === "string" ? body.project : void 0,
+				minConfidence: typeof body.minConfidence === "number" ? body.minConfidence : void 0,
+				limit: typeof body.limit === "number" ? body.limit : void 0
+			})
+		};
+	});
+	sdk.registerTrigger({
+		type: "http",
+		function_id: "api::insight-search",
+		config: {
+			api_path: "/agentmemory/insights/search",
+			http_method: "POST"
+		}
+	});
 }
 
 //#endregion
@@ -12105,6 +12511,43 @@ const V070_TOOLS = [
 		}
 	}
 ];
+const V073_TOOLS = [{
+	name: "memory_reflect",
+	description: "Traverse the knowledge graph, group related memories by concept clusters, and synthesize higher-order insights via LLM. Returns new and reinforced insights.",
+	inputSchema: {
+		type: "object",
+		properties: {
+			project: {
+				type: "string",
+				description: "Filter by project"
+			},
+			maxClusters: {
+				type: "number",
+				description: "Max concept clusters to process (default 10, max 20)"
+			}
+		}
+	}
+}, {
+	name: "memory_insight_list",
+	description: "List synthesized insights — higher-order observations derived from patterns across memories, lessons, and crystals.",
+	inputSchema: {
+		type: "object",
+		properties: {
+			project: {
+				type: "string",
+				description: "Filter by project"
+			},
+			minConfidence: {
+				type: "number",
+				description: "Minimum confidence threshold (default 0)"
+			},
+			limit: {
+				type: "number",
+				description: "Max results (default 50)"
+			}
+		}
+	}
+}];
 const ESSENTIAL_TOOLS = new Set([
 	"memory_save",
 	"memory_recall",
@@ -12112,7 +12555,8 @@ const ESSENTIAL_TOOLS = new Set([
 	"memory_smart_search",
 	"memory_sessions",
 	"memory_diagnose",
-	"memory_lesson_save"
+	"memory_lesson_save",
+	"memory_reflect"
 ]);
 function getAllTools() {
 	return [
@@ -12121,7 +12565,8 @@ function getAllTools() {
 		...V050_TOOLS,
 		...V051_TOOLS,
 		...V061_TOOLS,
-		...V070_TOOLS
+		...V070_TOOLS,
+		...V073_TOOLS
 	];
 }
 function getVisibleTools() {
@@ -12941,6 +13386,33 @@ function registerMcpEndpoints(sdk, kv, secret) {
 						}] }
 					};
 				}
+				case "memory_reflect": {
+					const reflectResult = await sdk.trigger("mem::reflect", {
+						project: args.project,
+						maxClusters: args.maxClusters
+					});
+					return {
+						status_code: 200,
+						body: { content: [{
+							type: "text",
+							text: JSON.stringify(reflectResult, null, 2)
+						}] }
+					};
+				}
+				case "memory_insight_list": {
+					const insightListResult = await sdk.trigger("mem::insight-list", {
+						project: args.project,
+						minConfidence: args.minConfidence,
+						limit: args.limit
+					});
+					return {
+						status_code: 200,
+						body: { content: [{
+							type: "text",
+							text: JSON.stringify(insightListResult, null, 2)
+						}] }
+					};
+				}
 				case "memory_obsidian_export": {
 					const exportTypes = typeof args.types === "string" && args.types.trim() ? args.types.split(",").map((t) => t.trim()).filter(Boolean) : void 0;
 					const obsidianResult = await sdk.trigger("mem::obsidian-export", {
@@ -13424,6 +13896,10 @@ function startViewerServer(port, _kv, _sdk, secret, restPort) {
 			json(res, 502, { error: "upstream error" }, req);
 		}
 	});
+	server.on("error", (err) => {
+		if (err.code === "EADDRINUSE") console.warn(`[agentmemory] Viewer port ${port} already in use, skipping viewer.`);
+		else console.error(`[agentmemory] Viewer error:`, err.message);
+	});
 	server.listen(port, "127.0.0.1", () => {
 		console.log(`[agentmemory] Viewer: http://localhost:${port}`);
 	});
@@ -13681,6 +14157,7 @@ async function main() {
 	registerVerifyFunction(sdk, kv);
 	registerLessonsFunctions(sdk, kv);
 	registerObsidianExportFunction(sdk, kv);
+	registerReflectFunctions(sdk, kv, provider);
 	registerCascadeFunction(sdk, kv);
 	registerSlidingWindowFunction(sdk, kv, provider);
 	registerQueryExpansionFunction(sdk, provider);
@@ -13725,7 +14202,7 @@ async function main() {
 		}
 	}
 	console.log(`[agentmemory] Ready. ${embeddingProvider ? "Triple-stream (BM25+Vector+Graph)" : "BM25+Graph"} search active.`);
-	console.log(`[agentmemory] Endpoints: 100 REST + 41 MCP tools + 6 MCP resources + 3 MCP prompts`);
+	console.log(`[agentmemory] Endpoints: 103 REST + 43 MCP tools + 6 MCP resources + 3 MCP prompts`);
 	const viewerServer = startViewerServer(config.restPort + 2, kv, sdk, secret, config.restPort);
 	const autoForgetIntervalMs = parseInt(process.env.AUTO_FORGET_INTERVAL_MS || "3600000", 10);
 	const consolidationIntervalMs = parseInt(process.env.CONSOLIDATION_INTERVAL_MS || "7200000", 10);
@@ -13745,6 +14222,11 @@ async function main() {
 		}, 864e5).unref();
 		console.log(`[agentmemory] Lesson decay sweep: enabled (every 24h)`);
 	}
+	if (process.env.INSIGHT_DECAY_ENABLED !== "false") setInterval(async () => {
+		try {
+			await sdk.trigger("mem::insight-decay-sweep", {});
+		} catch {}
+	}, 864e5).unref();
 	if (isConsolidationEnabled()) {
 		setInterval(async () => {
 			try {