@oh-my-pi/pi-mnemopi 18.8.9 → 18.9.0

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [18.9.0] - 2026-10-11
+
+### Added
+
+- Exported `clipRecallContent` for applications that need to format content consistently with Mnemopi recall previews.
+
+### Fixed
+
+- Fixed memory-save performance degradation and excessive memory-database growth when date-related terms such as “today” appeared in otherwise unrelated memories.
+
 ## [18.8.8] - 2026-10-10
 
 ### Fixed

package/dist/types/core/beam/index.d.ts

@@ -1,6 +1,7 @@
 import type { Database } from "bun:sqlite";
 import type { VeracityConsolidator } from "../veracity-consolidation.js";
 import type { BeamCaches, BeamConfig, BeamEvent, BeamMemoryOptions, BeamMemoryState, BeamStats, ImportStats, MemoriaRetrieveResult, Metadata, RecallEnhancedOptions, RecallOptions, RecallResult, RememberBatchItem, RememberBatchOptions, RememberOptions, SleepResult } from "./types.js";
+export { clipRecallContent } from "./recall.js";
 export { initBeam } from "./schema.js";
 export type * from "./types.js";
 export declare class BeamMemory implements BeamMemoryState {

package/dist/types/core/episodic-graph.d.ts

@@ -91,7 +91,6 @@ export declare class EpisodicGraph {
     private knownMemoryIds;
     private memoryContent;
     private entityOverlapScore;
-    private temporalContextScore;
     private memoryFeatures;
     private scoreFeatures;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-mnemopi",
-	"version": "18.8.9",
+	"version": "18.9.0",
 	"description": "Local SQLite memory engine for omp agents",
 	"homepage": "https://omp.sh",
 	"author": {
@@ -42,10 +42,10 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "18.8.9",
-		"@oh-my-pi/pi-catalog": "18.8.9",
-		"@oh-my-pi/pi-natives": "18.8.9",
-		"@oh-my-pi/pi-utils": "18.8.9"
+		"@oh-my-pi/pi-ai": "18.9.0",
+		"@oh-my-pi/pi-catalog": "18.9.0",
+		"@oh-my-pi/pi-natives": "18.9.0",
+		"@oh-my-pi/pi-utils": "18.9.0"
 	},
 	"peerDependencies": {
 		"fastembed": "3.0.0",

package/src/core/beam/helpers.ts

@@ -1,5 +1,5 @@
 import type { Database } from "bun:sqlite";
-import { logger } from "@oh-my-pi/pi-utils";
+import { logger, withLoopPhase } from "@oh-my-pi/pi-utils";
 import { generateId as generateTimedId, sha256Hex16, stableMemoryId } from "../../util/ids";
 import { cjkFtsTerms, containsSpacelessCjk, ftsQueryTerms, hasCjk, isCjkChar, recallTokens } from "../../util/regex";
 import { currentEmbeddingModel, embed } from "../embeddings";
@@ -727,29 +727,33 @@ async function runEmbedding(beam: BeamMemoryState, items: readonly EmbedItem[]):
 	try {
 		const matrix = await embed(items.map(item => item.content));
 		if (matrix === null) return;
-		const model = currentEmbeddingModel();
-		using insertEmbedding = beam.db.prepare(
-			"INSERT OR REPLACE INTO memory_embeddings(memory_id, embedding_json, model) VALUES (?, ?, ?)",
-		);
-		let committed = 0;
-		const insertMany = beam.db.transaction((rows: readonly EmbedItem[]) => {
-			for (let i = 0; i < rows.length; i += 1) {
-				const vector = matrix[i];
-				const item = rows[i];
-				if (vector === undefined || item === undefined) continue;
-				insertEmbedding.run(item.memoryId, JSON.stringify(Array.from(vector)), model);
-				committed += 1;
-			}
+		// Persisting the vectors runs synchronously on the caller's event loop; label it so a
+		// stall is attributable. The embedding itself is awaited above, outside the label.
+		withLoopPhase("mnemopi.embed-persist", () => {
+			const model = currentEmbeddingModel();
+			using insertEmbedding = beam.db.prepare(
+				"INSERT OR REPLACE INTO memory_embeddings(memory_id, embedding_json, model) VALUES (?, ?, ?)",
+			);
+			let committed = 0;
+			const insertMany = beam.db.transaction((rows: readonly EmbedItem[]) => {
+				for (let i = 0; i < rows.length; i += 1) {
+					const vector = matrix[i];
+					const item = rows[i];
+					if (vector === undefined || item === undefined) continue;
+					insertEmbedding.run(item.memoryId, JSON.stringify(Array.from(vector)), model);
+					committed += 1;
+				}
+			});
+			insertMany(items);
+			// A recall taken while these vectors were still generating cached an FTS-only ranking, and
+			// committing vectors changes what recall returns -- so that cache must be dropped, or the
+			// pre-embedding order keeps being served for the whole cache TTL. Gated on `committed`: a
+			// batch whose provider returned a short or empty matrix inserts nothing, changes no ranking,
+			// and invalidating there would only discard a still-valid cache. Only the query cache is
+			// affected; the polyphonic subject dictionary is built from facts/gists, which an embedding
+			// batch never touches.
+			if (committed > 0) beam.caches.queryCache?.invalidate();
 		});
-		insertMany(items);
-		// A recall taken while these vectors were still generating cached an FTS-only ranking, and
-		// committing vectors changes what recall returns -- so that cache must be dropped, or the
-		// pre-embedding order keeps being served for the whole cache TTL. Gated on `committed`: a
-		// batch whose provider returned a short or empty matrix inserts nothing, changes no ranking,
-		// and invalidating there would only discard a still-valid cache. Only the query cache is
-		// affected; the polyphonic subject dictionary is built from facts/gists, which an embedding
-		// batch never touches.
-		if (committed > 0) beam.caches.queryCache?.invalidate();
 	} catch (error) {
 		// Background embedding generation is best-effort: a failing provider, a closed DB
 		// during shutdown, or a transient API error must never disrupt the synchronous

package/src/core/beam/index.ts

@@ -57,6 +57,7 @@ import type {
 	SleepResult,
 } from "./types";
 
+export { clipRecallContent } from "./recall";
 export { initBeam } from "./schema";
 export type * from "./types";
 

package/src/core/beam/recall.ts

@@ -1,3 +1,4 @@
+import { popLoopPhase, pushLoopPhase, withLoopPhase } from "@oh-my-pi/pi-utils";
 import { normalizedRecallWeights, polyphonicRecallEnabled, temporalHalflifeHours } from "../../config";
 import { hasCjk, matchesWordForm } from "../../util/regex";
 import { embedQuery } from "../embeddings";
@@ -923,35 +924,37 @@ export async function recall(
 		const derived = query.length > 0 ? await embedQuery(query) : null;
 		temporalOptions.queryEmbedding = derived === null ? null : Array.from(derived);
 	}
-	let weights = normalizedRecallWeights(
-		options.vecWeight ?? beam.config.vecWeight,
-		options.ftsWeight ?? beam.config.ftsWeight,
-		options.importanceWeight ?? beam.config.importanceWeight,
-	);
-	if (options.useIntent === true) {
-		const intent = classifyIntent(query);
-		weights = adjustWeights(weights[0], weights[1], weights[2], intent);
-	}
-	const useSynonyms = options.useSynonyms !== false;
-	const tokens = expandedTokens(query, useSynonyms);
-	const tokenGroups = expandedTokenGroups(query, useSynonyms);
-	const candidates = collectMemoryCandidates(beam, query, topK, temporalOptions);
-	const scored: RecallResult[] = [];
-	for (const candidate of candidates) {
-		const result = scoreCandidate(candidate, tokens, tokenGroups, weights, temporalOptions);
-		if (result !== null) scored.push(result);
-	}
-	scored.sort((left, right) => (right.score ?? 0) - (left.score ?? 0));
-	let finalResults = dedupCrossTierSummaryLinks(beam, dedupeResults(scored));
-	if (query.length > 0 && tokens.length >= 4 && finalResults.length > topK)
-		finalResults = diversifyByCoverage(finalResults, tokens, topK);
-	if (options.useMmr === true && finalResults.length > 1) {
-		finalResults = rerankRecallResults(finalResults, options.mmrLambda ?? 0.7, topK);
-	} else {
-		finalResults = finalResults.slice(0, topK);
-	}
-	if (temporalOptions.updateRecallCounts !== false) updateRecallCounts(beam, finalResults, temporalOptions);
-	return finalResults;
+	return withLoopPhase("mnemopi.recall", () => {
+		let weights = normalizedRecallWeights(
+			options.vecWeight ?? beam.config.vecWeight,
+			options.ftsWeight ?? beam.config.ftsWeight,
+			options.importanceWeight ?? beam.config.importanceWeight,
+		);
+		if (options.useIntent === true) {
+			const intent = classifyIntent(query);
+			weights = adjustWeights(weights[0], weights[1], weights[2], intent);
+		}
+		const useSynonyms = options.useSynonyms !== false;
+		const tokens = expandedTokens(query, useSynonyms);
+		const tokenGroups = expandedTokenGroups(query, useSynonyms);
+		const candidates = collectMemoryCandidates(beam, query, topK, temporalOptions);
+		const scored: RecallResult[] = [];
+		for (const candidate of candidates) {
+			const result = scoreCandidate(candidate, tokens, tokenGroups, weights, temporalOptions);
+			if (result !== null) scored.push(result);
+		}
+		scored.sort((left, right) => (right.score ?? 0) - (left.score ?? 0));
+		let finalResults = dedupCrossTierSummaryLinks(beam, dedupeResults(scored));
+		if (query.length > 0 && tokens.length >= 4 && finalResults.length > topK)
+			finalResults = diversifyByCoverage(finalResults, tokens, topK);
+		if (options.useMmr === true && finalResults.length > 1) {
+			finalResults = rerankRecallResults(finalResults, options.mmrLambda ?? 0.7, topK);
+		} else {
+			finalResults = finalResults.slice(0, topK);
+		}
+		if (temporalOptions.updateRecallCounts !== false) updateRecallCounts(beam, finalResults, temporalOptions);
+		return finalResults;
+	});
 }
 
 function diversifyByCoverage(
@@ -1034,37 +1037,44 @@ export async function recallEnhanced(
 	let cache: QueryCache<RecallResult> | null = null;
 	let token = "";
 	let scope = "";
-	if (cacheEnabled) {
-		beam.caches.queryCache ??= new QueryCache<RecallResult>({
-			maxSize: ENHANCED_RECALL_CACHE_MAX_ENTRIES,
-			ttlSeconds: ENHANCED_RECALL_CACHE_TTL_SECONDS,
-		});
-		cache = beam.caches.queryCache;
-		// Explicit hooks invalidate on this beam's own writes; the token also catches writes
-		// no hook covers (sleep, graph ingest) and commits from other connections.
-		token = databaseWriteToken(beam);
-		if (beam.caches.queryCacheToken !== token) {
-			cache.invalidate();
-			beam.caches.queryCacheToken = token;
-		}
-		scope = enhancedRecallCacheScope(beam, topK, options, polyphonic);
-		const cached = cache.get(query, queryEmbedding, scope);
-		if (cached !== null) {
-			const results = structuredClone(cached) as RecallResult[];
-			if (countRecalls) countRecallsKeepingCache(beam, results, runOptions, token);
-			return results;
+	pushLoopPhase("mnemopi.recall");
+	try {
+		if (cacheEnabled) {
+			beam.caches.queryCache ??= new QueryCache<RecallResult>({
+				maxSize: ENHANCED_RECALL_CACHE_MAX_ENTRIES,
+				ttlSeconds: ENHANCED_RECALL_CACHE_TTL_SECONDS,
+			});
+			cache = beam.caches.queryCache;
+			// Explicit hooks invalidate on this beam's own writes; the token also catches writes
+			// no hook covers (sleep, graph ingest) and commits from other connections.
+			token = databaseWriteToken(beam);
+			if (beam.caches.queryCacheToken !== token) {
+				cache.invalidate();
+				beam.caches.queryCacheToken = token;
+			}
+			scope = enhancedRecallCacheScope(beam, topK, options, polyphonic);
+			const cached = cache.get(query, queryEmbedding, scope);
+			if (cached !== null) {
+				const results = structuredClone(cached) as RecallResult[];
+				if (countRecalls) countRecallsKeepingCache(beam, results, runOptions, token);
+				return results;
+			}
 		}
+	} finally {
+		popLoopPhase();
 	}
 
 	const results = polyphonic
 		? await polyphonicRecallEnhanced(beam, query, topK, runOptions)
 		: await linearRecallEnhanced(beam, query, topK, runOptions);
-	// A write committed while recall awaited may be missing from this ranking: skip the
-	// put and keep the stale token so the next lookup starts from an empty cache.
-	const cacheable = cache !== null && databaseWriteToken(beam) === token;
-	if (cacheable) cache?.put(query, structuredClone(results), queryEmbedding, scope);
-	if (countRecalls) countRecallsKeepingCache(beam, results, runOptions, cacheable ? token : null);
-	return results;
+	return withLoopPhase("mnemopi.recall", () => {
+		// A write committed while recall awaited may be missing from this ranking: skip the
+		// put and keep the stale token so the next lookup starts from an empty cache.
+		const cacheable = cache !== null && databaseWriteToken(beam) === token;
+		if (cacheable) cache?.put(query, structuredClone(results), queryEmbedding, scope);
+		if (countRecalls) countRecallsKeepingCache(beam, results, runOptions, cacheable ? token : null);
+		return results;
+	});
 }
 
 async function linearRecallEnhanced(
@@ -1084,14 +1094,16 @@ async function linearRecallEnhanced(
 		...enhancedOptions,
 		updateRecallCounts: false,
 	});
-	if (options.includeFacts === true) {
-		const facts = factRecall(beam, query, factRecallLimit(topK));
-		results.push(...facts);
-	}
-	results.sort((left, right) => (right.score ?? 0) - (left.score ?? 0));
-	const finalResults = rerankRecallResults(results, options.mmrLambda ?? 0.7, topK);
-	if (enhancedOptions.updateRecallCounts !== false) updateRecallCounts(beam, finalResults, enhancedOptions);
-	return finalResults;
+	return withLoopPhase("mnemopi.recall", () => {
+		if (options.includeFacts === true) {
+			const facts = factRecall(beam, query, factRecallLimit(topK));
+			results.push(...facts);
+		}
+		results.sort((left, right) => (right.score ?? 0) - (left.score ?? 0));
+		const finalResults = rerankRecallResults(results, options.mmrLambda ?? 0.7, topK);
+		if (enhancedOptions.updateRecallCounts !== false) updateRecallCounts(beam, finalResults, enhancedOptions);
+		return finalResults;
+	});
 }
 
 /**

package/src/core/beam/store.ts

@@ -1,5 +1,5 @@
 import type { Database, SQLQueryBindings } from "bun:sqlite";
-import { logger } from "@oh-my-pi/pi-utils";
+import { logger, withLoopPhase } from "@oh-my-pi/pi-utils";
 import { transaction } from "../../db";
 import { toUtcIso } from "../../util/datetime";
 import { generateId } from "../../util/ids";
@@ -307,9 +307,11 @@ function proactiveLinkIfEnabled(
 async function runFactExtraction(beam: BeamMemoryState, memoryId: string, content: string): Promise<void> {
 	try {
 		const extracted = await extractFactCategoriesSafe(content);
-		if (countExtractedFactCategories(extracted) === 0) return;
-		storeExtractedFactCategories(beam, extracted, 0, memoryId);
-		invalidateCaches(beam);
+		withLoopPhase("mnemopi.extract", () => {
+			if (countExtractedFactCategories(extracted) === 0) return;
+			storeExtractedFactCategories(beam, extracted, 0, memoryId);
+			invalidateCaches(beam);
+		});
 	} catch {
 		// Background fact extraction is best-effort and never surfaces to the caller.
 	}
@@ -740,7 +742,7 @@ export function updateWorking(
 export function get(beam: BeamMemoryState, memoryId: string): Row | null {
 	using workingStatement = beam.db.prepare(`
 		SELECT id, content, source, timestamp, session_id,
-			   importance, metadata_json, veracity, created_at
+			   importance, metadata_json, veracity, created_at, valid_until, superseded_by
 		FROM working_memory
 		WHERE id = ?
 	`);
@@ -749,7 +751,7 @@ export function get(beam: BeamMemoryState, memoryId: string): Row | null {
 
 	using episodicStatement = beam.db.prepare(`
 		SELECT id, content, source, timestamp, session_id,
-			   importance, metadata_json, veracity, created_at
+			   importance, metadata_json, veracity, created_at, valid_until, superseded_by
 		FROM episodic_memory
 		WHERE id = ? AND (session_id = ? OR scope = 'global')
 	`);

package/src/core/embeddings.ts

@@ -11,6 +11,7 @@ import {
 	fetchWithRetry,
 	getFastembedCacheDir,
 	logger,
+	withLoopPhase,
 } from "@oh-my-pi/pi-utils";
 import { LRUCache } from "@oh-my-pi/pi-utils/lru";
 import type { EmbeddingModel } from "fastembed";
@@ -294,9 +295,11 @@ export function embeddingDimFor(modelName: string): number {
 async function collectMatrix(batches: EmbeddingOutput): Promise<EmbeddingMatrix> {
 	const rows: Vector[] = [];
 	for await (const batch of batches) {
-		for (const row of batch) {
-			rows.push(new Float32Array(row));
-		}
+		withLoopPhase("mnemopi.embed", () => {
+			for (const row of batch) {
+				rows.push(new Float32Array(row));
+			}
+		});
 	}
 	return rows;
 }
@@ -388,12 +391,15 @@ async function embedApi(texts: readonly string[]): Promise<EmbeddingMatrix | nul
 		if (!response.ok) {
 			return null;
 		}
-		const { data: rows } = (await response.json()) as { data?: Array<{ embedding: number[] }> };
-		if (rows === undefined) {
-			return null;
-		}
-		apiCallCount += 1;
-		return rows.map(row => new Float32Array(row.embedding));
+		const data = (await response.json()) as { data?: Array<{ embedding: number[] }> };
+		return withLoopPhase("mnemopi.embed", () => {
+			const { data: rows } = data;
+			if (rows === undefined) {
+				return null;
+			}
+			apiCallCount += 1;
+			return rows.map(row => new Float32Array(row.embedding));
+		});
 	} catch (error) {
 		logger.debug("mnemopi embedding request failed", { status: extractHttpStatusFromError(error) });
 		return null;
@@ -525,7 +531,7 @@ export async function embed(texts: readonly string[]): Promise<EmbeddingMatrix |
 		return null;
 	}
 	try {
-		const vectors = await collectMatrix(model.embed([...texts]));
+		const vectors = await withLoopPhase("mnemopi.embed", () => collectMatrix(model.embed([...texts])));
 		if (vectors.length === 1) {
 			const vector = vectors[0];
 			if (vector !== undefined) {

package/src/core/episodic-graph.ts

@@ -571,17 +571,12 @@ export class EpisodicGraph {
 						this.addEdge(edge);
 						edges.push(edge);
 					}
-					const contextualScore = Math.max(
-						lexicalScore,
-						entityScore,
-						this.temporalContextScore(memoryId, otherId),
-					);
-					if (!wroteCtxEdge && contextualScore >= minLinkScore) {
+					if (!wroteCtxEdge && entityScore >= minLinkScore) {
 						const ctxEdge = {
 							source: memoryId,
 							target: otherId,
 							edgeType: "ctx",
-							weight: contextualScore,
+							weight: entityScore,
 							timestamp,
 						};
 						this.addEdge(ctxEdge);
@@ -736,18 +731,6 @@ export class EpisodicGraph {
 		return Math.round(overlapScore(left, right) * 1000) / 1000;
 	}
 
-	private temporalContextScore(sourceMemoryId: string, targetMemoryId: string): number {
-		const left = this.db.query("SELECT time_scope FROM gists WHERE memory_id = ?").get(sourceMemoryId) as {
-			time_scope: string | null;
-		} | null;
-		if (left?.time_scope === null || left?.time_scope === undefined) return 0;
-		const right = this.db.query("SELECT time_scope FROM gists WHERE memory_id = ?").get(targetMemoryId) as {
-			time_scope: string | null;
-		} | null;
-		if (right?.time_scope === null || right?.time_scope === undefined) return 0;
-		return left.time_scope === right.time_scope ? DEFAULT_LINK_THRESHOLD : 0;
-	}
-
 	private memoryFeatures(memoryId: string): Set<string> {
 		const gistRows = this.db.query("SELECT * FROM gists WHERE memory_id = ?").all(memoryId) as GistRow[];
 		const factRows = this.db.query("SELECT * FROM facts WHERE source_msg_id = ?").all(memoryId) as FactRow[];

package/src/core/extraction.ts

@@ -1,3 +1,4 @@
+import { withLoopPhase } from "@oh-my-pi/pi-utils";
 import { getDiagnostics, safeForLog } from "./extraction/diagnostics";
 import { callHostLlm, getHostLlmBackend } from "./llm-backends";
 import {
@@ -219,51 +220,58 @@ export function countExtractedFactCategories(extracted: ExtractedFactCategories)
 
 /** Parse extractor output without discarding MEMORIA categories or KG triples. */
 export function parseExtractedFactCategories(rawOutput: string | null | undefined): ExtractedFactCategories {
-	if (rawOutput === null || rawOutput === undefined) {
-		return emptyFactCategories();
-	}
-	const raw = rawOutput.trim();
-	if (raw === "" || raw.toUpperCase() === "NO_FACTS") {
-		return emptyFactCategories();
-	}
-	const rawClean = stripFence(raw);
-	if (rawClean.startsWith("{")) {
-		try {
-			const parsed: unknown = JSON.parse(rawClean);
-			if (isRecord(parsed)) {
-				return {
-					facts: normalizeFactArray(parsed.facts, { fields: FACT_TEXT_FIELD_KEYS }),
-					instructions: normalizeFactArray(parsed.instructions, { fields: INSTRUCTION_TEXT_FIELD_KEYS }),
-					preferences: normalizeFactArray(parsed.preferences, { fields: PREFERENCE_TEXT_FIELD_KEYS }),
-					timelines: normalizeFactArray(parsed.timelines, { fields: TIMELINE_TEXT_FIELD_KEYS, joinFields: true }),
-					kg: normalizeKgArray(parsed.kg),
-				};
-			}
-		} catch {
-			const matches = [...raw.matchAll(/"([^"]{10,})"/g)].map(m => m[1]).filter((v): v is string => v !== undefined);
-			if (matches.length > 0) {
-				return {
-					...emptyFactCategories(),
-					facts: matches
-						.map(normalizeFact)
-						.filter(f => f !== "")
-						.slice(0, FLAT_FACT_LIMIT),
-				};
+	return withLoopPhase("mnemopi.extract", () => {
+		if (rawOutput === null || rawOutput === undefined) {
+			return emptyFactCategories();
+		}
+		const raw = rawOutput.trim();
+		if (raw === "" || raw.toUpperCase() === "NO_FACTS") {
+			return emptyFactCategories();
+		}
+		const rawClean = stripFence(raw);
+		if (rawClean.startsWith("{")) {
+			try {
+				const parsed: unknown = JSON.parse(rawClean);
+				if (isRecord(parsed)) {
+					return {
+						facts: normalizeFactArray(parsed.facts, { fields: FACT_TEXT_FIELD_KEYS }),
+						instructions: normalizeFactArray(parsed.instructions, { fields: INSTRUCTION_TEXT_FIELD_KEYS }),
+						preferences: normalizeFactArray(parsed.preferences, { fields: PREFERENCE_TEXT_FIELD_KEYS }),
+						timelines: normalizeFactArray(parsed.timelines, {
+							fields: TIMELINE_TEXT_FIELD_KEYS,
+							joinFields: true,
+						}),
+						kg: normalizeKgArray(parsed.kg),
+					};
+				}
+			} catch {
+				const matches = [...raw.matchAll(/"([^"]{10,})"/g)]
+					.map(m => m[1])
+					.filter((v): v is string => v !== undefined);
+				if (matches.length > 0) {
+					return {
+						...emptyFactCategories(),
+						facts: matches
+							.map(normalizeFact)
+							.filter(f => f !== "")
+							.slice(0, FLAT_FACT_LIMIT),
+					};
+				}
 			}
 		}
-	}
-	const cleaned: string[] = [];
-	for (const line of raw.split("\n")) {
-		const fact = line.replace(/^[\s\d.\-*]+/, "").trim();
-		if (fact.length > 10) {
-			const normalized = normalizeFact(fact);
-			if (normalized !== "") {
-				cleaned.push(normalized);
+		const cleaned: string[] = [];
+		for (const line of raw.split("\n")) {
+			const fact = line.replace(/^[\s\d.\-*]+/, "").trim();
+			if (fact.length > 10) {
+				const normalized = normalizeFact(fact);
+				if (normalized !== "") {
+					cleaned.push(normalized);
+				}
 			}
+			if (cleaned.length >= FLAT_FACT_LIMIT) break;
 		}
-		if (cleaned.length >= FLAT_FACT_LIMIT) break;
-	}
-	return { ...emptyFactCategories(), facts: cleaned };
+		return { ...emptyFactCategories(), facts: cleaned };
+	});
 }
 
 /** Parse extractor output into the legacy flat string fact list. */
@@ -283,42 +291,44 @@ function addUnique(out: string[], value: string): void {
 }
 
 export function heuristicExtractFacts(text: string): string[] {
-	const normalized = text.replace(/\s+/g, " ").trim();
-	if (normalized === "") {
-		return [];
-	}
-	const facts: string[] = [];
-	const clauses = normalized.split(/(?:[.!?;]+|\s+and\s+|\s+but\s+)/i);
-	for (const clause of clauses) {
-		const c = clause.trim();
-		let value = /\bmy name is\s+([^,.!?;]+)/i.exec(c)?.[1];
-		if (value !== undefined) addUnique(facts, `The user's name is ${value}`);
-		value = /\bi (?:am|work as)\s+(?:an?\s+)?([^,.!?;]+)/i.exec(c)?.[1];
-		if (value !== undefined) addUnique(facts, `The user is ${value}`);
-		value = /\bi work (?:at|for)\s+([^,.!?;]+)/i.exec(c)?.[1];
-		if (value !== undefined) addUnique(facts, `The user works at ${value}`);
-		value = /\bi (?:live in|am based in)\s+([^,.!?;]+)/i.exec(c)?.[1];
-		if (value !== undefined) addUnique(facts, `The user lives in ${value}`);
-		value = /\bi (?:use|uses|am using)\s+([^,.!?;]+)/i.exec(c)?.[1];
-		if (value !== undefined) addUnique(facts, `The user uses ${value}`);
-		value = /\bi (?:like|love|prefer|enjoy)\s+([^,.!?;]+)/i.exec(c)?.[1];
-		if (value !== undefined) addUnique(facts, `The user prefers ${value}`);
-		value = /\bi (?:hate|dislike|do not like|don't like)\s+([^,.!?;]+)/i.exec(c)?.[1];
-		if (value !== undefined) addUnique(facts, `The user dislikes ${value}`);
-		// Require an explicit `i` or `you` subject before `always|never`. The
-		// other heuristics in this block all need an `i` subject (`i live in …`,
-		// `i use …`) which keeps them from matching narrative prose; the
-		// `Instruction:` pattern used to match any `always|never` token, so
-		// assistant prose like "the panel never populates" became stored as a
-		// user `Instruction:` memory (coding-agent issue #3372). Subject
-		// constraint mirrors how the rest of the heuristics filter for first- /
-		// second-person assertions and keeps narrative third-person prose out.
-		const instruction = /\b(?:i|you)\s+(always|never)\s+([^,.!?;]+)/i.exec(c);
-		if (instruction?.[1] !== undefined && instruction[2] !== undefined) {
-			addUnique(facts, `Instruction: ${instruction[1].toLowerCase()} ${instruction[2]}`);
+	return withLoopPhase("mnemopi.extract", () => {
+		const normalized = text.replace(/\s+/g, " ").trim();
+		if (normalized === "") {
+			return [];
 		}
-	}
-	return facts.slice(0, 5);
+		const facts: string[] = [];
+		const clauses = normalized.split(/(?:[.!?;]+|\s+and\s+|\s+but\s+)/i);
+		for (const clause of clauses) {
+			const c = clause.trim();
+			let value = /\bmy name is\s+([^,.!?;]+)/i.exec(c)?.[1];
+			if (value !== undefined) addUnique(facts, `The user's name is ${value}`);
+			value = /\bi (?:am|work as)\s+(?:an?\s+)?([^,.!?;]+)/i.exec(c)?.[1];
+			if (value !== undefined) addUnique(facts, `The user is ${value}`);
+			value = /\bi work (?:at|for)\s+([^,.!?;]+)/i.exec(c)?.[1];
+			if (value !== undefined) addUnique(facts, `The user works at ${value}`);
+			value = /\bi (?:live in|am based in)\s+([^,.!?;]+)/i.exec(c)?.[1];
+			if (value !== undefined) addUnique(facts, `The user lives in ${value}`);
+			value = /\bi (?:use|uses|am using)\s+([^,.!?;]+)/i.exec(c)?.[1];
+			if (value !== undefined) addUnique(facts, `The user uses ${value}`);
+			value = /\bi (?:like|love|prefer|enjoy)\s+([^,.!?;]+)/i.exec(c)?.[1];
+			if (value !== undefined) addUnique(facts, `The user prefers ${value}`);
+			value = /\bi (?:hate|dislike|do not like|don't like)\s+([^,.!?;]+)/i.exec(c)?.[1];
+			if (value !== undefined) addUnique(facts, `The user dislikes ${value}`);
+			// Require an explicit `i` or `you` subject before `always|never`. The
+			// other heuristics in this block all need an `i` subject (`i live in …`,
+			// `i use …`) which keeps them from matching narrative prose; the
+			// `Instruction:` pattern used to match any `always|never` token, so
+			// assistant prose like "the panel never populates" became stored as a
+			// user `Instruction:` memory (coding-agent issue #3372). Subject
+			// constraint mirrors how the rest of the heuristics filter for first- /
+			// second-person assertions and keeps narrative third-person prose out.
+			const instruction = /\b(?:i|you)\s+(always|never)\s+([^,.!?;]+)/i.exec(c);
+			if (instruction?.[1] !== undefined && instruction[2] !== undefined) {
+				addUnique(facts, `Instruction: ${instruction[1].toLowerCase()} ${instruction[2]}`);
+			}
+		}
+		return facts.slice(0, 5);
+	});
 }
 
 async function tryHostExtraction(prompt: string): Promise<[boolean, string | null]> {
@@ -345,7 +355,7 @@ async function localFallback(
 	try {
 		const raw = await callLocalLlm(prompt);
 		if (raw !== null) {
-			const extracted = parseExtractedFactCategories(cleanOutput(raw));
+			const extracted = withLoopPhase("mnemopi.extract", () => parseExtractedFactCategories(cleanOutput(raw)));
 			const count = countExtractedFactCategories(extracted);
 			if (count > 0) {
 				diag.recordSuccess("local", count);
@@ -380,7 +390,7 @@ export async function extractFactCategories(
 		return emptyFactCategories();
 	}
 	const input = clipToWindow(text, DEFAULT_INPUT_CHARS);
-	const prompt = buildExtractionPrompt(input);
+	const prompt = withLoopPhase("mnemopi.extract", () => buildExtractionPrompt(input));
 
 	// Configured completion (host-injected runtime LLM, e.g. the coding-agent's smol
 	// or a local on-device model). Mirrors consolidation's precedence: when a
@@ -453,7 +463,7 @@ export async function extractFactCategories(
 	try {
 		const raw = await callRemoteLlm(prompt, 0, options);
 		if (raw !== null) {
-			const extracted = parseExtractedFactCategories(cleanOutput(raw));
+			const extracted = withLoopPhase("mnemopi.extract", () => parseExtractedFactCategories(cleanOutput(raw)));
 			const count = countExtractedFactCategories(extracted);
 			if (count > 0) {
 				diag.recordSuccess("remote", count);

package/src/core/memory.ts

@@ -1,5 +1,6 @@
 import type { Database } from "bun:sqlite";
 import type { Api, ApiKey, Model } from "@oh-my-pi/pi-ai";
+import { popLoopPhase, pushLoopPhase, withLoopPhase } from "@oh-my-pi/pi-utils";
 
 import { dbPath as configuredDbPath } from "../config";
 import { closeQuietly } from "../db";
@@ -406,55 +407,62 @@ export class Mnemopi {
 	#closed = false;
 
 	constructor(options: MnemopiOptions = {}) {
-		this.sessionId = options.sessionId ?? options.session_id ?? "default";
-		this.bank = options.bank ?? "default";
-
-		this.authorId = options.authorId ?? options.author_id ?? null;
-		this.authorType = options.authorType ?? options.author_type ?? null;
-		this.channelId = options.channelId ?? options.channel_id ?? this.sessionId;
-		this.dbPath = resolveDbPath(options, this.bank);
-		this.runtimeOptions = resolveRuntimeOptions(options);
-
-		this.beam = new BeamMemory({
-			sessionId: this.sessionId,
-			dbPath: options.db === undefined ? this.dbPath : ":memory:",
-			authorId: this.authorId,
-			authorType: this.authorType,
-			channelId: this.channelId,
-			proactiveLinking: options.proactiveLinking,
-			polyphonicRecall: options.polyphonicRecall,
-			enhancedRecall: options.enhancedRecall,
-		});
-		this.#ownsDb = options.db === undefined;
-		if (options.db !== undefined) {
-			const opened = this.beam.db;
-			initBeam(options.db);
-			Object.defineProperty(this.beam, "db", { value: options.db });
-			Object.defineProperty(this.beam, "annotations", {
-				value: buildBeamAnnotations(options.db, this.dbPath),
-			});
-			Object.defineProperty(this.beam, "episodicGraph", {
-				value: buildEpisodicGraph(options.db, this.dbPath),
+		pushLoopPhase("mnemopi.open");
+		try {
+			this.sessionId = options.sessionId ?? options.session_id ?? "default";
+			this.bank = options.bank ?? "default";
+
+			this.authorId = options.authorId ?? options.author_id ?? null;
+			this.authorType = options.authorType ?? options.author_type ?? null;
+			this.channelId = options.channelId ?? options.channel_id ?? this.sessionId;
+			this.dbPath = resolveDbPath(options, this.bank);
+			this.runtimeOptions = resolveRuntimeOptions(options);
+
+			this.beam = new BeamMemory({
+				sessionId: this.sessionId,
+				dbPath: options.db === undefined ? this.dbPath : ":memory:",
+				authorId: this.authorId,
+				authorType: this.authorType,
+				channelId: this.channelId,
+				proactiveLinking: options.proactiveLinking,
+				polyphonicRecall: options.polyphonicRecall,
+				enhancedRecall: options.enhancedRecall,
 			});
-			closeQuietly(opened);
-		}
-		this.conn = this.beam.db;
-		this.db = this.beam.db;
-		// Wipe-and-rebuild stale embeddings when the configured model changed since
-		// the vectors were written. Runs inside the runtime scope so
-		// `currentEmbeddingModel()` reflects this instance's configured model.
-		// Skipped for read-only opens (`reconcile: false`) so an ephemeral stats
-		// reader never triggers a destructive migration whose async rebuild it would
-		// exit before completing — which would otherwise lose the embeddings.
-		if (options.reconcile !== false) {
-			this.#withRuntimeOptions(() => reconcileEmbeddingModel(this.beam));
+			this.#ownsDb = options.db === undefined;
+			if (options.db !== undefined) {
+				const opened = this.beam.db;
+				initBeam(options.db);
+				Object.defineProperty(this.beam, "db", { value: options.db });
+				Object.defineProperty(this.beam, "annotations", {
+					value: buildBeamAnnotations(options.db, this.dbPath),
+				});
+				Object.defineProperty(this.beam, "episodicGraph", {
+					value: buildEpisodicGraph(options.db, this.dbPath),
+				});
+				closeQuietly(opened);
+			}
+			this.conn = this.beam.db;
+			this.db = this.beam.db;
+			// Wipe-and-rebuild stale embeddings when the configured model changed since
+			// the vectors were written. Runs inside the runtime scope so
+			// `currentEmbeddingModel()` reflects this instance's configured model.
+			// Skipped for read-only opens (`reconcile: false`) so an ephemeral stats
+			// reader never triggers a destructive migration whose async rebuild it would
+			// exit before completing — which would otherwise lose the embeddings.
+			if (options.reconcile !== false) {
+				withMnemopiRuntimeOptions(this.runtimeOptions, () => reconcileEmbeddingModel(this.beam));
+			}
+		} finally {
+			popLoopPhase();
 		}
 	}
 
 	close(): void {
-		if (this.#closed) return;
-		this.#closed = true;
-		if (this.#ownsDb) this.beam.close();
+		withLoopPhase("mnemopi.close", () => {
+			if (this.#closed) return;
+			this.#closed = true;
+			if (this.#ownsDb) this.beam.close();
+		});
 	}
 
 	async flushExtractions(): Promise<void> {
@@ -462,12 +470,14 @@ export class Mnemopi {
 	}
 
 	remember(memory: string | RememberInput, options: RememberFacadeOptions = {}): string {
-		const content = typeof memory === "string" ? memory : memory.content;
-		return this.#withRuntimeOptions(() => this.beam.remember(content, toRememberOptions(memory, options)));
+		return this.#withRuntimeOptions("mnemopi.retain", () => {
+			const content = typeof memory === "string" ? memory : memory.content;
+			return this.beam.remember(content, toRememberOptions(memory, options));
+		});
 	}
 
 	recall(query: string, topK = 5, options: RecallFacadeOptions = {}): Promise<RecallResult[]> {
-		return this.#withRuntimeOptions(() => this.beam.recall(query, topK, toRecallOptions(options)));
+		return this.#withRuntimeOptions("mnemopi.recall", () => this.beam.recall(query, topK, toRecallOptions(options)));
 	}
 
 	recallEnhanced(
@@ -475,7 +485,7 @@ export class Mnemopi {
 		topK = 5,
 		options: RecallFacadeOptions & RecallEnhancedOptions = {},
 	): Promise<RecallResult[]> {
-		return this.#withRuntimeOptions(() =>
+		return this.#withRuntimeOptions("mnemopi.recall", () =>
 			this.beam.recallEnhanced(query, topK, {
 				...toRecallOptions(options),
 				useCache: options.useCache,
@@ -485,7 +495,7 @@ export class Mnemopi {
 	}
 
 	getContext(limit = 10): unknown[] {
-		return this.#withRuntimeOptions(() => this.beam.getContext(limit));
+		return this.#withRuntimeOptions("mnemopi.read", () => this.beam.getContext(limit));
 	}
 
 	getStats(
@@ -493,62 +503,70 @@ export class Mnemopi {
 		authorType: string | null = null,
 		channelId: string | null = null,
 	): MemoryFacadeStats {
-		const working = this.#withRuntimeOptions(() => this.beam.getWorkingStats(authorId, authorType, channelId));
-		const episodic = this.#withRuntimeOptions(() => this.beam.getEpisodicStats(authorId, authorType, channelId));
-		const totalMemories = countRows(this.conn, "SELECT COUNT(*) AS total FROM working_memory");
-		const totalSessions = countRows(this.conn, "SELECT COUNT(DISTINCT session_id) AS total FROM working_memory");
-		using lastStatement = this.conn.prepare("SELECT timestamp FROM working_memory ORDER BY timestamp DESC LIMIT 1");
-		const last = lastStatement.get() as {
-			timestamp: string | null;
-		} | null;
-		const tripleTotal = countRows(this.conn, "SELECT COUNT(*) AS total FROM triples");
-		let banks = ["default"];
-		if (this.dbPath !== undefined && this.dbPath !== ":memory:") {
-			const dataDir = dataDirForDbPath(this.dbPath);
-			banks = new BankManager(dataDir).listBanks();
-		}
-		return {
-			total_memories: totalMemories,
-			total_sessions: totalSessions,
-			sources: sourceCounts(this.conn),
-			last_memory: last?.timestamp ?? null,
-			database: this.dbPath ?? ":memory:",
-			mode: "beam",
-			banks,
-			beam: { working_memory: working, episodic_memory: episodic, triples: { total: tripleTotal } },
-		};
+		return withLoopPhase("mnemopi.stats", () => {
+			const working = withMnemopiRuntimeOptions(this.runtimeOptions, () =>
+				this.beam.getWorkingStats(authorId, authorType, channelId),
+			);
+			const episodic = withMnemopiRuntimeOptions(this.runtimeOptions, () =>
+				this.beam.getEpisodicStats(authorId, authorType, channelId),
+			);
+			const totalMemories = countRows(this.conn, "SELECT COUNT(*) AS total FROM working_memory");
+			const totalSessions = countRows(this.conn, "SELECT COUNT(DISTINCT session_id) AS total FROM working_memory");
+			using lastStatement = this.conn.prepare(
+				"SELECT timestamp FROM working_memory ORDER BY timestamp DESC LIMIT 1",
+			);
+			const last = lastStatement.get() as {
+				timestamp: string | null;
+			} | null;
+			const tripleTotal = countRows(this.conn, "SELECT COUNT(*) AS total FROM triples");
+			let banks = ["default"];
+			if (this.dbPath !== undefined && this.dbPath !== ":memory:") {
+				const dataDir = dataDirForDbPath(this.dbPath);
+				banks = new BankManager(dataDir).listBanks();
+			}
+			return {
+				total_memories: totalMemories,
+				total_sessions: totalSessions,
+				sources: sourceCounts(this.conn),
+				last_memory: last?.timestamp ?? null,
+				database: this.dbPath ?? ":memory:",
+				mode: "beam",
+				banks,
+				beam: { working_memory: working, episodic_memory: episodic, triples: { total: tripleTotal } },
+			};
+		});
 	}
 
 	get(memoryId: string): unknown | null {
-		return this.#withRuntimeOptions(() => this.beam.get(memoryId));
+		return this.#withRuntimeOptions("mnemopi.read", () => this.beam.get(memoryId));
 	}
 
 	forget(memoryId: string): boolean {
-		return this.#withRuntimeOptions(() => this.beam.forgetWorking(memoryId));
+		return this.#withRuntimeOptions("mnemopi.edit", () => this.beam.forgetWorking(memoryId));
 	}
 
 	update(memoryId: string, content: string | null = null, importance: number | null = null): boolean {
-		return this.#withRuntimeOptions(() => this.beam.updateWorking(memoryId, content, importance));
+		return this.#withRuntimeOptions("mnemopi.edit", () => this.beam.updateWorking(memoryId, content, importance));
 	}
 
 	sleep(dryRun = false): SleepResult {
-		return this.#withRuntimeOptions(() => this.beam.sleep(dryRun));
+		return this.#withRuntimeOptions("mnemopi.consolidate", () => this.beam.sleep(dryRun));
 	}
 
 	sleepAllSessions(dryRun = false): SleepResult {
-		return this.#withRuntimeOptions(() => this.beam.sleepAllSessions(dryRun));
+		return this.#withRuntimeOptions("mnemopi.consolidate", () => this.beam.sleepAllSessions(dryRun));
 	}
 
 	scratchpadWrite(content: string): string {
-		return this.#withRuntimeOptions(() => this.beam.scratchpadWrite(content));
+		return this.#withRuntimeOptions("mnemopi.retain", () => this.beam.scratchpadWrite(content));
 	}
 
 	scratchpadRead(): unknown[] {
-		return this.#withRuntimeOptions(() => this.beam.scratchpadRead());
+		return this.#withRuntimeOptions("mnemopi.read", () => this.beam.scratchpadRead());
 	}
 
 	scratchpadClear(): void {
-		this.#withRuntimeOptions(() => this.beam.scratchpadClear());
+		this.#withRuntimeOptions("mnemopi.edit", () => this.beam.scratchpadClear());
 	}
 
 	addMemory(memory: string | RememberInput, options: RememberFacadeOptions = {}): string {
@@ -574,8 +592,8 @@ export class Mnemopi {
 	consolidate(dryRun = false): SleepResult {
 		return this.sleep(dryRun);
 	}
-	#withRuntimeOptions<T>(fn: () => T): T {
-		return withMnemopiRuntimeOptions(this.runtimeOptions, fn);
+	#withRuntimeOptions<T>(label: string, fn: () => T): T {
+		return withLoopPhase(label, () => withMnemopiRuntimeOptions(this.runtimeOptions, fn));
 	}
 }
 

package/src/core/polyphonic-recall.ts

@@ -1,5 +1,5 @@
 import type { Database } from "bun:sqlite";
-import { logger } from "@oh-my-pi/pi-utils";
+import { logger, withLoopPhase } from "@oh-my-pi/pi-utils";
 import { type Env, polyphonicRecallEnabled } from "../config";
 import { closeQuietly, type DatabasePath, openDatabase } from "../db";
 import { backfillConsolidatedFacts, ensureVeracityConsolidator } from "./beam/consolidate";
@@ -759,11 +759,15 @@ export function polyphonicRecall(
 	topK = 10,
 	options: PolyphonicRecallOptions = {},
 ): PolyphonicMemoryResult[] {
-	return getPolyphonicEngine(beam).recall(
-		query,
-		options.queryEmbedding ?? null,
-		topK,
-		options.contextBudget ?? 4000,
-		options,
-	);
+	// Voice fan-out, graph walk and fusion run synchronously on the caller's event loop;
+	// label them so a stall is attributable.
+	return withLoopPhase("mnemopi.recall", () => {
+		return getPolyphonicEngine(beam).recall(
+			query,
+			options.queryEmbedding ?? null,
+			topK,
+			options.contextBudget ?? 4000,
+			options,
+		);
+	});
 }