@linxiraos/pi-mnemopi 1.1.26 → 1.2.0

package/CHANGELOG.md

@@ -1,7 +1,18 @@
-# Changelog
-
 ## [Unreleased]
 
+## [1.2.0] - 2026-10-12
+
+- Fixed proactive linking freezing the host for seconds per stored memory on large banks; a memory's graph links are now written in one commit instead of one per link ([#14998](https://github.com/can1357/oh-my-pi/issues/14998)).
+- Fixed long retained transcripts exhausting local memory extraction models by limiting each extraction input to 8192 characters while keeping the opening context and newest turns ([#14956](https://github.com/can1357/oh-my-pi/issues/14956)).
+
+### Fixed
+
+- Fixed new memories gaining graph links (`related_to`, `references`, `ctx`) to memories that were already invalidated, superseded, or expired; proactive linking and consolidation now link only to memories recall can still return, so the graph stops growing toward retired memories ([#14427](https://github.com/can1357/oh-my-pi/pull/14427) by [@tickernelz](https://github.com/tickernelz)).
+
+## [1.1.27] - 2026-10-07
+
+- 版本线推进至 1.1.27；本版无独立用户可见变化。
+
 ## [1.1.26] - 2026-10-03
 
 - 版本线推进至 1.1.26；本版无独立用户可见变化。

package/README.md

@@ -1,6 +1,6 @@
 # @linxiraos/pi-mnemopi
 
-Local SQLite memory engine for omp agents.
+Local SQLite memory engine for zetacode agents.
 
 This package is the Bun/TypeScript port of the Mnemosyne memory engine. It provides:
 

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/embeddings.d.ts

@@ -32,30 +32,11 @@ export type LocalModelInitializer = (options: LocalModelInitOptions) => Promise<
  */
 export declare function quarantineCorruptModelFile(message: string, cacheDir?: string): Promise<boolean>;
 /**
- * Recover from a partially-extracted fastembed model cache. An interrupted
- * archive download/extraction leaves `<cacheDir>/<model>/` populated with
- * sidecars and a truncated `model.onnx_data` but WITHOUT the graph file
- * (`model.onnx` / `model_optimized.onnx`), so `FlagEmbedding.init` throws
- * `Model file not found at .../model.onnx`. Upstream `retrieveModel`
- * short-circuits on the existing model dir and never re-downloads, and
- * `downloadFileFromGCS` reuses a leftover partial `<model>.tar.gz` as-is, so
- * the cache is stuck broken forever: recall silently dies and the rebuild
- * queue grows every session. Delete the incomplete model dir AND the leftover
- * partial archive so the retry re-downloads from scratch. The model path is
- * error-message CONTENT, so the dir is only removed when it is a direct child
- * of the fastembed cache root — never touch a directory a dependency merely
- * names. Returns true when a retry is worth attempting (the incomplete cache
- * was cleared, or already gone from a concurrent heal).
- * @internal exported for tests
- */
-export declare function clearIncompleteModelCache(message: string, cacheDir?: string): Promise<boolean>;
-/**
- * Shared local-model initializer: FlagEmbedding.init with BOTH cache heals.
- * Missing sidecars (config/tokenizer/tokens map) re-fetch and retry; a
- * corrupt model blob (Protobuf parse failure) quarantines the file and
- * retries THROUGH the sidecar heal, so a cache that is broken in both ways
- * still recovers in one pass. Also the initializer the embed worker uses in
- * its subprocess; the in-process seam stays {@link setLocalModelInitializer}.
+ * Shared local-model initializer: FlagEmbedding.init with a corrupt-cache heal.
+ * A corrupt model blob (Protobuf parse failure) quarantines the file and
+ * retries once; fastembed re-downloads any file missing from the model's
+ * cache directory. Also the initializer the embed worker uses in its
+ * subprocess; the in-process seam stays {@link setLocalModelInitializer}.
  */
 export declare function defaultLocalModelInitializer(options: LocalModelInitOptions): Promise<LocalEmbeddingModel>;
 export declare function embeddingsDisabled(): boolean;

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/dist/types/core/fastembed-model-cache.d.ts

@@ -1,2 +1,8 @@
-/** Download missing config/tokenizer sidecars into a fastembed model cache directory. */
-export declare function ensureFastembedModelSidecars(model: string, cacheDir?: string): Promise<boolean>;
+/**
+ * Whether `FlagEmbedding.init` can load `model` from `cacheDir` without a
+ * download. fastembed caches each file under `<cacheDir>/<repo with / → _>/`
+ * and fetches only the files that are missing, so a model is cached exactly
+ * when every file is present. Unknown models report false. The agent's embed
+ * client uses this to decide whether an init shows download activity.
+ */
+export declare function isFastembedModelCached(model: string, cacheDir: string): Promise<boolean>;

package/dist/types/core/query-cache.d.ts

@@ -31,7 +31,9 @@ export declare function isQueryCacheEnabled(useCache?: boolean, env?: Env, confi
  *
  * - Tier 1: exact normalized query match.
  * - Tiers 2/3: query embedding cosine >= 0.88, or >= 0.78 plus word overlap.
- * - Tier 4: normalized word overlap.
+ * - Tier 4: shared distinct words cover at least 70% of the new query and half of the
+ *   cached one, so a reworded or trimmed query hits but a short query never lands
+ *   inside a long cached prompt that merely contains its words.
  */
 export declare class QueryCache<T = QueryCacheResult> {
     #private;

package/dist/types/core/text-window.d.ts

@@ -0,0 +1,4 @@
+/** Default character budget for a single embedding or fact-extraction input. */
+export declare const DEFAULT_INPUT_CHARS = 8192;
+/** Preserve the opening context and newest turns of an oversized chronological input. */
+export declare function clipToWindow(text: string, max: number): string;

package/package.json

@@ -1,8 +1,8 @@
 {
 	"type": "module",
 	"name": "@linxiraos/pi-mnemopi",
-	"version": "1.1.26",
-	"description": "Local SQLite memory engine for omp agents",
+	"version": "1.2.0",
+	"description": "Local SQLite memory engine for Zeta agents",
 	"homepage": "https://linxira-os.github.io/zeta/",
 	"author": "Linxira-OS",
 	"contributors": [
@@ -39,13 +39,13 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@linxiraos/pi-ai": "1.1.26",
-		"@linxiraos/pi-catalog": "1.1.26",
-		"@linxiraos/pi-natives": "1.1.26",
-		"@linxiraos/pi-utils": "1.1.26"
+		"@linxiraos/pi-ai": "1.2.0",
+		"@linxiraos/pi-catalog": "1.2.0",
+		"@linxiraos/pi-natives": "1.2.0",
+		"@linxiraos/pi-utils": "1.2.0"
 	},
 	"peerDependencies": {
-		"fastembed": "2.1.0",
+		"fastembed": "3.0.0",
 		"onnxruntime-node": "1.21.0"
 	},
 	"peerDependenciesMeta": {
@@ -58,7 +58,7 @@
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14",
-		"fastembed": "2.1.0",
+		"fastembed": "3.0.0",
 		"onnxruntime-node": "1.26.0"
 	},
 	"engines": {

package/src/core/beam/helpers.ts

@@ -1,5 +1,5 @@
 import type { Database } from "bun:sqlite";
-import { logger } from "@linxiraos/pi-utils";
+import { logger, withLoopPhase } from "@linxiraos/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 "@linxiraos/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 "@linxiraos/pi-utils";
+import { logger, withLoopPhase } from "@linxiraos/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,10 +11,10 @@ import {
 	fetchWithRetry,
 	getFastembedCacheDir,
 	logger,
+	withLoopPhase,
 } from "@linxiraos/pi-utils";
 import { LRUCache } from "@linxiraos/pi-utils/lru";
 import type { EmbeddingModel } from "fastembed";
-import { ensureFastembedModelSidecars } from "./fastembed-model-cache";
 import { loadFastembed } from "./fastembed-runtime";
 import {
 	type EmbeddingOutput,
@@ -22,6 +22,7 @@ import {
 	mnemopiDebugEnabled,
 	resolveEmbeddingProvider,
 } from "./runtime-options";
+import { clipToWindow, DEFAULT_INPUT_CHARS } from "./text-window";
 
 export type { EmbeddingOutput } from "./runtime-options";
 export { cosineSimilarity } from "./vector-math";
@@ -93,74 +94,22 @@ export async function quarantineCorruptModelFile(message: string, cacheDir?: str
 }
 
 /**
- * Recover from a partially-extracted fastembed model cache. An interrupted
- * archive download/extraction leaves `<cacheDir>/<model>/` populated with
- * sidecars and a truncated `model.onnx_data` but WITHOUT the graph file
- * (`model.onnx` / `model_optimized.onnx`), so `FlagEmbedding.init` throws
- * `Model file not found at .../model.onnx`. Upstream `retrieveModel`
- * short-circuits on the existing model dir and never re-downloads, and
- * `downloadFileFromGCS` reuses a leftover partial `<model>.tar.gz` as-is, so
- * the cache is stuck broken forever: recall silently dies and the rebuild
- * queue grows every session. Delete the incomplete model dir AND the leftover
- * partial archive so the retry re-downloads from scratch. The model path is
- * error-message CONTENT, so the dir is only removed when it is a direct child
- * of the fastembed cache root — never touch a directory a dependency merely
- * names. Returns true when a retry is worth attempting (the incomplete cache
- * was cleared, or already gone from a concurrent heal).
- * @internal exported for tests
- */
-export async function clearIncompleteModelCache(message: string, cacheDir?: string): Promise<boolean> {
-	const match = /Model file not found at (.+?\.onnx)\b/i.exec(message);
-	if (!match) return false;
-	const modelFile = nodePath.resolve(match[1]);
-	const modelDir = nodePath.dirname(modelFile);
-	const cacheRoot = nodePath.resolve(cacheDir ?? getFastembedCacheDir());
-	// Only a direct child of the cache root: `<cacheRoot>/<model>`.
-	if (nodePath.dirname(modelDir) !== cacheRoot) return false;
-	try {
-		await fsp.rm(modelDir, { recursive: true, force: true });
-		await fsp.rm(`${modelDir}.tar.gz`, { force: true });
-		logger.warn("mnemopi: cleared incomplete local embedding model cache; re-downloading", { modelDir });
-	} catch {
-		// Concurrent heal or vanished dir: the single retry stays safe.
-	}
-	return true;
-}
-
-const SIDECAR_ERROR_RE =
-	/(?:Config file not found at .*config|Tokenizer file not found at .*tokenizer|Tokens map file not found at .*special_tokens_map)/u;
-
-/**
- * Shared local-model initializer: FlagEmbedding.init with BOTH cache heals.
- * Missing sidecars (config/tokenizer/tokens map) re-fetch and retry; a
- * corrupt model blob (Protobuf parse failure) quarantines the file and
- * retries THROUGH the sidecar heal, so a cache that is broken in both ways
- * still recovers in one pass. Also the initializer the embed worker uses in
- * its subprocess; the in-process seam stays {@link setLocalModelInitializer}.
+ * Shared local-model initializer: FlagEmbedding.init with a corrupt-cache heal.
+ * A corrupt model blob (Protobuf parse failure) quarantines the file and
+ * retries once; fastembed re-downloads any file missing from the model's
+ * cache directory. Also the initializer the embed worker uses in its
+ * subprocess; the in-process seam stays {@link setLocalModelInitializer}.
  */
 export async function defaultLocalModelInitializer(options: LocalModelInitOptions): Promise<LocalEmbeddingModel> {
 	const cacheDir = options.cacheDir ?? getFastembedCacheDir();
 	const initOptions = options.cacheDir === undefined ? { ...options, cacheDir } : options;
 	const { FlagEmbedding } = await loadFastembed();
-	const initWithSidecarHeal = async (): Promise<LocalEmbeddingModel> => {
-		try {
-			return await FlagEmbedding.init(initOptions);
-		} catch (error) {
-			const message = error instanceof Error ? error.message : "";
-			if (!SIDECAR_ERROR_RE.test(message)) throw error;
-			if (!(await ensureFastembedModelSidecars(options.model, cacheDir))) throw error;
-			return FlagEmbedding.init(initOptions);
-		}
-	};
 	try {
-		return await initWithSidecarHeal();
+		return await FlagEmbedding.init(initOptions);
 	} catch (error) {
 		const message = error instanceof Error ? error.message : "";
 		if (/Protobuf parsing failed/i.test(message) && (await quarantineCorruptModelFile(message, cacheDir))) {
-			return initWithSidecarHeal();
-		}
-		if (await clearIncompleteModelCache(message, cacheDir)) {
-			return initWithSidecarHeal();
+			return FlagEmbedding.init(initOptions);
 		}
 		throw error;
 	}
@@ -219,29 +168,7 @@ function effectiveMaxInputChars(): number {
 	if (override !== undefined) return Math.max(0, Math.trunc(override));
 	const envValue = Number.parseInt($env.MNEMOPI_EMBEDDING_MAX_INPUT_CHARS ?? "", 10);
 	if (Number.isFinite(envValue) && envValue >= 0) return envValue;
-	return 8192;
-}
-
-/** Elision marker injected between the retained head and tail of an oversized input. */
-const EMBEDDING_ELISION_MARKER = "\n\n[...]\n\n";
-
-/**
- * Right-clip a single oversized input to {@link max} chars while preserving
- * both ends. Retention transcripts are chronological (oldest → newest), so a
- * naive `slice(0, max)` would drop the most recent — and most semantically
- * loaded — turns once a session passed the cap, leaving every later retained
- * episode with essentially the same prefix vector. Keeping a head/tail split
- * lets the embedding capture the topic setup at the start AND the latest
- * exchanges at the end. Falls back to a tail-only clip when `max` is too
- * small to fit the elision marker plus a useful slice on either side.
- */
-function clipToWindow(text: string, max: number): string {
-	if (text.length <= max) return text;
-	if (max <= EMBEDDING_ELISION_MARKER.length + 16) return text.slice(text.length - max);
-	const budget = max - EMBEDDING_ELISION_MARKER.length;
-	const headLen = budget >>> 1;
-	const tailLen = budget - headLen;
-	return text.slice(0, headLen) + EMBEDDING_ELISION_MARKER + text.slice(text.length - tailLen);
+	return DEFAULT_INPUT_CHARS;
 }
 
 /**
@@ -368,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;
 }
@@ -462,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;
@@ -599,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) {