formative-memory 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { n as MemorySourceGuard, r as TemporalStateGuard, t as MemoryDatabase } from "./db-D2pzT6fw.js";
+import { n as MemorySourceGuard, r as TemporalStateGuard, t as MemoryDatabase } from "./db-D1Sc76VE.js";
 import { basename, dirname, isAbsolute, join, relative, sep } from "node:path";
 import { appendFileSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
 import { createGeminiEmbeddingProvider, createOpenAiEmbeddingProvider, getMemoryEmbeddingProvider, listMemoryEmbeddingProviders } from "openclaw/plugin-sdk/memory-core-host-engine-embeddings";
@@ -2795,7 +2795,8 @@ const memoryConfigSchema = { parse(value) {
 		"autoCapture",
 		"autoRecall",
 		"verbose",
-		"logQueries"
+		"logQueries",
+		"requireEmbedding"
 	], "memory config");
 	let provider = "auto";
 	let model;
@@ -2812,13 +2813,75 @@ const memoryConfigSchema = { parse(value) {
 			model
 		},
 		dbPath: typeof cfg.dbPath === "string" ? cfg.dbPath : "~/.openclaw/memory/associative",
-		autoCapture: cfg.autoCapture === true,
+		autoCapture: cfg.autoCapture !== false,
 		autoRecall: cfg.autoRecall !== false,
 		verbose: cfg.verbose === true,
-		logQueries: cfg.logQueries === true
+		logQueries: cfg.logQueries === true,
+		requireEmbedding: cfg.requireEmbedding !== false
 	};
 } };
 //#endregion
+//#region src/logger.ts
+const LEVEL_ORDER = {
+	debug: 0,
+	info: 1,
+	warn: 2,
+	error: 3
+};
+/**
+* Create a logger that forwards to the host logger at or above the
+* configured minimum level.
+*/
+function createLogger(opts) {
+	const envDebug = process.env.FORMATIVE_MEMORY_DEBUG === "1";
+	const minOrder = LEVEL_ORDER[opts.verbose || envDebug ? "debug" : "info"];
+	const host = opts.host;
+	function stringifyArg(a) {
+		if (a instanceof Error) return a.stack || a.message;
+		if (typeof a === "object" && a !== null) try {
+			return JSON.stringify(a);
+		} catch {
+			return "[Unserializable]";
+		}
+		return String(a);
+	}
+	function emit(level, msg, args) {
+		if (LEVEL_ORDER[level] < minOrder) return;
+		const prefix = `[formative-memory] [${level}]`;
+		if (host) {
+			const line = `${prefix} ${msg}${args.length > 0 ? " " + args.map(stringifyArg).join(" ") : ""}`;
+			if (level === "debug") (host.debug ?? host.info)(line);
+			else host[level](line);
+		} else {
+			const line = `${prefix} ${msg}`;
+			if (level === "error") console.error(line, ...args);
+			else if (level === "warn") console.warn(line, ...args);
+			else console.log(line, ...args);
+		}
+	}
+	return {
+		debug: (msg, ...args) => emit("debug", msg, args),
+		info: (msg, ...args) => emit("info", msg, args),
+		warn: (msg, ...args) => emit("warn", msg, args),
+		error: (msg, ...args) => emit("error", msg, args),
+		isDebugEnabled: () => minOrder === LEVEL_ORDER.debug
+	};
+}
+/** Sanitize content for log output: collapse whitespace/control chars, truncate. */
+function preview(text, max = 60) {
+	const sanitized = text.replace(/[\x00-\x1F\x7F\s]+/g, " ").trim();
+	if (!sanitized) return "<empty>";
+	return sanitized.length > max ? sanitized.slice(0, max - 1) + "…" : sanitized;
+}
+/** A silent logger that discards all output. Useful for tests. */
+const nullLogger = {
+	debug: () => {},
+	info: () => {},
+	warn: () => {},
+	error: () => {},
+	isDebugEnabled: () => false
+};
+//#endregion
 //#region src/consolidation-steps.ts
 /** Retrieval reinforcement learning rate (η). */
 const ETA = .7;
@@ -2843,9 +2906,10 @@ const MODE_WEIGHT_BM25_ONLY = .5;
 * @param lastConsolidationMs Timestamp (ms) of last consolidation run, or null if never run.
 * @param nowMs Current time in ms (injectable for testing).
 */
