@linxiraos/pi-mnemopi 1.1.27 → 1.2.0

package/CHANGELOG.md

@@ -1,7 +1,14 @@
-# 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；本版无独立用户可见变化。

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/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/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.27",
-	"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,10 +39,10 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@linxiraos/pi-ai": "1.1.27",
-		"@linxiraos/pi-catalog": "1.1.27",
-		"@linxiraos/pi-natives": "1.1.27",
-		"@linxiraos/pi-utils": "1.1.27"
+		"@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": "3.0.0",

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,6 +11,7 @@ import {
 	fetchWithRetry,
 	getFastembedCacheDir,
 	logger,
+	withLoopPhase,
 } from "@linxiraos/pi-utils";
 import { LRUCache } from "@linxiraos/pi-utils/lru";
 import type { EmbeddingModel } from "fastembed";
@@ -21,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";
@@ -166,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;
 }
 
 /**
@@ -315,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;
 }
@@ -409,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;
@@ -546,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) {