-function applyCatchUpDecay(db, lastConsolidationMs, nowMs = Date.now()) {
+function applyCatchUpDecay(db, lastConsolidationMs, nowMs = Date.now(), log = nullLogger) {
 	if (lastConsolidationMs == null || !Number.isFinite(lastConsolidationMs)) return 0;
 	const allMemories = db.getAllMemories();
+	const debug = log.isDebugEnabled();
 	let count = 0;
 	const dayMs = 1e3 * 60 * 60 * 24;
 	for (const mem of allMemories) {
@@ -2856,6 +2920,7 @@ function applyCatchUpDecay(db, lastConsolidationMs, nowMs = Date.now()) {
 		const effectiveCycles = Math.min(cycles, 30);
 		const factor = mem.consolidated ? DECAY_CONSOLIDATED : DECAY_WORKING;
 		const newStrength = mem.strength * Math.pow(factor, effectiveCycles);
+		if (debug) log.debug(`catch-up decay: "${preview(mem.content)}" ${mem.strength.toFixed(3)} → ${newStrength.toFixed(3)} (${effectiveCycles} cycles, ${mem.consolidated ? "consolidated" : "working"})`);
 		db.updateStrength(mem.id, newStrength);
 		count++;
 	}
@@ -2863,8 +2928,11 @@ function applyCatchUpDecay(db, lastConsolidationMs, nowMs = Date.now()) {
 	const globalCycles = Math.max(0, Math.floor(globalDaysSince) - 1);
 	if (globalCycles > 0) {
 		const effectiveGlobal = Math.min(globalCycles, 30);
-		db.decayAllAssociationWeights(Math.pow(DECAY_ASSOCIATION, effectiveGlobal));
+		const associationFactor = Math.pow(DECAY_ASSOCIATION, effectiveGlobal);
+		if (debug) log.debug(`catch-up decay: associations ×${associationFactor.toFixed(4)} (${effectiveGlobal} cycles)`);
+		db.decayAllAssociationWeights(associationFactor);
 	}
+	if (count > 0) log.info(`catch-up decay: ${count} memories adjusted for missed cycles`);
 	return count;
 }
 /**
@@ -2879,7 +2947,7 @@ function applyCatchUpDecay(db, lastConsolidationMs, nowMs = Date.now()) {
 *
 * Returns count of memories reinforced.
 */
-function applyReinforcement(db) {
+function applyReinforcement(db, log = nullLogger) {
 	const pendingAttrs = db.getUnreinforcedAttributions();
 	if (pendingAttrs.length === 0) return 0;
 	const reinforcements = /* @__PURE__ */ new Map();
@@ -2890,6 +2958,7 @@ function applyReinforcement(db) {
 		reinforcements.set(attr.memory_id, current + reinforcement);
 	}
 	return db.transaction(() => {
+		const debug = log.isDebugEnabled();
 		let count = 0;
 		for (const [memoryId, totalReinforcement] of reinforcements) {
 			if (totalReinforcement === 0) continue;
@@ -2898,10 +2967,12 @@ function applyReinforcement(db) {
 			const newStrength = Math.max(0, Math.min(mem.strength + totalReinforcement, 1));
 			if (newStrength !== mem.strength) {
 				db.updateStrength(memoryId, newStrength);
+				if (debug) log.debug(`reinforce: "${preview(mem.content)}" ${mem.strength.toFixed(3)} → ${newStrength.toFixed(3)} (+${totalReinforcement.toFixed(3)})`);
 				count++;
 			}
 		}
 		for (const attr of pendingAttrs) db.markAttributionsReinforced(attr.message_id, attr.memory_id);
+		if (count > 0) log.info(`reinforce: ${count} memories strengthened from ${pendingAttrs.length} attributions`);
 		return count;
 	});
 }
@@ -2913,16 +2984,20 @@ function applyReinforcement(db) {
 *
 * Returns count of memories decayed.
 */
-function applyDecay(db) {
+function applyDecay(db, log = nullLogger) {
 	const allMemories = db.getAllMemories();
+	const debug = log.isDebugEnabled();
 	let count = 0;
 	for (const mem of allMemories) {
 		const factor = mem.consolidated ? DECAY_CONSOLIDATED : DECAY_WORKING;
 		const newStrength = mem.strength * factor;
+		if (debug) log.debug(`decay: "${preview(mem.content)}" ${mem.strength.toFixed(3)} → ${newStrength.toFixed(3)} (×${factor})`);
 		db.updateStrength(mem.id, newStrength);
 		count++;
 	}
+	if (debug) log.debug(`decay: associations ×${DECAY_ASSOCIATION}`);
 	applyAssociationDecay(db);
+	if (count > 0) log.info(`decay: ${count} memories decayed`);
 	return count;
 }
 /**
@@ -2946,19 +3021,22 @@ const CO_RETRIEVAL_BASE_WEIGHT = .1;
 *
 * Returns count of associations updated.
 */
-function updateCoRetrievalAssociations(db) {
+function updateCoRetrievalAssociations(db, log = nullLogger) {
 	const groups = db.getCoRetrievalGroups();
 	const now = (/* @__PURE__ */ new Date()).toISOString();
 	const validIds = new Set(db.getAllMemories().map((m) => m.id));
+	const debug = log.isDebugEnabled();
 	let count = 0;
 	for (const group of groups) {
 		const ids = group.memory_ids.filter((id) => validIds.has(id));
 		if (ids.length < 2) continue;
 		for (let i = 0; i < ids.length; i++) for (let j = i + 1; j < ids.length; j++) {
 			db.upsertAssociationProbOr(ids[i], ids[j], CO_RETRIEVAL_BASE_WEIGHT, now);
+			if (debug) log.debug(`associate: co-retrieval ${ids[i].slice(0, 8)}…↔${ids[j].slice(0, 8)}… (+${CO_RETRIEVAL_BASE_WEIGHT})`);
 			count++;
 		}
 	}
+	if (count > 0) log.info(`associate: ${count} co-retrieval associations updated from ${groups.length} turn groups`);
 	return count;
 }
 /**
@@ -2971,9 +3049,10 @@ function updateCoRetrievalAssociations(db) {
 *
 * Returns count of associations created/updated.
 */
-function updateTransitiveAssociations(db, maxUpdates = 100) {
+function updateTransitiveAssociations(db, maxUpdates = 100, log = nullLogger) {
 	const allMemories = db.getAllMemories();
 	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const debug = log.isDebugEnabled();
 	let count = 0;
 	for (const mem of allMemories) {
 		if (count >= maxUpdates) break;
@@ -2990,9 +3069,11 @@ function updateTransitiveAssociations(db, maxUpdates = 100) {
 			const newWeight = existing + transitiveWeight - existing * transitiveWeight;
 			if (newWeight - existing < 1e-9) continue;
 			db.upsertAssociation(otherId1, otherId2, newWeight, now);
+			if (debug) log.debug(`associate: transitive ${otherId1.slice(0, 8)}…↔${otherId2.slice(0, 8)}… via ${mem.id.slice(0, 8)}… weight=${newWeight.toFixed(3)}`);
 			count++;
 		}
 	}
+	if (count > 0) log.info(`associate: ${count} transitive associations created/updated`);
 	return count;
 }
 /** Association weight threshold below which associations are pruned. */
@@ -3005,14 +3086,17 @@ const PRUNE_ASSOCIATION_THRESHOLD = .01;
 *
 * Returns count of memories pruned.
 */
-function applyPruning(db) {
+function applyPruning(db, log = nullLogger) {
 	const allMemories = db.getAllMemories();
+	const debug = log.isDebugEnabled();
 	let memoriesPruned = 0;
 	for (const mem of allMemories) if (mem.strength <= .05) {
+		if (debug) log.debug(`prune: removing "${preview(mem.content, 80)}" (strength=${mem.strength.toFixed(3)}, type=${mem.type})`);
 		db.deleteMemory(mem.id);
 		memoriesPruned++;
 	}
 	const associationsPruned = db.pruneWeakAssociations(PRUNE_ASSOCIATION_THRESHOLD);
+	if (memoriesPruned > 0 || associationsPruned > 0) log.info(`prune: ${memoriesPruned} memories, ${associationsPruned} associations removed`);
 	return {
 		memoriesPruned,
 		associationsPruned
@@ -3025,9 +3109,10 @@ function applyPruning(db) {
 *
 * Returns count of memories transitioned.
 */
-function applyTemporalTransitions(db) {
+function applyTemporalTransitions(db, log = nullLogger) {
 	const now = /* @__PURE__ */ new Date();
 	const allMemories = db.getAllMemories();
+	const debug = log.isDebugEnabled();
 	let count = 0;
 	for (const mem of allMemories) {
 		if (!mem.temporal_anchor) continue;
@@ -3039,10 +3124,12 @@ function applyTemporalTransitions(db) {
 			if ((now.getTime() - anchor.getTime()) / (1e3 * 60 * 60) >= 24) newState = "past";
 		}
 		if (newState) {
+			if (debug) log.debug(`temporal: "${preview(mem.content)}" ${mem.temporal_state} → ${newState}`);
 			db.updateTemporalState(mem.id, newState);
 			count++;
 		}
 	}
+	if (count > 0) log.info(`temporal: ${count} memories transitioned`);
 	return count;
 }
 /**
@@ -3053,9 +3140,11 @@ function applyTemporalTransitions(db) {
 *
 * Returns count of exposure rows deleted.
 */
-function provenanceGC(db, cutoffDays = 30) {
+function provenanceGC(db, cutoffDays = 30, log = nullLogger) {
 	const cutoffDate = (/* @__PURE__ */ new Date(Date.now() - cutoffDays * 24 * 60 * 60 * 1e3)).toISOString();
-	return db.deleteExposuresOlderThan(cutoffDate);
+	const count = db.deleteExposuresOlderThan(cutoffDate);
+	if (count > 0) log.debug(`gc: ${count} exposure rows older than ${cutoffDays}d removed`);
+	return count;
 }
 //#endregion
 //#region src/merge-candidates.ts
@@ -3183,11 +3272,12 @@ function contentHash(content) {
 *    refresh strength to 1.0, handle sources normally.
 * 3. newId is novel: create new memory with source="consolidation".
 */
-async function executeMerge(db, pair, contentProducer, embedder) {
+async function executeMerge(db, pair, contentProducer, embedder, log = nullLogger) {
 	if (pair.a === pair.b) throw new Error(`Merge failed: cannot merge memory with itself (${pair.a})`);
 	const memA = db.getMemory(pair.a);
 	const memB = db.getMemory(pair.b);
 	if (!memA || !memB) throw new Error(`Merge failed: memory not found (${pair.a}, ${pair.b})`);
+	if (log.isDebugEnabled()) log.debug(`merge: combining: A: "${preview(memA.content, 100)}" B: "${preview(memB.content, 100)}"`);
 	const merged = await contentProducer({
 		id: memA.id,
 		content: memA.content,
@@ -3208,15 +3298,19 @@ async function executeMerge(db, pair, contentProducer, embedder) {
 	} catch {}
 	return db.transaction(() => {
 		let canonicalId;
+		let outcome;
 		if (isAbsorption) {
+			outcome = "absorption";
 			canonicalId = newId;
 			db.updateStrength(canonicalId, 1);
 		} else {
 			const existing = db.getMemory(newId);
 			if (existing) {
+				outcome = "reuse";
 				if (existing.content !== merged.content) throw new Error(`Merge failed: hash collision for ${newId} with different content`);
 				db.updateStrength(newId, 1);
 			} else {
+				outcome = "new";
 				db.insertMemory({
 					id: newId,
 					type: merged.type,
@@ -3250,6 +3344,11 @@ async function executeMerge(db, pair, contentProducer, embedder) {
 			}
 		}
 		inheritAssociations(db, [memA.id, memB.id], canonicalId, now);
+		log.info(`merge: ${outcome} (${pair.a.slice(0, 8)}… + ${pair.b.slice(0, 8)}…) → "${preview(merged.content, 80)}" (${canonicalId.slice(0, 8)}…)`);
+		if (log.isDebugEnabled()) {
+			if (originalsWeakened.length > 0) log.debug(`merge: weakened originals: ${originalsWeakened.map((id) => id.slice(0, 8) + "…").join(", ")}`);
+			if (intermediatesDeleted.length > 0) log.debug(`merge: deleted intermediates: ${intermediatesDeleted.map((id) => id.slice(0, 8) + "…").join(", ")}`);
+		}
 		return {
 			newMemoryId: canonicalId,
 			mergedFrom: [pair.a, pair.b],
@@ -3265,18 +3364,19 @@ async function executeMerge(db, pair, contentProducer, embedder) {
 * Pairs are processed in order (highest score first).
 * Skips pairs where either memory was already consumed.
 */
-async function executeMerges(db, pairs, contentProducer, embedder) {
+async function executeMerges(db, pairs, contentProducer, embedder, log = nullLogger) {
 	const consumed = /* @__PURE__ */ new Set();
 	const results = [];
 	for (const pair of pairs) {
 		if (consumed.has(pair.a) || consumed.has(pair.b)) continue;
 		if (!db.getMemory(pair.a) || !db.getMemory(pair.b)) continue;
-		const result = await executeMerge(db, pair, contentProducer, embedder);
+		const result = await executeMerge(db, pair, contentProducer, embedder, log);
 		results.push(result);
 		consumed.add(pair.a);
 		consumed.add(pair.b);
 		consumed.add(result.newMemoryId);
 	}
+	if (results.length > 0) log.info(`merge: ${results.length} merges completed`);
 	return results;
 }
 function isIntermediate(mem) {
@@ -3339,6 +3439,7 @@ function inheritAssociations(db, sourceIds, canonicalId, now) {
 */
 async function runConsolidation(params) {
 	const start = Date.now();
+	const log = params.logger ?? nullLogger;
 	const consolidationCutoff = (/* @__PURE__ */ new Date()).toISOString();
 	const summary = {
 		catchUpDecayed: 0,
@@ -3350,6 +3451,7 @@ async function runConsolidation(params) {
 		transitioned: 0,
 		exposuresGc: 0
 	};
+	log.info("consolidation: starting");
 	params.db.transaction(() => {
 		const lastAt = params.db.getState("last_consolidation_at");
 		let lastConsolidationMs = null;
@@ -3357,13 +3459,13 @@ async function runConsolidation(params) {
 			const ms = new Date(lastAt).getTime();
 			if (Number.isFinite(ms)) lastConsolidationMs = ms;
 		}
-		summary.catchUpDecayed = applyCatchUpDecay(params.db, lastConsolidationMs);
-		summary.reinforced = applyReinforcement(params.db);
-		summary.decayed = applyDecay(params.db);
-		updateCoRetrievalAssociations(params.db);
-		updateTransitiveAssociations(params.db);
-		summary.transitioned = applyTemporalTransitions(params.db);
-		const pruneResult = applyPruning(params.db);
+		summary.catchUpDecayed = applyCatchUpDecay(params.db, lastConsolidationMs, Date.now(), log);
+		summary.reinforced = applyReinforcement(params.db, log);
+		summary.decayed = applyDecay(params.db, log);
+		updateCoRetrievalAssociations(params.db, log);
+		updateTransitiveAssociations(params.db, 100, log);
+		summary.transitioned = applyTemporalTransitions(params.db, log);
+		const pruneResult = applyPruning(params.db, log);
 		summary.pruned = pruneResult.memoriesPruned;
 		summary.prunedAssociations = pruneResult.associationsPruned;
 	});
@@ -3372,6 +3474,7 @@ async function runConsolidation(params) {
 			const lastAt = params.db.getState("last_consolidation_at");
 			const sourceMems = params.db.getMergeSources(MERGE_SOURCE_MIN_STRENGTH, lastAt);
 			const targetMems = params.db.getMergeTargets(MERGE_TARGET_MIN_STRENGTH);
+			log.debug(`merge: ${sourceMems.length} sources, ${targetMems.length} targets`);
 			const uniqueIds = [...new Set([...sourceMems, ...targetMems].map((m) => m.id))];
 			const embeddingMap = params.db.getEmbeddingsByIds(uniqueIds);
 			const toCandidate = (m) => ({
@@ -3381,14 +3484,19 @@ async function runConsolidation(params) {
 				embedding: embeddingMap.get(m.id) ?? null
 			});
 			const pairs = findMergeCandidatesDelta(sourceMems.map(toCandidate), targetMems.map(toCandidate));
-			if (pairs.length > 0) summary.merged = (await executeMerges(params.db, pairs, params.mergeContentProducer, params.embedder)).length;
+			if (pairs.length > 0) {
+				log.info(`merge: ${pairs.length} candidate pairs found`);
+				summary.merged = (await executeMerges(params.db, pairs, params.mergeContentProducer, params.embedder, log)).length;
+			}
 		}
 	} finally {
 		params.db.transaction(() => {
-			summary.exposuresGc = provenanceGC(params.db);
+			summary.exposuresGc = provenanceGC(params.db, 30, log);
 			params.db.setState("last_consolidation_at", consolidationCutoff);
 		});
 	}
+	const s = summary;
+	log.info(`consolidation: done in ${Date.now() - start}ms — reinforced=${s.reinforced} decayed=${s.decayed} pruned=${s.pruned}+${s.prunedAssociations} merged=${s.merged} transitioned=${s.transitioned}`);
 	return {
 		ok: true,
 		summary,
@@ -3581,6 +3689,111 @@ function feedbackEvidenceForRating(rating) {
 	};
 }
 //#endregion
+//#region src/llm-caller.ts
+const DEFAULTS = {
+	anthropic: {
+		model: "claude-haiku-4-5-20251001",
+		maxTokens: 2048
+	},
+	openai: {
+		model: "gpt-4o-mini",
+		maxTokens: 2048
+	}
+};
+/**
+* Call an LLM with a simple prompt → text response.
+* Throws on failure (network, auth, rate limit, timeout).
+*/
+async function callLlm(prompt, config) {
+	const { provider, apiKey } = config;
+	const model = config.model ?? DEFAULTS[provider].model;
+	const maxTokens = config.maxTokens ?? DEFAULTS[provider].maxTokens;
+	const timeoutMs = config.timeoutMs ?? 3e4;
+	if (provider === "anthropic") return callAnthropic(prompt, apiKey, model, maxTokens, timeoutMs);
+	return callOpenAi(prompt, apiKey, model, maxTokens, timeoutMs);
+}
+async function callAnthropic(prompt, apiKey, model, maxTokens, timeoutMs) {
+	const response = await fetchWithTimeout("https://api.anthropic.com/v1/messages", {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			"x-api-key": apiKey,
+			"anthropic-version": "2023-06-01"
+		},
+		body: JSON.stringify({
+			model,
+			max_tokens: maxTokens,
+			messages: [{
+				role: "user",
+				content: prompt
+			}]
+		})
+	}, timeoutMs);
+	if (!response.ok) {
+		const body = await response.text().catch(() => "");
+		throw new Error(`Anthropic API error ${response.status}: ${body.slice(0, 200)}`);
+	}
+	const text = (await response.json()).content?.filter((b) => b.type === "text")?.map((b) => b.text)?.join("") ?? "";
+	if (!text) throw new Error("Anthropic returned empty response");
+	return text;
+}
+async function callOpenAi(prompt, apiKey, model, maxTokens, timeoutMs) {
+	const response = await fetchWithTimeout("https://api.openai.com/v1/chat/completions", {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${apiKey}`
+		},
+		body: JSON.stringify({
+			model,
+			max_tokens: maxTokens,
+			messages: [{
+				role: "user",
+				content: prompt
+			}]
+		})
+	}, timeoutMs);
+	if (!response.ok) {
+		const body = await response.text().catch(() => "");
+		throw new Error(`OpenAI API error ${response.status}: ${body.slice(0, 200)}`);
+	}
+	const text = (await response.json()).choices?.[0]?.message?.content ?? "";
+	if (!text) throw new Error("OpenAI returned empty response");
+	return text;
+}
+async function fetchWithTimeout(url, init, timeoutMs) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	try {
+		return await fetch(url, {
+			...init,
+			signal: controller.signal
+		});
+	} catch (error) {
+		if (error instanceof DOMException && error.name === "AbortError") throw new Error(`LLM API call timed out after ${timeoutMs}ms`);
+		throw error;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/**
+* Extract an API key from OpenClaw auth profiles.
+* Tries the specified provider, falls back to the other.
+*/
+function resolveApiKey(authProfiles, preferredProvider) {
+	if (!authProfiles) return null;
+	for (const profile of Object.values(authProfiles)) if (profile.provider === preferredProvider && profile.key) return {
+		provider: preferredProvider,
+		apiKey: profile.key
+	};
+	const fallback = preferredProvider === "anthropic" ? "openai" : "anthropic";
+	for (const profile of Object.values(authProfiles)) if (profile.provider === fallback && profile.key) return {
+		provider: fallback,
+		apiKey: profile.key
+	};
+	return null;
+}
+//#endregion
 //#region src/context-engine.ts
 /**
 * Associative Memory Context Engine
@@ -3841,26 +4054,31 @@ function createAssociativeMemoryContextEngine(options) {
 			};
 		},
 		async afterTurn(params) {
-			if (!options.getDb || !options.ledger) {
-				options.logger?.warn("afterTurn() disabled: missing getDb or ledger");
-				return;
+			if (options.getDb && options.ledger) {
+				const turnFingerprint = userTurnKey(params.messages) ?? "empty";
+				const turnId = `${params.sessionId}:${params.prePromptMessageCount}:${turnFingerprint}`;
+				try {
+					processAfterTurn({
+						sessionId: params.sessionId,
+						turnId,
+						messages: params.messages,
+						prePromptMessageCount: params.prePromptMessageCount,
+						ledger: options.ledger,
+						db: options.getDb(),
+						logPath: options.getLogPath?.(),
+						isBm25Only: options.isBm25Only?.() ?? false
+					});
+					options.logger?.debug?.(`afterTurn: autoInjected=${options.ledger.autoInjected.size} searchResults=${options.ledger.searchResults.size} explicitlyOpened=${options.ledger.explicitlyOpened.size} storedThisTurn=${options.ledger.storedThisTurn.size}`);
+				} catch (error) {
+					options.logger?.warn("afterTurn() provenance write failed", error);
+				}
 			}
-			const turnFingerprint = userTurnKey(params.messages) ?? "empty";
-			const turnId = `${params.sessionId}:${params.prePromptMessageCount}:${turnFingerprint}`;
-			try {
-				processAfterTurn({
-					sessionId: params.sessionId,
-					turnId,
-					messages: params.messages,
-					prePromptMessageCount: params.prePromptMessageCount,
-					ledger: options.ledger,
-					db: options.getDb(),
-					logPath: options.getLogPath?.(),
-					isBm25Only: options.isBm25Only?.() ?? false
-				});
-				options.logger?.debug?.(`afterTurn: autoInjected=${options.ledger.autoInjected.size} searchResults=${options.ledger.searchResults.size} explicitlyOpened=${options.ledger.explicitlyOpened.size} storedThisTurn=${options.ledger.storedThisTurn.size}`);
-			} catch (error) {
-				options.logger?.warn("afterTurn() provenance write failed", error);
+			if (options.autoCapture) {
+				const turnContent = extractTurnContent(params.messages, params.prePromptMessageCount);
+				if (turnContent) {
+					const llmConfig = options.getLlmConfig?.();
+					if (llmConfig) extractAndStoreMemories(turnContent, llmConfig, getManager(), options.logger);
+				}
 			}
 		},
 		async ingest(_params) {
@@ -3927,6 +4145,158 @@ function checkSleepDebt(getDb) {
 		return "";
 	}
 }
+/** Maximum character length for the turn transcript sent to the extraction LLM. */
+const AUTO_CAPTURE_MAX_CHARS = 4e3;
+/**
+* Extract a concise turn summary from the current turn's messages.
+* Returns null if the turn has no meaningful user+assistant exchange.
+*
+* Only considers messages after `prePromptMessageCount` (current turn).
+* Aggregates ALL user and assistant messages (not just the last one).
+* Truncates long content to keep the extraction prompt manageable.
+*/
+function extractTurnContent(messages, prePromptMessageCount) {
+	const turnMessages = messages.slice(prePromptMessageCount);
+	const userText = extractRoleText(turnMessages, "user");
+	const assistantText = extractRoleText(turnMessages, "assistant");
+	if (!userText || !assistantText) return null;
+	if (userText.trim().length < 10 && assistantText.trim().length < 20) return null;
+	const { user: truncatedUser, assistant: truncatedAssistant } = truncatePair(userText, assistantText, AUTO_CAPTURE_MAX_CHARS);
+	return `User: ${truncatedUser}\n\nAssistant: ${truncatedAssistant}`;
+}
+/**
+* Aggregate all text content from messages with the given role.
+* Iterates forward to preserve chronological order.
+*/
+function extractRoleText(messages, role) {
+	const parts = [];
+	for (const msg of messages) {
+		if (msg == null || typeof msg !== "object") continue;
+		const m = msg;
+		if (m.role !== role || !m.content) continue;
+		if (typeof m.content === "string") parts.push(m.content);
+		else if (Array.isArray(m.content)) {
+			const texts = m.content.filter(isTextBlock).map((b) => b.text);
+			if (texts.length > 0) parts.push(texts.join("\n"));
+		}
+	}
+	return parts.length > 0 ? parts.join("\n\n") : null;
+}
+function truncatePair(userText, assistantText, maxTotal) {
+	if (userText.length + assistantText.length <= maxTotal) return {
+		user: userText,
+		assistant: assistantText
+	};
+	const half = Math.floor(maxTotal / 2);
+	if (userText.length <= half) return {
+		user: userText,
+		assistant: truncate(assistantText, maxTotal - userText.length)
+	};
+	if (assistantText.length <= half) return {
+		user: truncate(userText, maxTotal - assistantText.length),
+		assistant: assistantText
+	};
+	return {
+		user: truncate(userText, half),
+		assistant: truncate(assistantText, half)
+	};
+}
+function truncate(text, maxLen) {
+	if (text.length <= maxLen) return text;
+	return text.slice(0, maxLen - 3) + "...";
+}
+/** Extraction prompt sent to the LLM to distill facts from a conversation turn. */
+function buildExtractionPrompt(turnContent) {
+	return `You are a memory extraction system. Read the following conversation exchange and extract facts worth remembering long-term.
+
+Rules:
+- Extract durable information: preferences, personal background, goals, plans, work/project context, relationships, recurring patterns, commitments, events, or corrections to prior knowledge.
+- Facts can come from any source: user statements, tool outputs, environment details, project configuration, or confirmed assistant observations.
+- Do NOT extract: the current task request itself, ephemeral implementation details, assistant reasoning, pleasantries, or transient operational context.
+- Each fact should be a single, self-contained statement.
+- Most conversation turns contain nothing worth remembering long-term — returning an empty array is expected and correct. Only extract when there is clearly durable information.
+- Return a JSON array of objects, each with "type" and "content" fields.
+- Valid types: "preference", "about", "person", "event", "goal", "work", "fact"
+  - preference: tastes, values, styles, dislikes
+  - about: background, identity, skills, life situation
+  - person: people and relationships
+  - event: events, schedules, deadlines
+  - goal: objectives, plans, aspirations
+  - work: durable work/project context, constraints, architecture
+  - fact: other durable information (fallback)
+- Return ONLY the JSON array, nothing else.
+
+Example output:
+[{"type": "preference", "content": "User prefers TypeScript over JavaScript for backend work"}, {"type": "event", "content": "User is moving to Berlin in May 2026"}, {"type": "work", "content": "Project must support SQLite only, no Postgres"}]
+
+Conversation:
+${turnContent}`;
+}
+const VALID_FACT_TYPES = new Set([
+	"preference",
+	"about",
+	"person",
+	"event",
+	"goal",
+	"work",
+	"fact"
+]);
+/**
+* Parse the LLM's extraction response into validated facts.
+* Tolerant of minor formatting issues (markdown fences, trailing text).
+*/
+function parseExtractionResponse(response) {
+	let cleaned = response.trim();
+	cleaned = cleaned.replace(/^```(?:json)?\s*/i, "").replace(/\s*```\s*$/, "");
+	const start = cleaned.indexOf("[");
+	const end = cleaned.lastIndexOf("]");
+	if (start === -1 || end === -1 || end <= start) return [];
+	let parsed;
+	try {
+		parsed = JSON.parse(cleaned.slice(start, end + 1));
+	} catch {
+		return [];
+	}
+	if (!Array.isArray(parsed)) return [];
+	const facts = [];
+	for (const item of parsed) {
+		if (item == null || typeof item !== "object") continue;
+		const obj = item;
+		if (typeof obj.type !== "string" || typeof obj.content !== "string") continue;
+		if (!obj.content.trim()) continue;
+		const type = VALID_FACT_TYPES.has(obj.type) ? obj.type : "fact";
+		facts.push({
+			type,
+			content: obj.content.trim()
+		});
+	}
+	return facts;
+}
+/**
+* Extract facts from a conversation turn via LLM and store each as a memory.
+* Fire-and-forget — all errors are caught and logged.
+*/
+async function extractAndStoreMemories(turnContent, llmConfig, manager, logger) {
+	try {
+		const facts = parseExtractionResponse(await callLlm(buildExtractionPrompt(turnContent), llmConfig));
+		if (facts.length === 0) {
+			logger?.debug?.("auto-capture: LLM extracted 0 facts");
+			return;
+		}
+		for (const fact of facts) try {
+			await manager.store({
+				content: fact.content,
+				type: fact.type,
+				source: "auto_capture"
+			});
+		} catch (error) {
+			logger?.warn(`auto-capture: failed to store fact: ${fact.content.slice(0, 50)}`, error);
+		}
+		logger?.debug?.(`auto-capture: stored ${facts.length} facts`);
+	} catch (error) {
+		logger?.warn("auto-capture: LLM extraction failed", error);
+	}
+}
 /** Type guard for text content blocks in multimodal messages. */
 function isTextBlock(v) {
 	if (v == null || typeof v !== "object") return false;
@@ -4057,111 +4427,6 @@ var EmbeddingTimeoutError = class extends Error {
 	}
 };
 //#endregion
-//#region src/llm-caller.ts
-const DEFAULTS = {
-	anthropic: {
-		model: "claude-haiku-4-5-20251001",
-		maxTokens: 2048
-	},
-	openai: {
-		model: "gpt-4o-mini",
-		maxTokens: 2048
-	}
-};
-/**
-* Call an LLM with a simple prompt → text response.
-* Throws on failure (network, auth, rate limit, timeout).
-*/
-async function callLlm(prompt, config) {
-	const { provider, apiKey } = config;
-	const model = config.model ?? DEFAULTS[provider].model;
-	const maxTokens = config.maxTokens ?? DEFAULTS[provider].maxTokens;
-	const timeoutMs = config.timeoutMs ?? 3e4;
-	if (provider === "anthropic") return callAnthropic(prompt, apiKey, model, maxTokens, timeoutMs);
-	return callOpenAi(prompt, apiKey, model, maxTokens, timeoutMs);
-}
-async function callAnthropic(prompt, apiKey, model, maxTokens, timeoutMs) {
-	const response = await fetchWithTimeout("https://api.anthropic.com/v1/messages", {
-		method: "POST",
-		headers: {
-			"Content-Type": "application/json",
-			"x-api-key": apiKey,
-			"anthropic-version": "2023-06-01"
-		},
-		body: JSON.stringify({
-			model,
-			max_tokens: maxTokens,
-			messages: [{
-				role: "user",
-				content: prompt
-			}]
-		})
-	}, timeoutMs);
-	if (!response.ok) {
-		const body = await response.text().catch(() => "");
-		throw new Error(`Anthropic API error ${response.status}: ${body.slice(0, 200)}`);
-	}
-	const text = (await response.json()).content?.filter((b) => b.type === "text")?.map((b) => b.text)?.join("") ?? "";
-	if (!text) throw new Error("Anthropic returned empty response");
-	return text;
-}
-async function callOpenAi(prompt, apiKey, model, maxTokens, timeoutMs) {
-	const response = await fetchWithTimeout("https://api.openai.com/v1/chat/completions", {
-		method: "POST",
-		headers: {
-			"Content-Type": "application/json",
-			Authorization: `Bearer ${apiKey}`
-		},
-		body: JSON.stringify({
-			model,
-			max_tokens: maxTokens,
-			messages: [{
-				role: "user",
-				content: prompt
-			}]
-		})
-	}, timeoutMs);
-	if (!response.ok) {
-		const body = await response.text().catch(() => "");
-		throw new Error(`OpenAI API error ${response.status}: ${body.slice(0, 200)}`);
-	}
-	const text = (await response.json()).choices?.[0]?.message?.content ?? "";
-	if (!text) throw new Error("OpenAI returned empty response");
-	return text;
-}
-async function fetchWithTimeout(url, init, timeoutMs) {
-	const controller = new AbortController();
-	const timer = setTimeout(() => controller.abort(), timeoutMs);
-	try {
-		return await fetch(url, {
-			...init,
-			signal: controller.signal
-		});
-	} catch (error) {
-		if (error instanceof DOMException && error.name === "AbortError") throw new Error(`LLM API call timed out after ${timeoutMs}ms`);
-		throw error;
-	} finally {
-		clearTimeout(timer);
-	}
-}
-/**
-* Extract an API key from OpenClaw auth profiles.
-* Tries the specified provider, falls back to the other.
-*/
-function resolveApiKey(authProfiles, preferredProvider) {
-	if (!authProfiles) return null;
-	for (const profile of Object.values(authProfiles)) if (profile.provider === preferredProvider && profile.key) return {
-		provider: preferredProvider,
-		apiKey: profile.key
-	};
-	const fallback = preferredProvider === "anthropic" ? "openai" : "anthropic";
-	for (const profile of Object.values(authProfiles)) if (profile.provider === fallback && profile.key) return {
-		provider: fallback,
-		apiKey: profile.key
-	};
-	return null;
-}
-//#endregion
 //#region src/memory-manager.ts
 var MemoryManager = class {
 	db;
@@ -9786,6 +10051,7 @@ MarkdownIt.prototype.renderInline = function(src, env) {
 * Uses markdown-it for reliable parsing (handles code blocks, frontmatter, CRLF).
 */
 const DATE_FILENAME_RE = /^(\d{4}-\d{2}-\d{2})\.md$/;
+const DATE_ISO_RE = /^\d{4}-\d{2}-\d{2}/;
 const FRONTMATTER_RE = /^\uFEFF?---[ \t]*\r?\n[\s\S]*?\r?\n---[ \t]*\r?\n/;
 const MAX_SEGMENT_CHARS = 2e3;
 const MIN_SEGMENT_CHARS = 200;
@@ -9882,6 +10148,7 @@ function segmentMarkdown(content, filePath, workspaceDir) {
 		heading_level: seg.headingLevel,
 		date: fileDate,
 		evergreen: isEvergreen,
+		session: false,
 		content: seg.content,
 		char_count: seg.content.length
 	}));
@@ -10019,6 +10286,126 @@ function mergeSmallSegments(segments) {
 	}
 	return result;
 }
+/**
+* Discover JSONL session files in the agent's sessions directory.
+* Only imports canonical live session files (*.jsonl).
+* Excludes archive variants (.reset.*, .deleted.*), backups (.bak.*),
+* and lock files to avoid duplicate extraction from the same session.
+*/
+function discoverSessionFiles(sessionsDir) {
+	if (!existsSync(sessionsDir) || !statSync(sessionsDir).isDirectory()) return [];
+	const found = [];
+	let entries;
+	try {
+		entries = readdirSync(sessionsDir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+	for (const entry of entries) {
+		if (!entry.isFile()) continue;
+		const name = entry.name;
+		if (name.endsWith(".jsonl") && name !== "sessions.json") found.push(join(sessionsDir, name));
+	}
+	found.sort((a, b) => a.localeCompare(b));
+	return found;
+}
+/**
+* Parse a JSONL session file and extract conversation turns as ImportSegments.
+*
+* Strategy:
+* - Extract user and assistant text messages (skip tool calls, thinking, system)
+* - Group consecutive messages into conversation chunks
+* - Apply the same size limits as markdown segmentation
+* - Use the session timestamp for dating
+*/
+function parseSessionJsonl(content, filePath, sessionsDir) {
+	const lines = content.split("\n").filter((l) => l.trim());
+	if (lines.length === 0) return [];
+	const relPath = toPosixRelative(dirname(sessionsDir), filePath);
+	let sessionDate = null;
+	const turns = [];
+	for (const line of lines) {
+		let entry;
+		try {
+			entry = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (!sessionDate && entry.timestamp) {
+			const match = DATE_ISO_RE.exec(entry.timestamp);
+			if (match) sessionDate = match[0];
+		}
+		if (entry.type !== "message" || !entry.message) continue;
+		const { role, content: msgContent } = entry.message;
+		if (role !== "user" && role !== "assistant") continue;
+		const text = extractTextFromContent(msgContent);
+		if (!text.trim()) continue;
+		turns.push({
+			role,
+			text: text.trim(),
+			timestamp: entry.timestamp ?? null
+		});
+	}
+	if (turns.length === 0) return [];
+	return groupTurnsIntoExchanges(turns, relPath, sessionDate);
+}
+function extractTextFromContent(content) {
+	if (!content) return "";
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.filter((block) => block.type === "text" && block.text).map((block) => block.text).join("\n\n");
+}
+/**
+* Group parsed turns into exchanges and produce one ImportSegment per exchange.
+*
+* An exchange starts at each user turn and collects all following assistant turns
+* until the next user turn. Consecutive user turns without an assistant reply
+* are merged into a single exchange with the next assistant response.
+*
+* Each exchange becomes one segment formatted as "User: ...\n\nAssistant: ..."
+* — preserving the natural conversational boundary for LLM fact extraction.
+*/
+function groupTurnsIntoExchanges(turns, relPath, sessionDate) {
+	const exchanges = [];
+	let currentUserParts = [];
+	let currentAssistantParts = [];
+	let exchangeTimestamp = null;
+	const flushExchange = () => {
+		if (currentUserParts.length > 0 && currentAssistantParts.length > 0) exchanges.push({
+			userText: currentUserParts.join("\n\n"),
+			assistantText: currentAssistantParts.join("\n\n"),
+			timestamp: exchangeTimestamp
+		});
+		currentUserParts = [];
+		currentAssistantParts = [];
+		exchangeTimestamp = null;
+	};
+	for (const turn of turns) if (turn.role === "user") {
+		if (currentAssistantParts.length > 0) flushExchange();
+		currentUserParts.push(turn.text);
+		if (!exchangeTimestamp) exchangeTimestamp = turn.timestamp;
+	} else currentAssistantParts.push(turn.text);
+	flushExchange();
+	return exchanges.map((ex, i) => {
+		const content = `User: ${ex.userText}\n\nAssistant: ${ex.assistantText}`;
+		return {
+			id: i,
+			source_file: relPath,
+			heading: null,
+			heading_level: null,
+			date: extractDateFromTimestamp(ex.timestamp) ?? sessionDate,
+			evergreen: false,
+			session: true,
+			content,
+			char_count: content.length
+		};
+	});
+}
+function extractDateFromTimestamp(timestamp) {
+	if (!timestamp) return null;
+	const match = DATE_ISO_RE.exec(timestamp);
+	return match ? match[0] : null;
+}
 function isEvergreenFile(filePath, workspaceDir) {
 	const rel = relative(workspaceDir, filePath);
 	return basename(filePath).toLowerCase() === "memory.md" && dirname(rel) === ".";
@@ -10031,8 +10418,11 @@ function extractDateFromFilename(filename) {
 * Preprocess memory-core files: discover, segment, extract metadata.
 * Returns segments ready for LLM enrichment and storage.
 * Continues processing on per-file errors; collects errors in result.
+*
+* @param sessionsDir - Optional path to OpenClaw sessions directory
+*   (e.g. ~/.openclaw/agents/<agentId>/sessions/) for JSONL import.
 */
-function prepareImport(workspaceDir, extraPaths) {
+function prepareImport(workspaceDir, extraPaths, sessionsDir) {
 	const files = discoverMemoryFiles(workspaceDir, extraPaths);
 	const allSegments = [];
 	const fileInfos = [];
@@ -10056,6 +10446,27 @@ function prepareImport(workspaceDir, extraPaths) {
 			error: err instanceof Error ? err.message : String(err)
 		});
 	}
+	if (sessionsDir) {
+		const sessionFiles = discoverSessionFiles(sessionsDir);
+		for (const filePath of sessionFiles) try {
+			const renumbered = parseSessionJsonl(readFileSync(filePath, "utf8"), filePath, sessionsDir).map((seg) => ({
+				...seg,
+				id: globalId++
+			}));
+			allSegments.push(...renumbered);
+			fileInfos.push({
+				path: toPosixRelative(dirname(sessionsDir), filePath),
+				segmentCount: renumbered.length,
+				evergreen: false,
+				date: renumbered[0]?.date ?? null
+			});
+		} catch (err) {
+			errors.push({
+				path: toPosixRelative(dirname(sessionsDir), filePath),
+				error: err instanceof Error ? err.message : String(err)
+			});
+		}
+	}
 	return {
 		segments: allSegments,
 		files: fileInfos,
@@ -10099,14 +10510,14 @@ function calculateImportStrength(segmentDate) {
 * Run the memory-core migration. Idempotent — checks db state before proceeding.
 */
 async function runMigration(deps) {
-	const { workspaceDir, store, dbState, enrich, logger, extraPaths } = deps;
+	const { workspaceDir, store, dbState, enrich, logger, extraPaths, sessionsDir } = deps;
 	const completedAt = dbState.get(STATE_KEY_COMPLETED);
 	if (completedAt) {
 		logger.info(`Memory migration already completed at ${completedAt}`);
 		return { status: "skipped" };
 	}
 	logger.info("Scanning for memory-core files...");
-	const result = prepareImport(workspaceDir, extraPaths);
+	const result = prepareImport(workspaceDir, extraPaths, sessionsDir);
 	if (result.errors.length > 0) for (const err of result.errors) logger.warn(`Could not read ${err.path}: ${err.error}`);
 	if (result.totalSegments === 0) {
 		logger.info("No memory-core files found. Will re-check on next startup.");
@@ -10117,10 +10528,12 @@ async function runMigration(deps) {
 		};
 	}
 	logger.info(`Found ${result.files.length} files, ${result.totalSegments} segments. Starting migration...`);
+	const mdSegments = result.segments.filter((s) => !s.session);
+	const sessionSegments = result.segments.filter((s) => s.session);
 	let importedCount = 0;
 	const importErrors = [];
-	for (let i = 0; i < result.segments.length; i += BATCH_SIZE) {
-		const batch = result.segments.slice(i, i + BATCH_SIZE);
+	for (let i = 0; i < mdSegments.length; i += BATCH_SIZE) {
+		const batch = mdSegments.slice(i, i + BATCH_SIZE);
 		try {
 			const stored = await storeBatch(batch, await enrichBatch(batch, enrich, logger), store, logger, deps.updateStrength);
 			importedCount += stored;
@@ -10138,6 +10551,11 @@ async function runMigration(deps) {
 			}
 		}
 	}
+	if (sessionSegments.length > 0) {
+		const extracted = await extractSessionSegments(sessionSegments, store, deps.llmCall, logger, deps.updateStrength);
+		importedCount += extracted.stored;
+		if (extracted.errors.length > 0) importErrors.push(...extracted.errors);
+	}
 	if (importErrors.length === 0) dbState.set(STATE_KEY_COMPLETED, (/* @__PURE__ */ new Date()).toISOString());
 	dbState.set(STATE_KEY_SOURCE_COUNT, String(result.files.length));
 	dbState.set(STATE_KEY_SEGMENT_COUNT, String(importedCount));
@@ -10209,6 +10627,47 @@ function applyImportDecay(id, date, updateStrength) {
 	const strength = calculateImportStrength(date);
 	if (strength < 1) updateStrength(id, strength);
 }
+/**
+* Process JSONL session segments by extracting facts via LLM.
+* Uses the same extraction pipeline as autoCapture (buildExtractionPrompt/parseExtractionResponse).
+* Each segment's conversation exchange is sent to the LLM, which distills durable facts.
+* Requires llmCall — session import is skipped without LLM.
+*/
+async function extractSessionSegments(segments, store, llmCall, logger, updateStrength) {
+	if (!llmCall) {
+		logger.warn("Session import skipped: LLM extraction required but llmCall not available");
+		return {
+			stored: 0,
+			errors: []
+		};
+	}
+	let stored = 0;
+	const errors = [];
+	for (const seg of segments) try {
+		const facts = parseExtractionResponse(await llmCall(buildExtractionPrompt(seg.content)));
+		if (facts.length === 0) continue;
+		for (const fact of facts) try {
+			applyImportDecay((await store({
+				content: fact.content,
+				type: fact.type,
+				source: "import",
+				temporal_state: seg.date ? "past" : "none",
+				temporal_anchor: seg.date
+			})).id, seg.date, updateStrength);
+			stored++;
+		} catch (err) {
+			logger.warn(`Failed to store extracted fact from segment ${seg.id}: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	} catch (err) {
+		const msg = `Session segment ${seg.id} extraction failed: ${err instanceof Error ? err.message : String(err)}`;
+		logger.error(msg);
+		errors.push(msg);
+	}
+	return {
+		stored,
+		errors
+	};
+}
 function inferType(seg) {
 	if (seg.evergreen) return "fact";
 	if (seg.date) return "observation";
@@ -10353,11 +10812,11 @@ async function cleanupWorkspaceFiles(deps) {
 			hadFailure = true;
 			continue;
 		}
-		const backupPath = `${file.path}.pre-associative-memory`;
+		const backupPath = `${file.path}.pre-formative-memory`;
 		if (!existsSync(backupPath)) copyFileSync(file.path, backupPath);
 		writeFileSync(file.path, cleaned, "utf-8");
 		modified.push(file.name);
-		logger.info(`Cleaned ${file.name} (backup: ${file.name}.pre-associative-memory)`);
+		logger.info(`Cleaned ${file.name} (backup: ${file.name}.pre-formative-memory)`);
 	} catch (err) {
 		logger.warn(`Failed to clean ${file.name}: ${err instanceof Error ? err.message : String(err)}`);
 		hadFailure = true;
@@ -10396,53 +10855,6 @@ Here is the current content of ${fileName}:
 ${content}`;
 }
 //#endregion
-//#region src/logger.ts
-const LEVEL_ORDER = {
-	debug: 0,
-	info: 1,
-	warn: 2,
-	error: 3
-};
-/**
-* Create a logger that forwards to the host logger at or above the
-* configured minimum level.
-*/
-function createLogger(opts) {
-	const envDebug = process.env.FORMATIVE_MEMORY_DEBUG === "1";
-	const minOrder = LEVEL_ORDER[opts.verbose || envDebug ? "debug" : "info"];
-	const host = opts.host;
-	function stringifyArg(a) {
-		if (a instanceof Error) return a.stack || a.message;
-		if (typeof a === "object" && a !== null) try {
-			return JSON.stringify(a);
-		} catch {
-			return "[Unserializable]";
-		}
-		return String(a);
-	}
-	function emit(level, msg, args) {
-		if (LEVEL_ORDER[level] < minOrder) return;
-		const prefix = `[formative-memory] [${level}]`;
-		if (host) {
-			const line = `${prefix} ${msg}${args.length > 0 ? " " + args.map(stringifyArg).join(" ") : ""}`;
-			if (level === "debug") (host.debug ?? host.info)(line);
-			else host[level](line);
-		} else {
-			const line = `${prefix} ${msg}`;
-			if (level === "error") console.error(line, ...args);
-			else if (level === "warn") console.warn(line, ...args);
-			else console.log(line, ...args);
-		}
-	}
-	return {
-		debug: (msg, ...args) => emit("debug", msg, args),
-		info: (msg, ...args) => emit("info", msg, args),
-		warn: (msg, ...args) => emit("warn", msg, args),
-		error: (msg, ...args) => emit("error", msg, args),
-		isDebugEnabled: () => minOrder === LEVEL_ORDER.debug
-	};
-}
-//#endregion
 //#region src/turn-memory-ledger.ts
 /**
 * Turn Memory Ledger (Phase 3.4)
@@ -10590,6 +11002,7 @@ function resolveMemoryDir(config, workspaceDir, pathResolver) {
 	if (isAbsolute(dbPath)) return dbPath;
 	return join(workspaceDir, dbPath);
 }
+const EMBEDDING_REQUIRED_HINT = "Embedding provider required but not available.\nSet one of: OPENAI_API_KEY, GEMINI_API_KEY, VOYAGE_API_KEY, or MISTRAL_API_KEY.\nTo run without embeddings (BM25-only), set \"requireEmbedding\": false in plugin config.";
 /**
 * Try to create an embedding provider directly via SDK factory functions.
 * Used when the memory-core plugin is disabled and the global registry is empty.
@@ -10676,11 +11089,13 @@ function createWorkspace(config, workspaceDir, openclawConfig, agentDir, logger,
 	let providerPromise = null;
 	const getProvider = () => {
 		if (!providerPromise) providerPromise = resolveEmbeddingProvider(config.embedding.provider, openclawConfig, agentDir, config.embedding.model).catch((err) => {
+			if (config.requireEmbedding) throw new Error(`${EMBEDDING_REQUIRED_HINT}\nDetails: ${err instanceof Error ? err.message : String(err)}`);
 			providerPromise = null;
 			throw err;
 		});
 		return providerPromise;
 	};
+	if (config.requireEmbedding) getProvider().catch(() => {});
 	const ws = {
 		manager: new MemoryManager(memoryDir, { async embed(text) {
 			const provider = await getProvider();
@@ -10709,6 +11124,12 @@ function createWorkspace(config, workspaceDir, openclawConfig, agentDir, logger,
 		} catch (err) {
 			logger?.warn(`Workspace cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
 		}
+		if (config.requireEmbedding) try {
+			await getProvider();
+		} catch (err) {
+			logger?.error(`Migration aborted: embedding required but unavailable. ${err instanceof Error ? err.message : String(err)}`);
+			return;
+		}
 		try {
 			const userLanguage = detectUserLanguage(workspaceDir);
 			const enrichFn = initDeps.llmConfig ? createDirectLlmEnrichFn(initDeps.llmConfig, userLanguage) : async (segments) => segments.map((seg) => ({
@@ -10717,6 +11138,7 @@ function createWorkspace(config, workspaceDir, openclawConfig, agentDir, logger,
 				temporal_state: seg.date ? "past" : "none",
 				temporal_anchor: seg.date
 			}));
+			const sessionsDir = agentDir ? join(agentDir, "sessions") : void 0;
 			const migrationResult = await runMigration({
 				workspaceDir,
 				stateDir: initDeps.stateDir ?? workspaceDir,
@@ -10728,7 +11150,9 @@ function createWorkspace(config, workspaceDir, openclawConfig, agentDir, logger,
 					info: () => {},
 					warn: () => {},
 					error: () => {}
-				}
+				},
+				sessionsDir,
+				llmCall: initDeps.llmConfig ? (prompt) => callLlm(prompt, initDeps.llmConfig) : void 0
 			});
 			if (migrationResult.status === "completed") logger?.info(`Migration: imported ${migrationResult.segmentsImported} memories from ${migrationResult.filesFound} files`);
 		} catch (err) {
@@ -10872,8 +11296,8 @@ function createMemoryTools(getManager, getLogPath, ledger) {
 	];
 }
 const associativeMemoryPlugin = {
-	id: "memory-associative",
-	name: "Memory (Associative)",
+	id: "formative-memory",
+	name: "Formative Memory",
 	description: "Biologically-inspired associative memory with consolidation and temporal awareness",
 	kind: "memory",
 	configSchema: memoryConfigSchema,
@@ -10946,7 +11370,9 @@ const associativeMemoryPlugin = {
 			logger: log,
 			ledger,
 			getDb: () => getWorkspace(".").manager.getDatabase(),
-			getLogPath: () => join(getWorkspace(".").memoryDir, "retrieval.log")
+			getLogPath: () => join(getWorkspace(".").memoryDir, "retrieval.log"),
+			autoCapture: config.autoCapture,
+			getLlmConfig: () => resolveLlmConfig(runtimePaths.stateDir, runtimePaths.agentDir, log)
 		}));
 		api.registerCommand({
 			name: "memory-sleep",
@@ -10965,9 +11391,9 @@ const associativeMemoryPlugin = {
 					log.debug("consolidation: starting trigger=command");
 					const result = await runConsolidation({
 						db: ws.manager.getDatabase(),
-						mergeContentProducer
+						mergeContentProducer,
+						logger: log
 					});
-					log.debug(`consolidation: completed trigger=command durationMs=${result.durationMs}`);
 					const s = result.summary;
 					const catchUpInfo = s.catchUpDecayed > 0 ? `Catch-up decayed: ${s.catchUpDecayed}, ` : "";
 					return { text: `Memory consolidation complete (${result.durationMs}ms).\n` + catchUpInfo + `Reinforced: ${s.reinforced}, Decayed: ${s.decayed}, Pruned: ${s.pruned} memories + ${s.prunedAssociations} associations, Merged: ${s.merged}, Transitioned: ${s.transitioned}, Exposure GC: ${s.exposuresGc}` };
@@ -10992,6 +11418,7 @@ const associativeMemoryPlugin = {
 					temporal_anchor: seg.date
 				}));
 				db.setState("migration_completed_at", "");
+				const sessionsDir = runtimePaths.agentDir ? join(runtimePaths.agentDir, "sessions") : void 0;
 				const result = await runMigration({
 					workspaceDir: ".",
 					stateDir: runtimePaths.stateDir ?? ".",
@@ -11002,7 +11429,9 @@ const associativeMemoryPlugin = {
 						set: (key, value) => db.setState(key, value)
 					},
 					enrich: enrichFn,
-					logger: log
+					logger: log,
+					sessionsDir,
+					llmCall: llmConfig ? (prompt) => callLlm(prompt, llmConfig) : void 0
 				});
 				if (result.status === "completed") return { text: `Migration complete: imported ${result.segmentsImported} memories from ${result.filesFound} files` + (result.errors?.length ? ` (${result.errors.length} errors)` : "") };
 				return { text: `Migration: ${result.status}` };
@@ -11034,7 +11463,7 @@ const associativeMemoryPlugin = {
 		/** Cron job name (used to find/update managed jobs). */
 		const CONSOLIDATION_CRON_NAME = "Associative Memory Consolidation";
 		/** Tag in description to identify managed jobs. */
-		const CONSOLIDATION_CRON_TAG = "[managed-by=memory-associative.consolidation]";
+		const CONSOLIDATION_CRON_TAG = "[managed-by=formative-memory.consolidation]";
 		/** Default cron expression: daily at 03:00. */
 		const DEFAULT_CONSOLIDATION_CRON = "0 3 * * *";
 		/** System event token for cron-triggered temporal transitions. */
@@ -11042,7 +11471,7 @@ const associativeMemoryPlugin = {
 		/** Cron job name for temporal transitions. */
 		const TEMPORAL_CRON_NAME = "Associative Memory Temporal Transitions";
 		/** Tag to identify managed temporal jobs. */
-		const TEMPORAL_CRON_TAG = "[managed-by=memory-associative.temporal]";
+		const TEMPORAL_CRON_TAG = "[managed-by=formative-memory.temporal]";
 		/** Cron expression: daily at 15:00 (03:00 is covered by full consolidation). */
 		const DEFAULT_TEMPORAL_CRON = "0 15 * * *";
 		api.registerHook("gateway:startup", async (event) => {
@@ -11112,13 +11541,13 @@ const associativeMemoryPlugin = {
 			} catch (err) {
 				log.warn(`Failed to register consolidation cron: ${err instanceof Error ? err.message : String(err)}`);
 			}
-		}, { name: "memory-associative-consolidation-cron" });
+		}, { name: "formative-memory-consolidation-cron" });
 		api.on("before_agent_reply", async (event, ctx) => {
 			const body = event?.cleanedBody;
 			if (!body) return;
 			if (body.includes(TEMPORAL_CRON_TRIGGER) && !body.includes(CONSOLIDATION_CRON_TRIGGER)) try {
 				const db = getWorkspace(ctx?.workspaceDir ?? ".").manager.getDatabase();
-				const count = db.transaction(() => applyTemporalTransitions(db));
+				const count = db.transaction(() => applyTemporalTransitions(db, log));
 				if (count > 0) log.info(`Scheduled temporal transitions: ${count} transitioned`);
 				return {
 					handled: true,
@@ -11144,20 +11573,14 @@ const associativeMemoryPlugin = {
 					};
 				} : void 0;
 				const db = ws.manager.getDatabase();
-				const temporalCount = db.transaction(() => applyTemporalTransitions(db));
 				log.debug("consolidation: starting trigger=cron");
-				const result = await runConsolidation({
-					db,
-					mergeContentProducer
-				});
-				log.debug(`consolidation: completed trigger=cron durationMs=${result.durationMs}`);
-				const s = result.summary;
-				const catchUpInfo = s.catchUpDecayed > 0 ? `Catch-up decayed: ${s.catchUpDecayed}, ` : "";
-				const temporalInfo = temporalCount > 0 ? `, Temporal transitions (extra): ${temporalCount}` : "";
-				log.info(`Scheduled consolidation complete (${result.durationMs}ms): ${catchUpInfo}Reinforced: ${s.reinforced}, Decayed: ${s.decayed}, Pruned: ${s.pruned}+${s.prunedAssociations}, Merged: ${s.merged}${temporalInfo}`);
 				return {
 					handled: true,
-					reply: { text: `Memory consolidation complete (${result.durationMs}ms).` },
+					reply: { text: `Memory consolidation complete (${(await runConsolidation({
+						db,
+						mergeContentProducer,
+						logger: log
+					})).durationMs}ms).` },
 					reason: "associative-memory-consolidation"
 				};
 			} catch (err) {
@@ -11170,7 +11593,7 @@ const associativeMemoryPlugin = {
 			}
 		});
 		api.registerService({
-			id: "memory-associative-startup",
+			id: "formative-memory-startup",
 			async start(ctx) {
 				runtimePaths.stateDir = ctx.stateDir;
 			}