scream-code 0.16.7 → 0.16.9

package/dist/src-BhZujafw.mjs

@@ -0,0 +1,4141 @@
+#!/usr/bin/env node
+import { fileURLToPath as __cjsShimFileURLToPath } from 'node:url';
+import { dirname as __cjsShimDirname } from 'node:path';
+const __filename = __cjsShimFileURLToPath(import.meta.url);
+const __dirname = __cjsShimDirname(__filename);
+import { createHash } from "node:crypto";
+import { mkdir, readFile, readdir, rename, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
+import { createReadStream, existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+//#region ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	if (!input) return input;
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
+const _PATH_ROOT_RE = /^[/\\]|^[a-zA-Z]:[/\\]/;
+const normalize = function(path) {
+	if (path.length === 0) return ".";
+	path = normalizeWindowsPath(path);
+	const isUNCPath = path.match(_UNC_REGEX);
+	const isPathAbsolute = isAbsolute$1(path);
+	const trailingSeparator = path[path.length - 1] === "/";
+	path = normalizeString(path, !isPathAbsolute);
+	if (path.length === 0) {
+		if (isPathAbsolute) return "/";
+		return trailingSeparator ? "./" : ".";
+	}
+	if (trailingSeparator) path += "/";
+	if (_DRIVE_LETTER_RE.test(path)) path += "/";
+	if (isUNCPath) {
+		if (!isPathAbsolute) return `//./${path}`;
+		return `//${path}`;
+	}
+	return isPathAbsolute && !isAbsolute$1(path) ? `/${path}` : path;
+};
+const join$1 = function(...segments) {
+	let path = "";
+	for (const seg of segments) {
+		if (!seg) continue;
+		if (path.length > 0) {
+			const pathTrailing = path[path.length - 1] === "/";
+			const segLeading = seg[0] === "/";
+			if (pathTrailing && segLeading) path += seg.slice(1);
+			else path += pathTrailing || segLeading ? seg : `/${seg}`;
+		} else path += seg;
+	}
+	return normalize(path);
+};
+function cwd() {
+	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
+	return "/";
+}
+const resolve$1 = function(...arguments_) {
+	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+		const path = index >= 0 ? arguments_[index] : cwd();
+		if (!path || path.length === 0) continue;
+		resolvedPath = `${path}/${resolvedPath}`;
+		resolvedAbsolute = isAbsolute$1(path);
+	}
+	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+	if (resolvedAbsolute && !isAbsolute$1(resolvedPath)) return `/${resolvedPath}`;
+	return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let char = null;
+	for (let index = 0; index <= path.length; ++index) {
+		if (index < path.length) char = path[index];
+		else if (char === "/") break;
+		else char = "/";
+		if (char === "/") {
+			if (lastSlash === index - 1 || dots === 1);
+			else if (dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+					if (res.length > 2) {
+						const lastSlashIndex = res.lastIndexOf("/");
+						if (lastSlashIndex === -1) {
+							res = "";
+							lastSegmentLength = 0;
+						} else {
+							res = res.slice(0, lastSlashIndex);
+							lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+						}
+						lastSlash = index;
+						dots = 0;
+						continue;
+					} else if (res.length > 0) {
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = index;
+						dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) {
+					res += res.length > 0 ? "/.." : "..";
+					lastSegmentLength = 2;
+				}
+			} else {
+				if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
+				else res = path.slice(lastSlash + 1, index);
+				lastSegmentLength = index - lastSlash - 1;
+			}
+			lastSlash = index;
+			dots = 0;
+		} else if (char === "." && dots !== -1) ++dots;
+		else dots = -1;
+	}
+	return res;
+}
+const isAbsolute$1 = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+};
+const extname$1 = function(p) {
+	if (p === "..") return "";
+	const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+	return match && match[1] || "";
+};
+const relative$1 = function(from, to) {
+	const _from = resolve$1(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	const _to = resolve$1(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) return _to.join("/");
+	const _fromCopy = [..._from];
+	for (const segment of _fromCopy) {
+		if (_to[0] !== segment) break;
+		_from.shift();
+		_to.shift();
+	}
+	return [..._from.map(() => ".."), ..._to].join("/");
+};
+const dirname$1 = function(p) {
+	const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+	if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
+	return segments.join("/") || (isAbsolute$1(p) ? "/" : ".");
+};
+const basename$1 = function(p, extension) {
+	const segments = normalizeWindowsPath(p).split("/");
+	let lastSegment = "";
+	for (let i = segments.length - 1; i >= 0; i--) {
+		const val = segments[i];
+		if (val) {
+			lastSegment = val;
+			break;
+		}
+	}
+	return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
+};
+const parse = function(p) {
+	const root = _PATH_ROOT_RE.exec(p)?.[0]?.replace(/\\/g, "/") || "";
+	const base = basename$1(p);
+	const extension = extname$1(base);
+	return {
+		root,
+		dir: dirname$1(p),
+		base,
+		ext: extension,
+		name: base.slice(0, base.length - extension.length)
+	};
+};
+//#endregion
+//#region ../../packages/memory/src/scoring.ts
+const TEMPORAL_STRONG = /昨天|今天|上周|本周|本月|最近|之前|以前|上次|刚刚|刚刚才|刚才|前天|大前天|前几天|这几天|这几天来|近.*[天周月年]/;
+const TEMPORAL_WEAK = /什么时候|何时|多久|几时|哪天|哪一天|多长.*时间/;
+const TEMPORAL_ACTION = /做了|干了|处理了|解决了|修复了|完成了|改了|写了|加了|删了|移除了|部署了|发布了/;
+const CODE_SIGNAL = /[`'"#]|[{}()[\]]|\.(ts|js|tsx|jsx|py|rs|go|java|cpp|c|h)\b|function |const |import |export |class |async |await |type |interface /;
+/**
+* Lightweight regex-based query intent detection.
+* Zero LLM cost — classifies into temporal vs factual bias to adjust scoring weights.
+*/
+function detectQueryIntent(query) {
+	const q = query.trim();
+	if (q.length === 0) return {
+		temporalBias: .3,
+		factualBias: .6
+	};
+	let temporalBias = .3;
+	let factualBias = .6;
+	if (TEMPORAL_STRONG.test(q)) temporalBias = 1;
+	else if (TEMPORAL_WEAK.test(q)) temporalBias = .8;
+	else if (TEMPORAL_ACTION.test(q)) temporalBias = .6;
+	if (CODE_SIGNAL.test(q) && !TEMPORAL_STRONG.test(q) && !TEMPORAL_WEAK.test(q)) factualBias = 1;
+	return {
+		temporalBias,
+		factualBias
+	};
+}
+/**
+* Multi-factor relevance score for a memory memo against a query.
+* Pure deterministic scoring — no LLM call, no network.
+*
+* When `intent` is provided, keyword weight increases for factual queries
+* and recency weight increases for temporal queries.
+*/
+function computeRelevanceScore(memo, query, usageCount = 0, currentProjectDir, projectTagCloud, intent) {
+	const ti = intent?.temporalBias ?? .3;
+	const fi = intent?.factualBias ?? .6;
+	const factors = {
+		keywordOverlap: computeKeywordSimilarity(memo, query),
+		recency: computeRecency(memo.recordedAt),
+		usageBoost: Math.min(.3, usageCount * .1),
+		projectBoost: computeProjectBoost(memo.projectDir, currentProjectDir),
+		tagOverlap: computeTagOverlap(memo.tags, projectTagCloud)
+	};
+	const kwWeight = .45 * (1 + (fi - .6) * .5);
+	const recencyWeight = .25 * (1 + (ti - .3) * .571);
+	const usageWeight = .15;
+	const projectWeight = .1;
+	const tagWeight = .05;
+	const total = kwWeight + recencyWeight + usageWeight + projectWeight + tagWeight;
+	return factors.keywordOverlap * (kwWeight / total) + factors.recency * (recencyWeight / total) + factors.usageBoost * (usageWeight / total) + factors.projectBoost * (projectWeight / total) + factors.tagOverlap * (tagWeight / total);
+}
+/**
+* Score multiple memos against a query, returning sorted results.
+*/
+function rankMemos(memos, query, options = {}) {
+	const { minScore = .3, maxResults = 3, currentProjectDir, projectTagCloud, vectorScores } = options;
+	const intent = detectQueryIntent(query);
+	const hasVectorScores = vectorScores !== void 0 && vectorScores.size > 0;
+	return memos.map((memo) => {
+		const keywordScore = computeRelevanceScore(memo, query, 0, currentProjectDir, projectTagCloud, intent);
+		const vectorScore = vectorScores?.get(memo.id) ?? 0;
+		return {
+			memo,
+			score: hasVectorScores ? keywordScore * .6 + vectorScore * .4 : keywordScore
+		};
+	}).filter((s) => s.score >= minScore).toSorted((a, b) => b.score - a.score).slice(0, maxResults);
+}
+/**
+* Build a tag cloud from memos that belong to the current project.
+*/
+function buildProjectTagCloud(memos, projectDir) {
+	const cloud = /* @__PURE__ */ new Set();
+	for (const memo of memos) if (memo.projectDir === projectDir && memo.tags !== void 0) for (const tag of memo.tags) cloud.add(tag);
+	return cloud;
+}
+function computeProjectBoost(memoProjectDir, currentProjectDir) {
+	if (currentProjectDir === void 0 || currentProjectDir.length === 0) return 0;
+	if (memoProjectDir === currentProjectDir) return 1;
+	if (memoProjectDir.length === 0) return 0;
+	const memoParent = parentDir(memoProjectDir);
+	const currentParent = parentDir(currentProjectDir);
+	if (memoParent.length > 0 && memoParent === currentParent) return .3;
+	return 0;
+}
+function parentDir(path) {
+	const trimmed = path.replace(/\/+$/, "");
+	const lastSep = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
+	return lastSep > 0 ? trimmed.slice(0, lastSep) : "";
+}
+function computeTagOverlap(memoTags, projectTagCloud) {
+	if (projectTagCloud === void 0 || projectTagCloud.size === 0) return 0;
+	if (memoTags === void 0 || memoTags.length === 0) return 0;
+	const memoSet = new Set(memoTags);
+	let intersection = 0;
+	for (const tag of memoSet) if (projectTagCloud.has(tag)) intersection++;
+	const union = new Set([...memoSet, ...projectTagCloud]).size;
+	return union === 0 ? 0 : intersection / union;
+}
+const STOP_WORDS = new Set([
+	"的",
+	"了",
+	"在",
+	"是",
+	"我",
+	"有",
+	"和",
+	"就",
+	"不",
+	"人",
+	"都",
+	"一",
+	"一个",
+	"上",
+	"也",
+	"很",
+	"到",
+	"说",
+	"要",
+	"去",
+	"你",
+	"会",
+	"着",
+	"没有",
+	"看",
+	"好",
+	"自己",
+	"这",
+	"他",
+	"她",
+	"它",
+	"们",
+	"那",
+	"些",
+	"the",
+	"a",
+	"an",
+	"is",
+	"are",
+	"was",
+	"were",
+	"be",
+	"been",
+	"being",
+	"have",
+	"has",
+	"had",
+	"do",
+	"does",
+	"did",
+	"will",
+	"would",
+	"could",
+	"should",
+	"may",
+	"might",
+	"can",
+	"shall",
+	"to",
+	"of",
+	"in",
+	"for",
+	"on",
+	"with",
+	"at",
+	"by",
+	"from",
+	"as",
+	"into",
+	"through",
+	"during",
+	"before",
+	"after",
+	"above",
+	"below",
+	"between",
+	"and",
+	"but",
+	"or",
+	"nor",
+	"not",
+	"so",
+	"yet",
+	"both",
+	"either",
+	"neither",
+	"each",
+	"every",
+	"all",
+	"any",
+	"few",
+	"more",
+	"most",
+	"other",
+	"some",
+	"such",
+	"no",
+	"only",
+	"own",
+	"same",
+	"than",
+	"too",
+	"very",
+	"just",
+	"because",
+	"about",
+	"what",
+	"which",
+	"who",
+	"whom",
+	"this",
+	"that",
+	"these",
+	"those",
+	"it",
+	"its",
+	"he",
+	"she",
+	"they",
+	"we",
+	"you",
+	"how"
+]);
+function extractKeywords(text) {
+	const parts = text.toLowerCase().replaceAll(/([一-鿿㐀-䶿])([a-z0-9])/g, "$1 $2").replaceAll(/([a-z0-9])([一-鿿㐀-䶿])/g, "$1 $2").split(/[^a-z0-9一-鿿㐀-䶿]+/);
+	const tokens = [];
+	for (const part of parts) {
+		if (part.length === 0) continue;
+		if (/[一-鿿㐀-䶿]/.test(part)) {
+			for (const ch of part) if (ch.length > 0 && !STOP_WORDS.has(ch)) tokens.push(ch);
+		}
+		if (/^[a-z0-9]+$/.test(part) && part.length >= 2 && !STOP_WORDS.has(part)) tokens.push(part);
+	}
+	return [...new Set(tokens)];
+}
+function computeKeywordSimilarity(memo, query) {
+	const memoWords = extractKeywords(`${memo.userNeed} ${memo.approach} ${memo.whatFailed} ${memo.whatWorked}`);
+	const queryWords = extractKeywords(query);
+	if (memoWords.length === 0 || queryWords.length === 0) return 0;
+	const intersection = memoWords.filter((w) => queryWords.includes(w)).length;
+	const union = new Set([...memoWords, ...queryWords]).size;
+	return union === 0 ? 0 : intersection / union;
+}
+function computeRecency(recordedAt) {
+	const daysSince = (Date.now() - recordedAt) / (1e3 * 60 * 60 * 24);
+	return Math.max(0, 1 - daysSince / 90);
+}
+//#endregion
+//#region ../../packages/memory/src/tags.ts
+/**
+* Normalize a tag list: lowercase, trim, deduplicate, drop empties,
+* and cap at `max` entries.
+*/
+function normalizeTags(tags, max = 5) {
+	if (!Array.isArray(tags)) return [];
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const raw of tags) {
+		if (typeof raw !== "string") continue;
+		const tag = raw.trim().toLowerCase();
+		if (tag.length === 0 || seen.has(tag)) continue;
+		seen.add(tag);
+		result.push(tag);
+		if (result.length >= max) break;
+	}
+	return result;
+}
+/**
+* Generate a small set of semantic tags from free-form text.
+* Falls back to keyword extraction when the caller does not supply tags.
+*/
+function generateTags(text, max = 5) {
+	return normalizeTags(extractKeywords(text), max);
+}
+//#endregion
+//#region ../../packages/memory/src/models.ts
+function generateId$1() {
+	return `memo-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function createMemoryMemo(partial) {
+	return {
+		id: partial.id ?? generateId$1(),
+		sourceSessionId: partial.sourceSessionId,
+		sourceSessionTitle: partial.sourceSessionTitle,
+		userNeed: partial.userNeed,
+		approach: partial.approach,
+		outcome: partial.outcome,
+		whatFailed: partial.whatFailed,
+		whatWorked: partial.whatWorked,
+		extractionSource: partial.extractionSource,
+		recordedAt: partial.recordedAt ?? Date.now(),
+		projectDir: partial.projectDir ?? "",
+		tags: normalizedTags(partial.tags),
+		note: partial.note
+	};
+}
+function normalizedTags(value) {
+	const tags = normalizeTags(value);
+	return tags.length > 0 ? tags : void 0;
+}
+function toSummary(memo) {
+	return {
+		id: memo.id,
+		sourceSessionTitle: memo.sourceSessionTitle,
+		sourceSessionId: memo.sourceSessionId,
+		userNeed: memo.userNeed,
+		approach: memo.approach,
+		outcome: memo.outcome,
+		whatFailed: memo.whatFailed,
+		whatWorked: memo.whatWorked,
+		extractionSource: memo.extractionSource,
+		recordedAt: memo.recordedAt,
+		projectDir: memo.projectDir,
+		tags: memo.tags,
+		note: memo.note
+	};
+}
+//#endregion
+//#region ../../packages/memory/src/embeddings.ts
+/**
+* Text used to generate embeddings for a memo.
+* Combines the most semantically meaningful fields.
+*/
+function buildEmbeddingText(memo) {
+	return `${memo.userNeed} ${memo.approach} ${memo.whatWorked}`;
+}
+/**
+* Cache of created engines keyed by cacheDir.
+* Guarantees that all callers sharing the same cacheDir reuse the same engine
+* instance and the same in-flight model download/load — avoiding duplicate
+* downloads and file-corruption races when /memory and /knowledge both start
+* before the model is cached.
+*/
+const engineCache = /* @__PURE__ */ new Map();
+/**
+* Create an embedding engine backed by fastembed.
+* Lazily loads the model on first use so startup is not blocked.
+* Engines are cached by cacheDir so repeated calls with the same cacheDir
+* return the same instance, sharing model state and download progress.
+* @param cacheDir Absolute path for model cache (e.g. ~/.scream-code/cache/fastembed).
+*                 Defaults to "local_cache" (CWD-relative) if not provided — prefer
+*                 passing an explicit path so the cache doesn't duplicate across CWDs.
+*/
+function createFastEmbedEngine(cacheDir) {
+	const key = cacheDir ?? "";
+	const cached = engineCache.get(key);
+	if (cached !== void 0) return cached;
+	const engine = createFastEmbedEngineImpl(cacheDir);
+	engineCache.set(key, engine);
+	return engine;
+}
+/** Stable identity of the model used by every engine created here. */
+const EMBEDDING_MODEL_NAME = "bge-small-zh-v1.5";
+function createFastEmbedEngineImpl(cacheDir) {
+	let embedder = null;
+	let initPromise = null;
+	let loadFailed = false;
+	let lastError;
+	return {
+		modelName: EMBEDDING_MODEL_NAME,
+		get available() {
+			return embedder !== null && !loadFailed;
+		},
+		get lastError() {
+			return lastError;
+		},
+		async embedBatch(texts) {
+			if (!this.available) return null;
+			if (texts.length === 0) return [];
+			try {
+				const generator = embedder.embed(texts);
+				const vectors = [];
+				for await (const batch of generator) for (const vec of batch) vectors.push(new Float32Array(vec));
+				return vectors.length > 0 ? vectors : null;
+			} catch (error) {
+				lastError = error instanceof Error ? error.message : String(error);
+				return null;
+			}
+		},
+		cosineSimilarity(a, b) {
+			if (a.length !== b.length || a.length === 0) return 0;
+			let dot = 0;
+			let normA = 0;
+			let normB = 0;
+			for (let i = 0; i < a.length; i++) {
+				dot += a[i] * b[i];
+				normA += a[i] * a[i];
+				normB += b[i] * b[i];
+			}
+			const denom = Math.sqrt(normA) * Math.sqrt(normB);
+			return denom === 0 ? 0 : dot / denom;
+		},
+		async ensureReady() {
+			if (embedder !== null) {
+				loadFailed = false;
+				lastError = void 0;
+				return true;
+			}
+			try {
+				if (loadFailed || initPromise === null) {
+					loadFailed = false;
+					lastError = void 0;
+					initPromise = loadEmbedder(cacheDir);
+				}
+				embedder = await initPromise;
+				if (embedder === null) {
+					initPromise = null;
+					lastError = "fastembed returned an empty model";
+					return false;
+				}
+				loadFailed = false;
+				lastError = void 0;
+				return true;
+			} catch (error) {
+				initPromise = null;
+				loadFailed = true;
+				lastError = error instanceof Error ? error.message : String(error);
+				return false;
+			}
+		}
+	};
+}
+async function loadEmbedder(cacheDir) {
+	const { FlagEmbedding, EmbeddingModel } = await import("fastembed");
+	if (cacheDir !== void 0) mkdirSync(cacheDir, { recursive: true });
+	const model = EmbeddingModel.BGESmallZH;
+	const initOpts = cacheDir !== void 0 ? {
+		model,
+		cacheDir
+	} : { model };
+	try {
+		return await FlagEmbedding.init(initOpts);
+	} catch (initError) {
+		const msg = initError instanceof Error ? initError.message : "";
+		if (!/Config file not found|Tokenizer file not found|Tokens map file not found/iu.test(msg)) throw initError;
+		await ensureFastembedModelSidecars(model, cacheDir);
+		return FlagEmbedding.init(initOpts);
+	}
+}
+/**
+* Cache entry names fastembed uses for the fixed BGESmallZH model: it extracts
+* into `<cacheDir>/<name>/` from the staged archive `<cacheDir>/<name>.tar.gz`.
+*/
+const BGESMALLZH_CACHE_NAME = "fast-bge-small-zh-v1.5";
+const PLATFORM_FAILURE = /@anush008\/tokenizers|Failed to load native binding|Unsupported (?:OS|platform|architecture)|ERR_DLOPEN_FAILED|invalid ELF header|Exec format error|is not a valid Win32 application|GLIBC_\d+[^"\n]*not found|Error loading shared library|cannot open shared object file/iu;
+const ARCHIVE_FAILURE = /\bTAR_[A-Z_]+|incorrect header check|unexpected end of file|invalid tar|zlib/iu;
+const NETWORK_FAILURE = /\b(?:ENOTFOUND|EAI_AGAIN|ETIMEDOUT|ECONNRESET|ECONNREFUSED|EHOSTUNREACH|socket hang up|fetch failed)\b|network error|HTTP \d{3}/iu;
+/**
+* Classify a load failure so callers can say something true about it: the four
+* causes need four different answers (unsupported platform, corrupt cache,
+* network, unknown), and they used to be reported as one network problem.
+*/
+function classifyEmbeddingFailure(message) {
+	if (message === void 0) return "other";
+	if (PLATFORM_FAILURE.test(message)) return "platform";
+	if (ARCHIVE_FAILURE.test(message)) return "archive";
+	if (NETWORK_FAILURE.test(message)) return "network";
+	return "other";
+}
+/**
+* Loads only the module entry point — no model download — so callers can tell
+* "this machine cannot run the local model at all" apart from "the download
+* failed". fastembed imports its native tokenizer binding at module scope, which
+* is exactly the step a platform without a published binary cannot pass.
+*/
+async function probeLocalEmbeddingSupport() {
+	try {
+		await import("fastembed");
+		return { supported: true };
+	} catch (error) {
+		return {
+			supported: false,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+/**
+* Remove every trace of a previous BGESmallZH download: the extracted model
+* directory *and* the staged archive it came from.
+*
+* The archive has to go with it. fastembed skips the download whenever
+* `<cacheDir>/<name>.tar.gz` exists, and it only deletes that file after a
+* *successful* extract — its download error paths (response error, file stream
+* error) reject and leave whatever was written behind. So an archive sitting
+* next to a failed attempt is usually a partial leftover, and keeping it makes
+* every retry extract the same junk locally: no network traffic, a few
+* milliseconds, the same failure forever.
+*
+* Never throws: a file locked by another process (on Windows a mapped ONNX file
+* stays locked) must not replace the download error the caller is reporting.
+*/
+function clearEmbeddingModelCache(cacheDir) {
+	for (const name of [BGESMALLZH_CACHE_NAME, `${BGESMALLZH_CACHE_NAME}.tar.gz`]) {
+		const target = join(cacheDir, name);
+		if (!existsSync(target)) continue;
+		try {
+			rmSync(target, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
+}
+/**
+* True when the extracted model weights are already on disk. Loading then
+* never downloads (fastembed skips the fetch whenever the model dir exists),
+* so callers can safely trigger a local load without risking a surprise
+* mid-query download.
+*/
+function hasEmbeddingModelCache(cacheDir) {
+	const modelDir = join(cacheDir, BGESMALLZH_CACHE_NAME);
+	return existsSync(modelDir) && existsSync(join(modelDir, "model_optimized.onnx"));
+}
+/**
+* Small config/tokenizer files that fastembed expects alongside model.onnx.
+* If these are missing (e.g. GCS download partially failed), fastembed throws.
+* We download them from HuggingFace so the model can load — this covers the
+* case where the GCS tarball was incomplete but the HF repo is reachable.
+*/
+const FASTEMBED_SIDECARS = [
+	"config.json",
+	"tokenizer.json",
+	"tokenizer_config.json",
+	"special_tokens_map.json"
+];
+const FASTEMBED_HF_REPOS = { "fast-bge-small-zh-v1.5": "BAAI/bge-small-zh-v1.5" };
+async function ensureFastembedModelSidecars(model, cacheDir) {
+	const repo = FASTEMBED_HF_REPOS[model];
+	if (repo === void 0) return;
+	const modelDir = join(cacheDir ?? "local_cache", model);
+	mkdirSync(modelDir, { recursive: true });
+	for (const fileName of FASTEMBED_SIDECARS) {
+		const target = join(modelDir, fileName);
+		try {
+			const { access } = await import("node:fs/promises");
+			await access(target);
+			continue;
+		} catch {}
+		const hfUrl = `https://huggingface.co/${repo}/resolve/main/${fileName}`;
+		try {
+			const response = await fetch(hfUrl);
+			if (!response.ok) continue;
+			const { writeFile } = await import("node:fs/promises");
+			await writeFile(target, Buffer.from(await response.arrayBuffer()));
+		} catch {}
+	}
+}
+//#endregion
+//#region ../../packages/memory/src/store.ts
+const FILE_NAME = "entries.jsonl";
+const MIGRATION_MARKER = ".migrated";
+const SQLITE_MIGRATION_MARKER = ".migrated-to-sqlite";
+var MemoryMemoStore = class MemoryMemoStore {
+	projectDir;
+	jsonlPath;
+	dbPath;
+	db;
+	initialized = false;
+	writeLock = Promise.resolve();
+	embeddingEngine;
+	embeddingQueue = /* @__PURE__ */ new Set();
+	embeddingTimer;
+	embeddingFlushing = false;
+	embeddingDegraded = false;
+	embeddingConsecutiveFailures = 0;
+	lastEmbeddingError;
+	log;
+	constructor(projectDir, log) {
+		this.projectDir = projectDir;
+		this.jsonlPath = join$1(projectDir, "memory", FILE_NAME);
+		this.dbPath = join$1(projectDir, "memory", "memos.sqlite");
+		this.log = log ?? {};
+	}
+	/**
+	* Open the SQLite database and run schema migrations. Call this once after
+	* construction before relying on reads/writes.
+	*
+	* Note on async SQLite: Node.js added the asynchronous `Database` class to
+	* `node:sqlite` in v23.4.0 (experimental). This package currently supports
+	* Node >=22.0.0 and uses `DatabaseSync` because the v22 type definitions do
+	* not yet include `Database`. Once the project baseline moves to Node 23+ and
+	* the types catch up, the synchronous calls here should be migrated to the
+	* async API to avoid blocking the event loop on large operations.
+	*/
+	initPromise = null;
+	async init() {
+		if (this.initPromise) return this.initPromise;
+		this.initPromise = this._doInit().catch((error) => {
+			this.initPromise = null;
+			throw error;
+		});
+		return this.initPromise;
+	}
+	async _doInit() {
+		if (this.initialized) return;
+		await this.ensureDir();
+		this.db = new DatabaseSync(this.dbPath);
+		this.db.exec("PRAGMA journal_mode = WAL;");
+		this.db.exec("PRAGMA foreign_keys = ON;");
+		this.db.exec("PRAGMA busy_timeout = 5000;");
+		this.createSchema();
+		await this.migrateFromJsonl();
+		this.initialized = true;
+	}
+	/** Close the database handle and checkpoint WAL. */
+	close() {
+		if (this.embeddingTimer !== void 0) {
+			clearTimeout(this.embeddingTimer);
+			this.embeddingTimer = void 0;
+		}
+		this.embeddingQueue.clear();
+		if (this.db !== void 0) {
+			this.db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+			this.db.close();
+			this.db = void 0;
+		}
+		this.initialized = false;
+		this.initPromise = null;
+	}
+	/** Iterate all memos from the database, newest first. Optionally filter by project directory. */
+	async *read(options) {
+		await this.init();
+		if (this.db === void 0) return;
+		const projectDir = options?.projectDir;
+		const stmt = projectDir === void 0 ? this.db.prepare("SELECT * FROM memos ORDER BY recorded_at DESC") : this.db.prepare("SELECT * FROM memos WHERE project_dir = ? OR project_dir = '' ORDER BY recorded_at DESC");
+		const rows = projectDir === void 0 ? stmt.all() : stmt.all(projectDir);
+		for (const row of rows) yield rowToMemo(row);
+	}
+	/** Append a memo. */
+	async append(entry) {
+		return this.withWriteLock(() => this.appendInternal(entry));
+	}
+	/**
+	* True when a memo with the same source session + user need + approach
+	* already exists. Used by compaction-summary recovery to re-store memos
+	* idempotently after a crash between compaction apply and extraction.
+	* The approach field keeps two distinct memos that happen to share the
+	* same user need from being collapsed into one.
+	*/
+	existsBySourceAndNeed(sourceSessionId, userNeed, approach) {
+		if (this.db === void 0) return false;
+		return this.db.prepare("SELECT 1 FROM memos WHERE source_session_id = ? AND user_need = ? AND approach = ? LIMIT 1").get(sourceSessionId, userNeed, approach) !== void 0;
+	}
+	/** Delete a memo by id. */
+	async delete(id) {
+		return this.withWriteLock(() => this.deleteInternal(id));
+	}
+	/** Get a single memo by ID. */
+	async get(id) {
+		await this.init();
+		if (this.db === void 0) return void 0;
+		const row = this.db.prepare("SELECT * FROM memos WHERE id = ?").get(id);
+		return row !== void 0 ? rowToMemo(row) : void 0;
+	}
+	/**
+	* Full-text search over memos using the FTS5 index.
+	*
+	* Returns raw candidates newest first. Callers that need ranking should pass
+	* the results to `rankMemos`. An empty or whitespace-only query returns an
+	* empty array.
+	*/
+	async search(query, options) {
+		await this.init();
+		if (this.db === void 0) return [];
+		const ftsQuery = buildFtsQuery$1(query);
+		if (ftsQuery === void 0) return [];
+		const limit = options?.candidateLimit ?? 200;
+		const projectDir = options?.projectDir;
+		const stmt = projectDir === void 0 ? this.db.prepare(`SELECT m.* FROM memos m
+         JOIN memos_fts f ON m.rowid = f.rowid
+         WHERE f.memos_fts MATCH ?
+         ORDER BY m.recorded_at DESC LIMIT ?`) : this.db.prepare(`SELECT m.* FROM memos m
+         JOIN memos_fts f ON m.rowid = f.rowid
+         WHERE f.memos_fts MATCH ? AND (m.project_dir = ? OR m.project_dir = '')
+         ORDER BY m.recorded_at DESC LIMIT ?`);
+		return (projectDir === void 0 ? stmt.all(ftsQuery, limit) : stmt.all(ftsQuery, projectDir, limit)).map(rowToMemo);
+	}
+	/** List memos with optional full-text search and pagination. */
+	async list(options) {
+		await this.init();
+		if (this.db === void 0) return {
+			memos: [],
+			total: 0
+		};
+		const search = options?.search?.toLowerCase().trim();
+		const limit = options?.limit ?? 50;
+		const offset = options?.offset ?? 0;
+		const projectDir = options?.projectDir;
+		if (search !== void 0 && search.length > 0) {
+			let candidates = await this.search(search, { projectDir });
+			if (candidates.length === 0) for await (const memo of this.read({ projectDir })) candidates.push(memo);
+			const filtered = candidates.filter((memo) => memoMatchesSearch(memo, search));
+			const total = filtered.length;
+			return {
+				memos: filtered.slice(offset, offset + limit).map(toSummary),
+				total
+			};
+		}
+		const { rows, total } = this.listAll(limit, offset, projectDir);
+		return {
+			memos: rows.map(toSummary),
+			total
+		};
+	}
+	/**
+	* One-time migration from per-workDir memory stores to a global store.
+	* Reads `<screamHomeDir>/sessions/<workDirKey>/memory/entries.jsonl`
+	* and appends valid entries to the global SQLite store.
+	* Deletes the legacy per-session memory files afterwards and writes a marker
+	* file so the migration only runs once.
+	*/
+	static async migrateLegacyStores(screamHomeDir) {
+		const target = new MemoryMemoStore(screamHomeDir);
+		const markerPath = join$1(screamHomeDir, "memory", MIGRATION_MARKER);
+		try {
+			await stat(markerPath);
+			return;
+		} catch {}
+		const sessionsDir = join$1(screamHomeDir, "sessions");
+		let sessionEntries;
+		try {
+			sessionEntries = await readdir(sessionsDir, { withFileTypes: true }).then((entries) => entries.filter((e) => e.isDirectory()).map((e) => e.name));
+		} catch {
+			await writeFile(markerPath, "", "utf8").catch(() => {});
+			return;
+		}
+		const migratedIds = /* @__PURE__ */ new Set();
+		for await (const memo of target.read()) migratedIds.add(memo.id);
+		let migratedCount = 0;
+		const legacyPaths = [];
+		for (const sessionKey of sessionEntries) {
+			const legacyPath = join$1(sessionsDir, sessionKey, "memory", FILE_NAME);
+			let stream;
+			try {
+				stream = createReadStream(legacyPath, { encoding: "utf8" });
+			} catch {}
+			stream.on("error", () => {});
+			let line = "";
+			try {
+				for await (const chunk of stream) {
+					line += chunk;
+					let newlineIndex = line.indexOf("\n");
+					while (newlineIndex !== -1) {
+						const rawLine = line.slice(0, newlineIndex).replace(/\r$/, "");
+						line = line.slice(newlineIndex + 1);
+						newlineIndex = line.indexOf("\n");
+						const memo = target.parseLine(rawLine, 0);
+						if (memo === void 0 || migratedIds.has(memo.id)) continue;
+						await target.append(memo);
+						migratedIds.add(memo.id);
+						migratedCount++;
+					}
+				}
+			} catch {
+				continue;
+			}
+			legacyPaths.push(legacyPath);
+		}
+		for (const legacyPath of legacyPaths) {
+			await unlink(legacyPath).catch(() => {});
+			await rmdir(dirname$1(legacyPath)).catch(() => {});
+		}
+		await writeFile(markerPath, `${migratedCount}\n`, "utf8").catch(() => {});
+	}
+	/** @internal */
+	parseLine(rawLine, _lineNumber) {
+		if (rawLine.length === 0) return void 0;
+		try {
+			const record = JSON.parse(rawLine);
+			if (record["type"] !== "memory_memo" || !record["entry"]) return void 0;
+			const entry = record["entry"];
+			if (record["version"] === 1 || entry["userRequirement"] !== void 0 && entry["userNeed"] === void 0) {
+				const str = (v, fallback = "") => typeof v === "string" ? v : fallback;
+				return {
+					id: str(entry["id"]),
+					sourceSessionId: str(entry["sourceSessionId"]),
+					sourceSessionTitle: str(entry["sourceSessionTitle"], void 0),
+					userNeed: str(entry["userRequirement"]),
+					approach: str(entry["solution"]),
+					outcome: str(entry["completionStatus"]),
+					whatFailed: str(entry["problemsEncountered"], "none"),
+					whatWorked: "none",
+					extractionSource: entry["extractionSource"] === "exit" ? "exit" : "compaction",
+					recordedAt: typeof entry["recordedAt"] === "number" ? entry["recordedAt"] : 0,
+					projectDir: str(entry["projectDir"])
+				};
+			}
+			const src = entry["extractionSource"];
+			if (typeof src === "string" && ![
+				"compaction",
+				"exit",
+				"manual"
+			].includes(src)) return;
+			return entry;
+		} catch {
+			return;
+		}
+	}
+	createSchema() {
+		if (this.db === void 0) return;
+		this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memos (
+        id TEXT PRIMARY KEY,
+        source_session_id TEXT NOT NULL,
+        source_session_title TEXT,
+        user_need TEXT NOT NULL,
+        approach TEXT NOT NULL,
+        outcome TEXT NOT NULL,
+        what_failed TEXT NOT NULL DEFAULT 'none',
+        what_worked TEXT NOT NULL DEFAULT 'none',
+        extraction_source TEXT NOT NULL CHECK(extraction_source IN ('compaction', 'exit', 'manual')),
+        recorded_at INTEGER NOT NULL,
+        project_dir TEXT NOT NULL DEFAULT '',
+        tags TEXT NOT NULL DEFAULT '[]'
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_memos_project_dir ON memos(project_dir);
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS memos_fts USING fts5(
+        user_need,
+        approach,
+        what_failed,
+        what_worked,
+        source_session_title,
+        content=''
+      );
+
+      CREATE TABLE IF NOT EXISTS memory_embeddings (
+        memory_id TEXT PRIMARY KEY REFERENCES memos(id) ON DELETE CASCADE,
+        embedding_json TEXT NOT NULL,
+        model TEXT NOT NULL DEFAULT '${EMBEDDING_MODEL_NAME}',
+        created_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_memory_embeddings_created_at ON memory_embeddings(created_at DESC);
+    `);
+		this.migrateSchema();
+	}
+	migrateSchema() {
+		if (this.db === void 0) return;
+		const info = this.db.prepare("PRAGMA table_info(memos)").all();
+		if (!info.some((col) => col.name === "project_dir")) this.db.exec("ALTER TABLE memos ADD COLUMN project_dir TEXT NOT NULL DEFAULT ''");
+		if (!info.some((col) => col.name === "tags")) this.db.exec("ALTER TABLE memos ADD COLUMN tags TEXT NOT NULL DEFAULT '[]'");
+		this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_memos_project_dir ON memos(project_dir);
+      CREATE INDEX IF NOT EXISTS idx_memory_embeddings_created_at ON memory_embeddings(created_at DESC);
+    `);
+	}
+	async migrateFromJsonl() {
+		const markerPath = join$1(this.projectDir, "memory", SQLITE_MIGRATION_MARKER);
+		try {
+			await stat(markerPath);
+			return;
+		} catch {}
+		const memos = [];
+		let stream;
+		try {
+			stream = createReadStream(this.jsonlPath, { encoding: "utf8" });
+		} catch {
+			await writeFile(markerPath, "", "utf8").catch(() => {});
+			return;
+		}
+		stream.on("error", () => {});
+		let line = "";
+		try {
+			for await (const chunk of stream) {
+				line += chunk;
+				let newlineIndex = line.indexOf("\n");
+				while (newlineIndex !== -1) {
+					const rawLine = line.slice(0, newlineIndex).replace(/\r$/, "");
+					line = line.slice(newlineIndex + 1);
+					newlineIndex = line.indexOf("\n");
+					const memo = this.parseLine(rawLine, 0);
+					if (memo !== void 0) memos.push(memo);
+				}
+			}
+		} catch {}
+		if (memos.length > 0) this.insertMany(memos);
+		await writeFile(markerPath, "", "utf8").catch(() => {});
+		await rename(this.jsonlPath, `${this.jsonlPath}.bak`).catch(() => {});
+		await unlink(join$1(this.projectDir, "memory", "index.json")).catch(() => {});
+	}
+	insertMany(memos) {
+		if (this.db === void 0 || memos.length === 0) return;
+		const insert = this.db.prepare(`INSERT OR IGNORE INTO memos (
+        id, source_session_id, source_session_title, user_need, approach,
+        outcome, what_failed, what_worked, extraction_source, recorded_at, project_dir, tags
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      RETURNING rowid`);
+		const insertFts = this.db.prepare(`INSERT INTO memos_fts(rowid, user_need, approach, what_failed, what_worked, source_session_title)
+       VALUES (?, ?, ?, ?, ?, ?)`);
+		this.db.exec("BEGIN TRANSACTION");
+		try {
+			for (const memo of memos) {
+				const row = insert.get(memo.id, memo.sourceSessionId, memo.sourceSessionTitle ?? null, memo.userNeed, memo.approach, memo.outcome, memo.whatFailed, memo.whatWorked, memo.extractionSource, memo.recordedAt, memo.projectDir ?? "", JSON.stringify(memo.tags ?? []));
+				if (row === void 0) continue;
+				insertFts.run(row.rowid, toFtsText$1(memo.userNeed), toFtsText$1(memo.approach), toFtsText$1(memo.whatFailed), toFtsText$1(memo.whatWorked), toFtsText$1(memo.sourceSessionTitle ?? ""));
+			}
+			this.db.exec("COMMIT");
+		} catch (error) {
+			this.db.exec("ROLLBACK");
+			throw new Error(`Failed to migrate memos to SQLite: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+		}
+	}
+	async appendInternal(entry) {
+		await this.init();
+		if (this.db === void 0) return;
+		const insert = this.db.prepare(`INSERT INTO memos (
+        id, source_session_id, source_session_title, user_need, approach,
+        outcome, what_failed, what_worked, extraction_source, recorded_at, project_dir, tags
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      RETURNING rowid`);
+		const insertFts = this.db.prepare(`INSERT INTO memos_fts(rowid, user_need, approach, what_failed, what_worked, source_session_title)
+       VALUES (?, ?, ?, ?, ?, ?)`);
+		this.db.exec("BEGIN TRANSACTION");
+		try {
+			const row = insert.get(entry.id, entry.sourceSessionId, entry.sourceSessionTitle ?? null, entry.userNeed, entry.approach, entry.outcome, entry.whatFailed, entry.whatWorked, entry.extractionSource, entry.recordedAt, entry.projectDir ?? "", JSON.stringify(entry.tags ?? []));
+			insertFts.run(row.rowid, toFtsText$1(entry.userNeed), toFtsText$1(entry.approach), toFtsText$1(entry.whatFailed), toFtsText$1(entry.whatWorked), toFtsText$1(entry.sourceSessionTitle ?? ""));
+			this.db.exec("COMMIT");
+			this.scheduleEmbedding(entry);
+		} catch {
+			this.db.exec("ROLLBACK");
+			throw new Error("Failed to append memo");
+		}
+	}
+	/** Update a memo by id. Returns true if the memo existed and was updated. */
+	async update(id, patch) {
+		return this.withWriteLock(() => this.updateInternal(id, patch));
+	}
+	/** @internal */
+	async updateInternal(id, patch) {
+		await this.init();
+		if (this.db === void 0) return false;
+		const existing = await this.get(id);
+		if (existing === void 0) return false;
+		const updated = {
+			...existing,
+			...patch
+		};
+		const selectRow = this.db.prepare("SELECT rowid FROM memos WHERE id = ?");
+		const update = this.db.prepare(`UPDATE memos SET
+        rowid = (SELECT COALESCE(MAX(rowid), 0) + 1 FROM memos),
+        source_session_id = ?,
+        source_session_title = ?,
+        user_need = ?,
+        approach = ?,
+        outcome = ?,
+        what_failed = ?,
+        what_worked = ?,
+        extraction_source = ?,
+        recorded_at = ?,
+        project_dir = ?,
+        tags = ?
+      WHERE id = ?
+      RETURNING rowid`);
+		const updateFts = this.db.prepare(`INSERT INTO memos_fts(rowid, user_need, approach, what_failed, what_worked, source_session_title)
+       VALUES (?, ?, ?, ?, ?, ?)`);
+		const deleteFts = this.db.prepare("INSERT INTO memos_fts(memos_fts, rowid) VALUES ('delete', ?)");
+		const deleteEmbedding = this.db.prepare("DELETE FROM memory_embeddings WHERE memory_id = ?");
+		this.db.exec("BEGIN TRANSACTION");
+		try {
+			const oldRow = selectRow.get(id);
+			if (oldRow === void 0) {
+				this.db.exec("ROLLBACK");
+				return false;
+			}
+			const row = update.get(updated.sourceSessionId, updated.sourceSessionTitle ?? null, updated.userNeed, updated.approach, updated.outcome, updated.whatFailed, updated.whatWorked, updated.extractionSource, updated.recordedAt, updated.projectDir ?? "", JSON.stringify(updated.tags ?? []), id);
+			if (row === void 0) {
+				this.db.exec("ROLLBACK");
+				return false;
+			}
+			deleteFts.run(oldRow.rowid);
+			updateFts.run(row.rowid, toFtsText$1(updated.userNeed), toFtsText$1(updated.approach), toFtsText$1(updated.whatFailed), toFtsText$1(updated.whatWorked), toFtsText$1(updated.sourceSessionTitle ?? ""));
+			deleteEmbedding.run(id);
+			this.db.exec("COMMIT");
+			this.scheduleEmbedding(updated);
+			return true;
+		} catch {
+			this.db.exec("ROLLBACK");
+			throw new Error("Failed to update memo");
+		}
+	}
+	async deleteInternal(id) {
+		await this.init();
+		if (this.db === void 0) return false;
+		const row = this.db.prepare("SELECT rowid FROM memos WHERE id = ?").get(id);
+		if (row === void 0) return true;
+		const deleteFts = this.db.prepare("INSERT INTO memos_fts(memos_fts, rowid) VALUES ('delete', ?)");
+		const deleteMemo = this.db.prepare("DELETE FROM memos WHERE id = ?");
+		this.db.exec("BEGIN TRANSACTION");
+		try {
+			deleteFts.run(row.rowid);
+			deleteMemo.run(id);
+			this.db.exec("COMMIT");
+			return true;
+		} catch {
+			this.db.exec("ROLLBACK");
+			throw new Error("Failed to delete memo");
+		}
+	}
+	/** Set the embedding engine. Call once after construction, before any writes. */
+	setEmbeddingEngine(engine) {
+		this.embeddingEngine = engine;
+	}
+	/** Check whether the store has any vector embeddings. */
+	hasEmbeddings() {
+		if (this.db === void 0) return false;
+		return (this.db.prepare("SELECT COUNT(*) as count FROM memory_embeddings").get()?.count ?? 0) > 0;
+	}
+	/** Access the embedding engine (may be undefined if not configured). */
+	getEmbeddingEngine() {
+		return this.embeddingEngine;
+	}
+	/**
+	* Search memos by vector similarity. Returns memos sorted by cosine
+	* similarity (highest first). Falls back to empty if no embeddings exist.
+	*
+	* NOTE: candidates are ordered by created_at DESC, so only the newest
+	* N embeddings are considered. Older but highly relevant memos may be
+	* omitted when the store has more than candidateLimit embeddings.
+	* This is a known limitation — see M-M5 in project review notes.
+	* Performance notes:
+	* - candidateLimit bounds the SQL query so we never load every embedding.
+	* - recencyCutoffDays lets callers ignore very old memos.
+	* - projectDir is pushed into the SQL JOIN so unrelated projects are not
+	*   considered at all.
+	*/
+	async searchByVector(queryEmbedding, options) {
+		await this.init();
+		if (this.db === void 0) return [];
+		const limit = options?.candidateLimit ?? 200;
+		const projectDir = options?.projectDir;
+		const recencyCutoffDays = options?.recencyCutoffDays;
+		const cutoffMs = recencyCutoffDays !== void 0 && recencyCutoffDays > 0 ? Date.now() - recencyCutoffDays * 24 * 60 * 60 * 1e3 : void 0;
+		let rows;
+		if (projectDir !== void 0) {
+			const stmt = cutoffMs === void 0 ? this.db.prepare(`
+              SELECT e.memory_id, e.embedding_json
+              FROM memory_embeddings e
+              JOIN memos m ON m.id = e.memory_id
+              WHERE (m.project_dir = ? OR m.project_dir = '')
+              ORDER BY e.created_at DESC
+              LIMIT ?
+            `) : this.db.prepare(`
+              SELECT e.memory_id, e.embedding_json
+              FROM memory_embeddings e
+              JOIN memos m ON m.id = e.memory_id
+              WHERE (m.project_dir = ? OR m.project_dir = '')
+                AND e.created_at > ?
+              ORDER BY e.created_at DESC
+              LIMIT ?
+            `);
+			rows = cutoffMs === void 0 ? stmt.all(projectDir, limit) : stmt.all(projectDir, cutoffMs, limit);
+		} else {
+			const stmt = cutoffMs === void 0 ? this.db.prepare("SELECT memory_id, embedding_json FROM memory_embeddings ORDER BY created_at DESC LIMIT ?") : this.db.prepare("SELECT memory_id, embedding_json FROM memory_embeddings WHERE created_at > ? ORDER BY created_at DESC LIMIT ?");
+			rows = cutoffMs === void 0 ? stmt.all(limit) : stmt.all(cutoffMs, limit);
+		}
+		if (rows.length === 0) return [];
+		const scored = [];
+		for (const row of rows) try {
+			const vec = new Float32Array(JSON.parse(row.embedding_json));
+			const similarity = this.embeddingEngine?.cosineSimilarity(queryEmbedding, vec) ?? 0;
+			if (similarity > 0) scored.push({
+				id: row.memory_id,
+				score: similarity
+			});
+		} catch {}
+		scored.sort((a, b) => b.score - a.score);
+		const topScored = scored.slice(0, limit);
+		const results = [];
+		for (const { id, score } of topScored) {
+			const row = this.db.prepare("SELECT * FROM memos WHERE id = ?").get(id);
+			if (row !== void 0) results.push({
+				memo: rowToMemo(row),
+				score
+			});
+		}
+		return results;
+	}
+	/**
+	* Schedule async embedding generation for a memo. Debounced — the actual
+	* batch flush runs after a short quiet period. Never blocks the caller.
+	*/
+	scheduleEmbedding(memo) {
+		this.embeddingQueue.add(memo.id);
+		if (this.embeddingEngine === void 0) return;
+		if (!this.embeddingEngine.available) {
+			this.embeddingEngine.ensureReady().then((ready) => {
+				if (ready && this.embeddingQueue.size > 0 && this.embeddingTimer === void 0) this.embeddingTimer = setTimeout(() => {
+					this.flushEmbeddings();
+				}, 2e3);
+			}).catch(() => {});
+			return;
+		}
+		if (this.embeddingTimer !== void 0) clearTimeout(this.embeddingTimer);
+		this.embeddingTimer = setTimeout(() => {
+			this.flushEmbeddings();
+		}, 2e3);
+	}
+	/**
+	* Flush queued embedding generation. Retries once on failure to tolerate
+	* transient model-load contention, then marks embeddings as degraded and
+	* logs the problem. Callers can still retrieve memos through keyword search.
+	*/
+	async flushEmbeddings() {
+		if (this.embeddingFlushing || this.embeddingEngine === void 0 || !this.embeddingEngine.available) return;
+		this.embeddingFlushing = true;
+		const ids = [...this.embeddingQueue];
+		this.embeddingQueue.clear();
+		const reenqueue = () => {
+			for (const id of ids) this.embeddingQueue.add(id);
+		};
+		try {
+			await this.init();
+			if (this.db === void 0) return;
+			const pending = [];
+			for (const id of ids) {
+				if (this.db.prepare("SELECT id FROM memory_embeddings WHERE memory_id = ?").get(id) !== void 0) continue;
+				const memo = await this.get(id);
+				if (memo !== void 0) pending.push({
+					id,
+					text: buildEmbeddingText(memo)
+				});
+			}
+			if (pending.length === 0) return;
+			const vectors = await this.tryEmbedBatch(pending.map((p) => p.text));
+			if (vectors === null || vectors.length !== pending.length) {
+				this.markEmbeddingFailure(/* @__PURE__ */ new Error(vectors === null ? "embedBatch returned null" : "embedding count mismatch"));
+				reenqueue();
+				return;
+			}
+			this.clearEmbeddingFailure();
+			const insert = this.db.prepare("INSERT OR REPLACE INTO memory_embeddings (memory_id, embedding_json, model, created_at) VALUES (?, ?, ?, ?)");
+			const now = Date.now();
+			this.db.exec("BEGIN TRANSACTION");
+			try {
+				for (let i = 0; i < pending.length; i++) insert.run(pending[i].id, JSON.stringify([...vectors[i]]), EMBEDDING_MODEL_NAME, now);
+				this.db.exec("COMMIT");
+			} catch (error) {
+				this.db.exec("ROLLBACK");
+				this.markEmbeddingFailure(error instanceof Error ? error : new Error(String(error)));
+				reenqueue();
+			}
+		} catch (error) {
+			this.markEmbeddingFailure(error instanceof Error ? error : new Error(String(error)));
+			reenqueue();
+		} finally {
+			this.embeddingFlushing = false;
+			this.embeddingTimer = void 0;
+		}
+	}
+	async tryEmbedBatch(texts) {
+		if (this.embeddingEngine === void 0) return null;
+		try {
+			const first = await this.embeddingEngine.embedBatch(texts);
+			if (first !== null) return first;
+		} catch {}
+		try {
+			return await this.embeddingEngine.embedBatch(texts);
+		} catch {
+			return null;
+		}
+	}
+	markEmbeddingFailure(error) {
+		this.embeddingDegraded = true;
+		this.embeddingConsecutiveFailures += 1;
+		this.lastEmbeddingError = error;
+		this.log.warn?.("embedding flush failed", {
+			error: error.message,
+			consecutiveFailures: this.embeddingConsecutiveFailures
+		});
+	}
+	clearEmbeddingFailure() {
+		this.embeddingDegraded = false;
+		this.embeddingConsecutiveFailures = 0;
+		this.lastEmbeddingError = void 0;
+	}
+	/**
+	* Runtime health of the embedding subsystem. When `degraded` is true, the
+	* store still serves keyword search; only vector similarity is unavailable.
+	*/
+	embeddingStatus() {
+		return {
+			available: this.embeddingEngine !== void 0 && this.embeddingEngine.available,
+			degraded: this.embeddingDegraded,
+			consecutiveFailures: this.embeddingConsecutiveFailures,
+			lastError: this.lastEmbeddingError?.message
+		};
+	}
+	listAll(limit, offset, projectDir) {
+		if (this.db === void 0) return {
+			rows: [],
+			total: 0
+		};
+		const countStmt = projectDir === void 0 ? this.db.prepare("SELECT COUNT(*) as total FROM memos") : this.db.prepare("SELECT COUNT(*) as total FROM memos WHERE project_dir = ? OR project_dir = ''");
+		const total = (projectDir === void 0 ? countStmt.get() : countStmt.get(projectDir))?.total ?? 0;
+		const stmt = projectDir === void 0 ? this.db.prepare("SELECT * FROM memos ORDER BY recorded_at DESC LIMIT ? OFFSET ?") : this.db.prepare("SELECT * FROM memos WHERE project_dir = ? OR project_dir = '' ORDER BY recorded_at DESC LIMIT ? OFFSET ?");
+		return {
+			rows: (projectDir === void 0 ? stmt.all(limit, offset) : stmt.all(projectDir, limit, offset)).map(rowToMemo),
+			total
+		};
+	}
+	async ensureDir() {
+		await mkdir(dirname$1(this.dbPath), { recursive: true });
+	}
+	async withWriteLock(fn) {
+		const next = this.writeLock.then(fn, fn);
+		this.writeLock = next;
+		return next;
+	}
+};
+function rowToMemo(row) {
+	const sourceSessionTitle = row["source_session_title"];
+	const projectDir = row["project_dir"];
+	return {
+		id: String(row["id"]),
+		sourceSessionId: String(row["source_session_id"]),
+		sourceSessionTitle: typeof sourceSessionTitle === "string" ? sourceSessionTitle : void 0,
+		userNeed: String(row["user_need"]),
+		approach: String(row["approach"]),
+		outcome: String(row["outcome"]),
+		whatFailed: String(row["what_failed"]),
+		whatWorked: String(row["what_worked"]),
+		extractionSource: row["extraction_source"],
+		recordedAt: Number(row["recorded_at"]),
+		projectDir: typeof projectDir === "string" ? projectDir : "",
+		tags: parseTags(row["tags"])
+	};
+}
+function parseTags(value) {
+	if (typeof value !== "string" || value.length === 0) return void 0;
+	try {
+		const parsed = JSON.parse(value);
+		if (!Array.isArray(parsed)) return void 0;
+		const tags = parsed.filter((t) => typeof t === "string");
+		return tags.length > 0 ? tags : void 0;
+	} catch {
+		return;
+	}
+}
+function memoMatchesSearch(memo, search) {
+	return [
+		memo.userNeed,
+		memo.approach,
+		memo.whatFailed,
+		memo.whatWorked,
+		memo.sourceSessionTitle ?? "",
+		...memo.tags ?? []
+	].join(" ").toLowerCase().replaceAll(/\s+/g, "").includes(search.replaceAll(/\s+/g, ""));
+}
+/**
+* Tokenize text so FTS5's unicode61 tokenizer can index mixed CJK/ASCII text.
+* CJK characters are split into individual characters separated by spaces, and
+* CJK/ASCII boundaries are also separated so "使用redis缓存" becomes searchable
+* by "redis" as well as by individual CJK characters.
+*/
+function toFtsText$1(text) {
+	const parts = text.toLowerCase().replaceAll(/([一-鿿㐀-䶿])([a-z0-9])/g, "$1 $2").replaceAll(/([a-z0-9])([一-鿿㐀-䶿])/g, "$1 $2").split(/[^a-z0-9一-鿿㐀-䶿]+/);
+	const tokens = [];
+	for (const part of parts) {
+		if (part.length === 0) continue;
+		if (/^[a-z0-9]+$/.test(part)) tokens.push(part);
+		else for (const ch of part) if (ch.length > 0) tokens.push(ch);
+	}
+	return tokens.join(" ");
+}
+function buildFtsQuery$1(search) {
+	const tokens = toFtsText$1(search).split(/\s+/).filter((t) => t.length > 0);
+	if (tokens.length === 0) return void 0;
+	return tokens.map((t) => `"${t.replaceAll("\"", "\"\"")}"`).join(" AND ");
+}
+//#endregion
+//#region ../../packages/memory/src/extractor.ts
+/**
+* Parse memory-memo blocks from LLM compaction output.
+*/
+function parseMemoryMemos(text) {
+	const memos = [];
+	const regex = /```memory-memo[\s\S]*?\n([\s\S]*?)```/g;
+	let match;
+	while ((match = regex.exec(text)) !== null) {
+		const jsonStr = match[1]?.trim();
+		if (!jsonStr) continue;
+		try {
+			const parsed = JSON.parse(jsonStr);
+			if (parsed["none"] === true) continue;
+			const userNeed = typeof parsed["userNeed"] === "string" ? parsed["userNeed"].trim() : "";
+			if (userNeed.length === 0) continue;
+			const rawTags = parsed["tags"];
+			const tags = Array.isArray(rawTags) ? normalizeTags(rawTags) : void 0;
+			const note = typeof parsed["note"] === "string" ? parsed["note"].trim() : void 0;
+			memos.push(createMemoryMemo({
+				userNeed,
+				approach: typeof parsed["approach"] === "string" ? parsed["approach"].trim() : "",
+				outcome: typeof parsed["outcome"] === "string" ? parsed["outcome"].trim() : "",
+				whatFailed: typeof parsed["whatFailed"] === "string" ? parsed["whatFailed"].trim() : "none",
+				whatWorked: typeof parsed["whatWorked"] === "string" ? parsed["whatWorked"].trim() : "none",
+				tags,
+				note: note && note.length > 0 ? note : void 0,
+				extractionSource: "compaction",
+				sourceSessionId: "",
+				sourceSessionTitle: ""
+			}));
+		} catch {}
+	}
+	return memos;
+}
+/**
+* Strip injected memory-memo content from text before writing it back to the
+* store, preventing feedback loops where recalled/compacted content gets
+* re-stored. Removes fenced ```memory-memo blocks (the format emitted by
+* compaction and exit-time extraction) and any <memories>...</memories>
+* wrapper an injector might use.
+*/
+function stripMemoryTags(text) {
+	return text.replaceAll(/```memory-memo[\s\S]*?```/gi, "").replaceAll(/<memories>[\s\S]*?<\/memories>/gi, "").trim();
+}
+/** System prompt for exit-time extraction — instructs the LLM how to extract. */
+const EXIT_EXTRACTION_SYSTEM_PROMPT = "你是一个任务经验提取助手。任务是从对话记录中识别已完成的任务闭环，提炼出任务经验记录。用对话的主要语言输出（中文对话用中文，英文对话用英文）。只输出指定的 JSON 格式，不要调用任何工具。";
+/** Build the user prompt for exit-time extraction, including a conversation sample. */
+function buildExitExtractionPrompt(sessionId, messageCount, sampleText) {
+	return `以下是会话 "${sessionId}"（共 ${messageCount} 条消息）的对话记录。请提取其中所有**已完成的任务闭环**：
+
+判断标准：
+- 用户提出了明确的需求或问题
+- 给出了解决方案或回答
+- 结果明确（成功、部分完成、失败）
+
+对每个已完成的任务闭环，输出一个结构化经验记录。**必须用对话的主要语言书写**：
+
+\`\`\`memory-memo
+{
+  "userNeed": "<用户需求/目标，一句话概括>",
+  "approach": "<执行方案，做了什么，2-4 句话>",
+  "outcome": "<最终结果，如'完成'、'部分完成'、'失败：原因'>",
+  "whatFailed": "<踩坑记录：试了但不行的路，无则填 'none'>",
+  "whatWorked": "<成功经验：最终奏效的关键动作，无则填 'none'>",
+  "tags": ["<标签1>", "<标签2>", "<标签3>"],
+  "note": "<可选：给 AI 的补充说明/建议——让未来理解这条经验更容易，如'这类任务先查接口可用性再写代码'。无则省略>"
+}
+\`\`\`
+
+注意：
+- tags 是 3-5 个语义标签，概括任务领域/技术栈/动作类型，例如 ["react", "auth", "部署"]
+- whatFailed 记录重要的错误尝试，帮助未来避免重蹈覆辙
+- whatWorked 记录最终成功的关键动作，帮助未来复用经验
+- note 是可选字段，写一句能让未来 AI 更快理解/复用这条经验的说明或建议（软性提示，非强制规则）
+- 跳过未完成的工作，除非其中包含有价值的踩坑经验
+- 将紧密相关的子任务合并为一条记录
+- 严格遵守字段名和 JSON 格式（除 note 外不要添加额外字段）
+
+如果没有已完成的任务闭环，输出：
+\`\`\`memory-memo
+{"none": true}
+\`\`\`
+
+--- 对话记录（最近 30 条消息）---
+
+${sampleText}
+
+--- 对话记录结束 ---`;
+}
+//#endregion
+//#region ../../packages/memory/src/consolidator.ts
+const SIMILARITY_THRESHOLD = .45;
+const STALE_DAYS = 30;
+/**
+* Analyze all memos and produce a consolidation plan.
+*
+* Pure logic — no LLM call. Uses keyword similarity to find near-duplicate
+* memos, flags resolved/stale entries.
+*/
+async function buildConsolidationPlan(store, options) {
+	const allMemos = [];
+	for await (const memo of store.read(options)) allMemos.push(memo);
+	const summaries = allMemos.map(toSummary);
+	const duplicateGroups = findDuplicateGroups(summaries);
+	const relatedGroups = findRelatedGroups(summaries, duplicateGroups);
+	const resolved = findResolved(summaries);
+	const stale = findStale(summaries, STALE_DAYS);
+	const dedupedCount = duplicateGroups.reduce((acc, g) => acc + g.memos.length - 1, 0);
+	return {
+		duplicateGroups,
+		relatedGroups,
+		resolved,
+		stale,
+		summary: {
+			totalMemos: allMemos.length,
+			duplicatesFound: dedupedCount,
+			relatedGroupsFound: relatedGroups.length,
+			resolvedFound: resolved.length,
+			staleFound: stale.length,
+			memosAfterConsolidation: allMemos.length - dedupedCount - resolved.length - stale.length
+		}
+	};
+}
+/**
+* Apply a consolidation plan: delete duplicates, resolved, and stale memos,
+* appending merged replacements for duplicates.
+*/
+async function applyConsolidation(store, plan) {
+	let deleted = 0;
+	let created = 0;
+	if (plan.resolved.length > 0) {
+		const worked = plan.resolved.filter((m) => m.whatWorked).map((m) => m.whatWorked).join("; ");
+		const failed = plan.resolved.filter((m) => m.whatFailed).map((m) => m.whatFailed).join("; ");
+		if (worked || failed) {
+			const archive = createMemoryMemo({
+				sourceSessionId: plan.resolved[0].sourceSessionId,
+				userNeed: "已解决任务的经验归档（dream 整理）",
+				approach: "多次尝试后解决",
+				outcome: "已完成",
+				whatWorked: worked || "none",
+				whatFailed: failed || "none",
+				tags: normalizeTags(plan.resolved.flatMap((m) => m.tags ?? [])),
+				projectDir: plan.resolved[0].projectDir,
+				extractionSource: "compaction"
+			});
+			await store.append(archive);
+			created++;
+		}
+	}
+	if (plan.stale.length > 0) {
+		const worked = plan.stale.filter((m) => m.whatWorked).map((m) => m.whatWorked).join("; ");
+		const failed = plan.stale.filter((m) => m.whatFailed).map((m) => m.whatFailed).join("; ");
+		if (worked || failed) {
+			const archive = createMemoryMemo({
+				sourceSessionId: plan.stale[0].sourceSessionId,
+				userNeed: "过期记忆的经验归档（dream 整理）",
+				approach: "距今超过30天未使用",
+				outcome: "已归档",
+				whatWorked: worked || "none",
+				whatFailed: failed || "none",
+				tags: normalizeTags(plan.stale.flatMap((m) => m.tags ?? [])),
+				projectDir: plan.stale[0].projectDir,
+				extractionSource: "compaction"
+			});
+			await store.append(archive);
+			created++;
+		}
+	}
+	for (const group of plan.duplicateGroups) {
+		const newest = group.memos.reduce((a, b) => a.recordedAt > b.recordedAt ? a : b);
+		const mergedTags = normalizeTags(group.memos.flatMap((m) => m.tags ?? []));
+		const merged = createMemoryMemo({
+			sourceSessionId: newest.sourceSessionId,
+			sourceSessionTitle: newest.sourceSessionTitle,
+			userNeed: group.merged.userNeed,
+			approach: group.merged.approach,
+			outcome: group.merged.outcome,
+			whatFailed: group.merged.whatFailed,
+			whatWorked: group.merged.whatWorked,
+			tags: group.merged.tags ?? mergedTags,
+			projectDir: newest.projectDir,
+			extractionSource: "compaction"
+		});
+		await store.append(merged);
+		created++;
+	}
+	for (const group of plan.duplicateGroups) for (const memo of group.memos) {
+		await store.delete(memo.id);
+		deleted++;
+	}
+	for (const memo of plan.resolved) {
+		await store.delete(memo.id);
+		deleted++;
+	}
+	for (const memo of plan.stale) {
+		await store.delete(memo.id);
+		deleted++;
+	}
+	return {
+		deleted,
+		created
+	};
+}
+function findDuplicateGroups(memos) {
+	const groups = [];
+	const used = /* @__PURE__ */ new Set();
+	for (let i = 0; i < memos.length; i++) {
+		const first = memos[i];
+		if (!first || used.has(first.id)) continue;
+		const cluster = [first];
+		for (let j = i + 1; j < memos.length; j++) {
+			const candidate = memos[j];
+			if (!candidate || used.has(candidate.id)) continue;
+			if (cluster.some((m) => {
+				return computeKeywordSimilarity(candidate, `${m.userNeed} ${m.approach}`) >= SIMILARITY_THRESHOLD;
+			})) cluster.push(candidate);
+		}
+		if (cluster.length > 1) {
+			for (const m of cluster) used.add(m.id);
+			groups.push(buildDuplicateGroup(cluster));
+		}
+	}
+	return groups;
+}
+/**
+* Split a whatFailed / whatWorked field into individual claims.
+* Handles both `;` and `；` separators.
+*/
+function splitClaims(text) {
+	if (!text || text === "none" || text === "无") return [];
+	return text.split(/[;；]/).map((s) => s.trim()).filter((s) => s.length > 0);
+}
+/**
+* Extract significant words for contradiction detection:
+* ASCII words >= 3 chars + CJK 2-grams.
+*/
+function extractSignificantWords(text) {
+	const words = [];
+	const lower = text.toLowerCase();
+	for (const m of lower.matchAll(/[a-z0-9]+/g)) if (m[0].length >= 3) words.push(m[0]);
+	for (const m of lower.matchAll(/[一-鿿]+/g)) {
+		const run = m[0];
+		for (let i = 0; i < run.length - 1; i++) words.push(run.slice(i, i + 2));
+	}
+	return words;
+}
+/**
+* Check whether `claim` overlaps with any claim in `against`.
+* 2+ shared significant words = overlap; 1 word is enough for single-word claims.
+*/
+function claimsOverlap(claim, against) {
+	const words = extractSignificantWords(claim);
+	if (words.length === 0) return false;
+	for (const other of against) {
+		const otherLower = other.toLowerCase();
+		const matched = words.filter((w) => otherLower.includes(w)).length;
+		if (matched >= 2 || matched >= 1 && words.length === 1) return true;
+	}
+	return false;
+}
+function buildDuplicateGroup(cluster) {
+	const sorted = [...cluster].toSorted((a, b) => b.recordedAt - a.recordedAt);
+	const newest = sorted[0];
+	const mid = Math.ceil(sorted.length / 2);
+	const newer = sorted.slice(0, mid);
+	const newerFailedClaims = new Set(newer.flatMap((m) => splitClaims(m.whatFailed)));
+	const newerWorkedClaims = new Set(newer.flatMap((m) => splitClaims(m.whatWorked)));
+	const failures = /* @__PURE__ */ new Set();
+	const successes = /* @__PURE__ */ new Set();
+	for (const memo of cluster) {
+		for (const claim of splitClaims(memo.whatFailed)) if (!claimsOverlap(claim, newerWorkedClaims)) failures.add(claim);
+		for (const claim of splitClaims(memo.whatWorked)) if (!claimsOverlap(claim, newerFailedClaims)) successes.add(claim);
+	}
+	const bestOutcome = cluster.map((m) => m.outcome).some((o) => o.includes("完成") || o.toLowerCase().includes("done")) ? "完成" : newest.outcome;
+	return {
+		memos: cluster,
+		merged: {
+			userNeed: newest.userNeed,
+			approach: `合并 ${cluster.length} 条相关记录。最新方案: ${newest.approach}`,
+			outcome: bestOutcome,
+			whatFailed: failures.size > 0 ? [...failures].join("; ") : "none",
+			whatWorked: successes.size > 0 ? [...successes].join("; ") : "none"
+		},
+		reason: `发现 ${cluster.length} 条相似记录（关键词重叠 > ${Math.round(SIMILARITY_THRESHOLD * 100)}%）`
+	};
+}
+/**
+* Extract topic anchors from memo text.
+*
+* Compound identifiers like `sample-project` are strong signals and kept whole.
+* ASCII words >= 3 chars are kept when not stopwords. CJK runs are tokenized
+* into 2-grams so that pure-Chinese themes like "用户认证" can still form
+* groups without relying on noisy single-character Jaccard overlap.
+*/
+function extractTopicAnchors(text) {
+	const lower = text.toLowerCase();
+	const anchors = /* @__PURE__ */ new Set();
+	for (const match of lower.matchAll(/[a-z0-9]+[-_][a-z0-9]+(?:[-_][a-z0-9]+)*/g)) {
+		const token = match[0];
+		if (token.length >= 5) anchors.add(token);
+	}
+	for (const match of lower.matchAll(/[a-z0-9]+/g)) {
+		const token = match[0];
+		if (token.length >= 3 && !STOP_WORDS.has(token)) anchors.add(token);
+	}
+	for (const match of lower.matchAll(/[一-鿿㐀-䶿]+/g)) {
+		const run = match[0];
+		for (let i = 0; i < run.length - 1; i++) anchors.add(run.slice(i, i + 2));
+	}
+	return [...anchors];
+}
+function findRelatedGroups(memos, duplicateGroups) {
+	const used = /* @__PURE__ */ new Set();
+	for (const group of duplicateGroups) for (const memo of group.memos) used.add(memo.id);
+	const available = memos.filter((m) => !used.has(m.id));
+	const anchorIndex = /* @__PURE__ */ new Map();
+	for (const memo of available) {
+		const anchors = extractTopicAnchors(`${memo.userNeed} ${memo.approach} ${memo.whatFailed} ${memo.whatWorked}`);
+		for (const anchor of anchors) {
+			const list = anchorIndex.get(anchor) ?? [];
+			if (!list.some((m) => m.id === memo.id)) list.push(memo);
+			anchorIndex.set(anchor, list);
+		}
+	}
+	const groups = [];
+	const assigned = /* @__PURE__ */ new Set();
+	const sortedAnchors = [...anchorIndex.entries()].filter(([, list]) => list.length >= 2).toSorted((a, b) => b[1].length - a[1].length);
+	for (const [anchor, candidates] of sortedAnchors) {
+		const groupMemos = candidates.filter((m) => !assigned.has(m.id));
+		if (groupMemos.length >= 2) {
+			groups.push({
+				memos: groupMemos,
+				topic: anchor,
+				reason: `发现 ${groupMemos.length} 条围绕 ${anchor} 的记录`
+			});
+			for (const m of groupMemos) assigned.add(m.id);
+		}
+	}
+	return groups;
+}
+function isOutcomeCompleted(outcome) {
+	const lower = outcome.toLowerCase();
+	return lower.includes("完成") || lower.includes("done") || lower.includes("completed") || lower.includes("成功") || lower.includes("success");
+}
+function findResolved(memos) {
+	return memos.filter((m) => isOutcomeCompleted(m.outcome) && Date.now() - m.recordedAt > 10080 * 60 * 1e3);
+}
+function findStale(memos, staleDays) {
+	const threshold = Date.now() - staleDays * 24 * 60 * 60 * 1e3;
+	return memos.filter((m) => m.recordedAt < threshold && !isOutcomeCompleted(m.outcome) && !m.outcome.includes("blocked"));
+}
+//#endregion
+//#region ../../packages/memory/src/dream.ts
+const LOCK_FILE = "dream-lock.json";
+const MIN_HOURS_BETWEEN_DREAMS = 24;
+const MIN_SESSIONS_BETWEEN_DREAMS = 5;
+let atomicWriteSequence = 0;
+/**
+* Write `data` to `path` through a temp file + rename, so a crash mid-write
+* leaves the previous state on disk instead of a truncated file. The temp file
+* sits next to the target, which keeps the rename inside one filesystem.
+*
+* The swap replaces the target inode rather than writing through it: a
+* rewritten file's permissions follow the process umask, and a symlink at the
+* target is replaced by a regular file. That is the same trade-off every other
+* state-file swap in this repository makes.
+*
+* Implemented here rather than imported because this package declares `pathe`
+* as its only dependency: the atomic-write helpers in `@scream-code/jian` and
+* `@scream-code/agent-core` are not reachable from it, and pulling either
+* package in for ten lines would widen the dependency graph.
+*/
+async function writeFileAtomic(path, data) {
+	const tmpPath = `${path}.${process.pid.toString(36)}.${(atomicWriteSequence++).toString(36)}.tmp`;
+	try {
+		await writeFile(tmpPath, data, "utf8");
+		await rename(tmpPath, path);
+	} catch (error) {
+		await unlink(tmpPath).catch(() => {});
+		throw error;
+	}
+}
+/**
+* Tracks dream consolidation state and decides when to suggest running
+* another dream. Persisted to `<screamHomeDir>/dream-lock.json`.
+*/
+var DreamTracker = class {
+	state;
+	lockPath;
+	screamHomeDir;
+	initialized = false;
+	constructor(screamHomeDir) {
+		this.screamHomeDir = screamHomeDir;
+		this.lockPath = join$1(screamHomeDir, LOCK_FILE);
+		this.state = {
+			lastDreamAt: (/* @__PURE__ */ new Date()).toISOString(),
+			sessionsSinceLastDream: 0
+		};
+	}
+	/** Load persisted state (call once at startup). */
+	async init() {
+		if (this.initialized) return;
+		this.initialized = true;
+		try {
+			const raw = await readFile(this.lockPath, "utf8");
+			const parsed = JSON.parse(raw);
+			if (parsed.version === 1 && parsed.state) {
+				this.state = parsed.state;
+				return;
+			}
+		} catch {}
+		await this.migrateLegacyLockFiles();
+	}
+	/** Record that a dream completed successfully. */
+	async recordDream() {
+		this.state = {
+			lastDreamAt: (/* @__PURE__ */ new Date()).toISOString(),
+			sessionsSinceLastDream: 0
+		};
+		await this.persist();
+	}
+	/** Call on each new session to bump the session counter. */
+	async recordNewSession() {
+		if (!this.initialized) await this.init();
+		this.state.sessionsSinceLastDream += 1;
+		await this.persist();
+	}
+	/** Check whether it's time to suggest another dream. */
+	shouldSuggest() {
+		return (Date.now() - new Date(this.state.lastDreamAt).getTime()) / (1e3 * 60 * 60) >= MIN_HOURS_BETWEEN_DREAMS && this.state.sessionsSinceLastDream >= MIN_SESSIONS_BETWEEN_DREAMS;
+	}
+	/** Get a human-readable suggestion message when conditions are met. */
+	getSuggestionMessage() {
+		const hoursSince = (Date.now() - new Date(this.state.lastDreamAt).getTime()) / (1e3 * 60 * 60);
+		return `距离上次记忆整理已过去 ${Math.floor(hoursSince / 24)} 天、${this.state.sessionsSinceLastDream} 个会话。建议运行 /dream 来合并重复记忆、清理过期条目、解决矛盾信息。`;
+	}
+	async persist() {
+		const data = {
+			version: 1,
+			state: this.state
+		};
+		try {
+			await mkdir(dirname$1(this.lockPath), { recursive: true });
+			await writeFileAtomic(this.lockPath, JSON.stringify(data, null, 2));
+		} catch {}
+	}
+	/**
+	* One-time migration for legacy dream-lock.json locations:
+	* - <screamHomeDir>/.scream-code/dream-lock.json (buggy double directory)
+	* - <screamHomeDir>/sessions/<sessionKey>/.scream-code/dream-lock.json (old per-session)
+	*
+	* Picks the most recent state, writes it to the new global location, and
+	* deletes the legacy files/directories.
+	*/
+	async migrateLegacyLockFiles() {
+		const candidates = [join$1(this.screamHomeDir, ".scream-code", LOCK_FILE)];
+		const sessionsDir = join$1(this.screamHomeDir, "sessions");
+		try {
+			const entries = await readdir(sessionsDir, { withFileTypes: true });
+			for (const entry of entries) if (entry.isDirectory()) candidates.push(join$1(sessionsDir, entry.name, ".scream-code", LOCK_FILE));
+		} catch {}
+		let bestState;
+		for (const candidate of candidates) try {
+			await stat(candidate);
+			const raw = await readFile(candidate, "utf8");
+			const parsed = JSON.parse(raw);
+			if (parsed.version === 1 && parsed.state) {
+				if (bestState === void 0 || new Date(parsed.state.lastDreamAt).getTime() > new Date(bestState.lastDreamAt).getTime()) bestState = parsed.state;
+			}
+		} catch {}
+		if (bestState !== void 0) {
+			this.state = bestState;
+			await this.persist();
+		}
+		for (const candidate of candidates) try {
+			await rm(candidate);
+			await rmdir(dirname$1(candidate)).catch(() => {});
+		} catch {}
+	}
+};
+//#endregion
+//#region ../../packages/knowledge/src/store.ts
+const ENTITY_TYPES$1 = new Set([
+	"person",
+	"organization",
+	"location",
+	"time",
+	"product",
+	"metric",
+	"action",
+	"work",
+	"group",
+	"subject",
+	"tags"
+]);
+function generateId(prefix) {
+	return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function normalizeName(name) {
+	return name.trim().toLowerCase().replaceAll(/\s+/g, " ");
+}
+/** Serialize a vector as a raw Float32 BLOB — half the text of JSON, no parse on scan. */
+function vectorToBlob(vec) {
+	if (vec === null) return null;
+	return Buffer.from(vec.buffer, vec.byteOffset, vec.byteLength);
+}
+/**
+* Decode a stored vector: Float32 BLOB, or legacy JSON text. Both formats are
+* accepted forever so a half-migrated (or not-yet-migrated) library stays
+* correct — the migration only shrinks storage, it is not a correctness gate.
+*/
+function blobToVector(value) {
+	if (value === null || value === void 0) return null;
+	if (typeof value === "string") try {
+		const arr = JSON.parse(value);
+		return new Float32Array(arr);
+	} catch {
+		return null;
+	}
+	if (!(value instanceof Uint8Array)) return null;
+	if (value.byteLength % 4 !== 0) return null;
+	const copy = value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
+	return new Float32Array(copy);
+}
+function isEntityType(value) {
+	return ENTITY_TYPES$1.has(value);
+}
+/** Meta key recording which embedding model the stored vectors came from. */
+const EMBEDDING_MODEL_META_KEY = "embedding_model";
+var KnowledgeStore = class {
+	dbPath;
+	db;
+	initialized = false;
+	initPromise = null;
+	embeddingEngine;
+	constructor(projectDir) {
+		this.dbPath = join$1(projectDir, "knowledge", "knowledge.db");
+	}
+	async init() {
+		if (this.initPromise) return this.initPromise;
+		this.initPromise = this._doInit().catch((error) => {
+			this.initPromise = null;
+			throw error;
+		});
+		return this.initPromise;
+	}
+	async _doInit() {
+		if (this.initialized) return;
+		await mkdir(dirname$1(this.dbPath), { recursive: true });
+		this.db = new DatabaseSync(this.dbPath);
+		this.db.exec("PRAGMA journal_mode = WAL;");
+		this.db.exec("PRAGMA foreign_keys = ON;");
+		this.db.exec("PRAGMA busy_timeout = 5000;");
+		this.createSchema();
+		this.migrateFtsTokenization();
+		this.migrateVectorsToBlob();
+		this.initialized = true;
+	}
+	/**
+	* One-time migration: FTS rows written before toFtsText pre-tokenization
+	* indexed raw text (CJK runs became single tokens and are unsearchable).
+	* Rebuild all three FTS tables from the content tables with toFtsText.
+	* Tracked via PRAGMA user_version so it runs exactly once.
+	*/
+	migrateFtsTokenization() {
+		if (this.db === void 0) return;
+		if (this.db.prepare("PRAGMA user_version").get().user_version >= 1) return;
+		this.db.exec("DELETE FROM knowledge_chunks_fts");
+		this.db.exec("DELETE FROM knowledge_events_fts");
+		this.db.exec("DELETE FROM knowledge_entities_fts");
+		const chunks = this.db.prepare("SELECT rowid, heading, content FROM knowledge_chunks").all();
+		const insChunk = this.db.prepare("INSERT INTO knowledge_chunks_fts (rowid, heading, content) VALUES (?, ?, ?)");
+		for (const c of chunks) insChunk.run(c.rowid, toFtsText(c.heading ?? ""), toFtsText(c.content));
+		const events = this.db.prepare("SELECT rowid, title, summary, content FROM knowledge_events").all();
+		const insEvent = this.db.prepare("INSERT INTO knowledge_events_fts (rowid, title, summary, content) VALUES (?, ?, ?, ?)");
+		for (const e of events) insEvent.run(e.rowid, toFtsText(e.title), toFtsText(e.summary ?? ""), toFtsText(e.content));
+		const entities = this.db.prepare("SELECT rowid, name, description FROM knowledge_entities").all();
+		const insEntity = this.db.prepare("INSERT INTO knowledge_entities_fts (rowid, name, description) VALUES (?, ?, ?)");
+		for (const e of entities) insEntity.run(e.rowid, toFtsText(e.name), toFtsText(e.description ?? ""));
+		this.db.exec("PRAGMA user_version = 1");
+	}
+	/**
+	* One-time migration (user_version 2): rewrite legacy JSON vector text to
+	* raw Float32 BLOBs. Reads accept both formats forever, so a half-migrated
+	* or failed run stays correct — this only shrinks storage and removes
+	* JSON.parse from the O(n) scan paths. typeof() = 'text' makes the pass
+	* idempotent: converted rows come back as 'blob' and are skipped.
+	*/
+	migrateVectorsToBlob() {
+		if (this.db === void 0) return;
+		if (this.db.prepare("PRAGMA user_version").get().user_version >= 2) return;
+		const columns = [
+			{
+				table: "knowledge_chunks",
+				column: "embedding_json"
+			},
+			{
+				table: "knowledge_events",
+				column: "title_embedding_json"
+			},
+			{
+				table: "knowledge_events",
+				column: "content_embedding_json"
+			},
+			{
+				table: "knowledge_entities",
+				column: "embedding_json"
+			},
+			{
+				table: "knowledge_event_entities",
+				column: "embedding_json"
+			}
+		];
+		this.db.exec("BEGIN");
+		try {
+			for (const { table, column } of columns) {
+				const rows = this.db.prepare(`SELECT id AS pk, ${column} AS v FROM ${table}
+             WHERE ${column} IS NOT NULL AND typeof(${column}) = 'text'`).all();
+				if (rows.length === 0) continue;
+				const update = this.db.prepare(`UPDATE ${table} SET ${column} = ? WHERE id = ?`);
+				for (const row of rows) {
+					const vec = blobToVector(row.v);
+					if (vec === null) continue;
+					update.run(vectorToBlob(vec), row.pk);
+				}
+			}
+			this.db.exec("PRAGMA user_version = 2");
+			this.db.exec("COMMIT");
+		} catch (error) {
+			this.db.exec("ROLLBACK");
+			throw error;
+		}
+	}
+	close() {
+		if (this.db !== void 0) {
+			this.db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+			this.db.close();
+			this.db = void 0;
+		}
+		this.initialized = false;
+		this.initPromise = null;
+	}
+	setEmbeddingEngine(engine) {
+		this.embeddingEngine = engine;
+	}
+	getEmbeddingEngine() {
+		return this.embeddingEngine;
+	}
+	/**
+	* Begin a write transaction. Use commitTransaction / rollbackTransaction
+	* to close it. Used by ingest to keep chunks/events/entities/edges atomic —
+	* a mid-ingest failure leaves no partial rows.
+	*/
+	beginTransaction() {
+		if (this.db === void 0) throw new Error("knowledge store not initialized");
+		this.db.exec("BEGIN");
+	}
+	commitTransaction() {
+		if (this.db === void 0) throw new Error("knowledge store not initialized");
+		this.db.exec("COMMIT");
+	}
+	rollbackTransaction() {
+		if (this.db === void 0) return;
+		try {
+			this.db.exec("ROLLBACK");
+		} catch {}
+	}
+	/**
+	* Read a metadata value (e.g. the embedding model identity the library was
+	* built with). Returns null when the key is absent.
+	*/
+	async getMeta(key) {
+		await this.init();
+		if (this.db === void 0) return null;
+		const row = this.db.prepare("SELECT value FROM knowledge_meta WHERE key = ?").get(key);
+		return row === void 0 ? null : asString(row["value"]);
+	}
+	/** Write a metadata value (upsert). */
+	async setMeta(key, value) {
+		await this.init();
+		if (this.db === void 0) throw new Error("knowledge store not initialized");
+		this.db.prepare("INSERT INTO knowledge_meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, value);
+	}
+	createSchema() {
+		if (this.db === void 0) return;
+		this.db.exec(`
+      CREATE TABLE IF NOT EXISTS knowledge_sources (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        file_path TEXT,
+        description TEXT,
+        created_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS knowledge_documents (
+        id TEXT PRIMARY KEY,
+        source_id TEXT NOT NULL REFERENCES knowledge_sources(id) ON DELETE CASCADE,
+        title TEXT NOT NULL,
+        content TEXT,
+        status TEXT NOT NULL DEFAULT 'pending',
+        chunk_count INTEGER DEFAULT 0,
+        created_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_knowledge_documents_source ON knowledge_documents(source_id);
+
+      CREATE TABLE IF NOT EXISTS knowledge_chunks (
+        id TEXT PRIMARY KEY,
+        source_id TEXT NOT NULL REFERENCES knowledge_sources(id) ON DELETE CASCADE,
+        document_id TEXT NOT NULL REFERENCES knowledge_documents(id) ON DELETE CASCADE,
+        rank INTEGER NOT NULL,
+        heading TEXT,
+        content TEXT NOT NULL,
+        raw_content TEXT,
+        embedding_json BLOB,
+        created_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_knowledge_chunks_doc ON knowledge_chunks(document_id);
+      CREATE INDEX IF NOT EXISTS idx_knowledge_chunks_source ON knowledge_chunks(source_id);
+
+      CREATE TABLE IF NOT EXISTS knowledge_events (
+        id TEXT PRIMARY KEY,
+        source_id TEXT NOT NULL REFERENCES knowledge_sources(id) ON DELETE CASCADE,
+        document_id TEXT NOT NULL REFERENCES knowledge_documents(id) ON DELETE CASCADE,
+        chunk_id TEXT NOT NULL REFERENCES knowledge_chunks(id) ON DELETE CASCADE,
+        rank INTEGER NOT NULL,
+        title TEXT NOT NULL,
+        summary TEXT,
+        content TEXT NOT NULL,
+        category TEXT,
+        keywords TEXT,
+        title_embedding_json BLOB,
+        content_embedding_json BLOB,
+        created_at INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_knowledge_events_chunk ON knowledge_events(chunk_id);
+      CREATE INDEX IF NOT EXISTS idx_knowledge_events_doc ON knowledge_events(document_id);
+      CREATE INDEX IF NOT EXISTS idx_knowledge_events_source ON knowledge_events(source_id);
+
+      CREATE TABLE IF NOT EXISTS knowledge_entities (
+        id TEXT PRIMARY KEY,
+        source_id TEXT NOT NULL REFERENCES knowledge_sources(id) ON DELETE CASCADE,
+        type TEXT NOT NULL,
+        name TEXT NOT NULL,
+        normalized_name TEXT NOT NULL,
+        description TEXT,
+        embedding_json BLOB,
+        created_at INTEGER NOT NULL,
+        UNIQUE(source_id, type, normalized_name)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_knowledge_entities_source ON knowledge_entities(source_id);
+      CREATE INDEX IF NOT EXISTS idx_knowledge_entities_name ON knowledge_entities(normalized_name);
+
+      CREATE TABLE IF NOT EXISTS knowledge_event_entities (
+        id TEXT PRIMARY KEY,
+        event_id TEXT NOT NULL REFERENCES knowledge_events(id) ON DELETE CASCADE,
+        entity_id TEXT NOT NULL REFERENCES knowledge_entities(id) ON DELETE CASCADE,
+        weight REAL DEFAULT 1.0,
+        description TEXT,
+        embedding_json BLOB,
+        UNIQUE(event_id, entity_id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_knowledge_event_entities_event ON knowledge_event_entities(event_id);
+      CREATE INDEX IF NOT EXISTS idx_knowledge_event_entities_entity ON knowledge_event_entities(entity_id);
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS knowledge_chunks_fts USING fts5(
+        heading, content, content='knowledge_chunks', content_rowid='rowid'
+      );
+      CREATE VIRTUAL TABLE IF NOT EXISTS knowledge_events_fts USING fts5(
+        title, summary, content, content='knowledge_events', content_rowid='rowid'
+      );
+      CREATE VIRTUAL TABLE IF NOT EXISTS knowledge_entities_fts USING fts5(
+        name, description, content='knowledge_entities', content_rowid='rowid'
+      );
+
+      CREATE TABLE IF NOT EXISTS knowledge_meta (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+    `);
+		try {
+			this.db.exec("ALTER TABLE knowledge_sources ADD COLUMN content_hash TEXT");
+		} catch (error) {
+			if (!(error instanceof Error ? error.message : String(error)).includes("duplicate column")) throw error;
+		}
+	}
+	async createSource(params) {
+		await this.init();
+		if (this.db === void 0) throw new Error("knowledge store not initialized");
+		const id = generateId("src");
+		const createdAt = Date.now();
+		this.db.prepare("INSERT INTO knowledge_sources (id, name, file_path, description, content_hash, created_at) VALUES (?, ?, ?, ?, ?, ?)").run(id, params.name, params.filePath ?? null, params.description ?? null, params.contentHash ?? null, createdAt);
+		return {
+			id,
+			name: params.name,
+			filePath: params.filePath ?? null,
+			description: params.description ?? null,
+			contentHash: params.contentHash ?? null,
+			createdAt
+		};
+	}
+	/** Backfill or refresh a source's content fingerprint (legacy rows / replacements). */
+	async updateSourceContentHash(id, contentHash) {
+		await this.init();
+		if (this.db === void 0) throw new Error("knowledge store not initialized");
+		this.db.prepare("UPDATE knowledge_sources SET content_hash = ? WHERE id = ?").run(contentHash, id);
+	}
+	async findSourceByFilePath(filePath) {
+		await this.init();
+		if (this.db === void 0) return void 0;
+		const row = this.db.prepare("SELECT * FROM knowledge_sources WHERE file_path = ?").get(filePath);
+		return row === void 0 ? void 0 : rowToSource(row);
+	}
+	async listSources() {
+		await this.init();
+		if (this.db === void 0) return [];
+		return this.db.prepare("SELECT * FROM knowledge_sources ORDER BY created_at DESC").all().map(rowToSource);
+	}
+	async getSource(id) {
+		await this.init();
+		if (this.db === void 0) return void 0;
+		const row = this.db.prepare("SELECT * FROM knowledge_sources WHERE id = ?").get(id);
+		return row === void 0 ? void 0 : rowToSource(row);
+	}
+	async deleteSource(id) {
+		await this.init();
+		if (this.db === void 0) return false;
+		const chunkRows = this.db.prepare("SELECT rowid, heading, content FROM knowledge_chunks WHERE source_id = ?").all(id);
+		const eventRows = this.db.prepare("SELECT rowid, title, summary, content FROM knowledge_events WHERE source_id = ?").all(id);
+		const entityRows = this.db.prepare("SELECT rowid, name, description FROM knowledge_entities WHERE source_id = ?").all(id);
+		const result = this.db.prepare("DELETE FROM knowledge_sources WHERE id = ?").run(id);
+		if (result.changes > 0) {
+			const delChunk = this.db.prepare("INSERT INTO knowledge_chunks_fts (knowledge_chunks_fts, rowid, heading, content) VALUES ('delete', ?, ?, ?)");
+			for (const row of chunkRows) delChunk.run(row.rowid, toFtsText(row.heading ?? ""), toFtsText(row.content));
+			const delEvent = this.db.prepare("INSERT INTO knowledge_events_fts (knowledge_events_fts, rowid, title, summary, content) VALUES ('delete', ?, ?, ?, ?)");
+			for (const row of eventRows) delEvent.run(row.rowid, toFtsText(row.title), toFtsText(row.summary ?? ""), toFtsText(row.content));
+			const delEntity = this.db.prepare("INSERT INTO knowledge_entities_fts (knowledge_entities_fts, rowid, name, description) VALUES ('delete', ?, ?, ?)");
+			for (const row of entityRows) delEntity.run(row.rowid, toFtsText(row.name), toFtsText(row.description ?? ""));
+		}
+		return result.changes > 0;
+	}
+	async createDocument(params) {
+		if (this.db === void 0) throw new Error("knowledge store not initialized");
+		const id = generateId("doc");
+		const createdAt = Date.now();
+		this.db.prepare("INSERT INTO knowledge_documents (id, source_id, title, content, status, chunk_count, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(id, params.sourceId, params.title, params.content ?? null, "pending", 0, createdAt);
+		return {
+			id,
+			sourceId: params.sourceId,
+			title: params.title,
+			content: params.content ?? null,
+			status: "pending",
+			chunkCount: 0,
+			createdAt
+		};
+	}
+	async updateDocumentStatus(documentId, status, chunkCount) {
+		if (this.db === void 0) return;
+		if (chunkCount !== void 0) this.db.prepare("UPDATE knowledge_documents SET status = ?, chunk_count = ? WHERE id = ?").run(status, chunkCount, documentId);
+		else this.db.prepare("UPDATE knowledge_documents SET status = ? WHERE id = ?").run(status, documentId);
+	}
+	async listDocuments() {
+		await this.init();
+		if (this.db === void 0) return [];
+		return this.db.prepare(`SELECT d.*, s.name AS source_name
+         FROM knowledge_documents d
+         JOIN knowledge_sources s ON s.id = d.source_id
+         ORDER BY d.created_at DESC`).all().map((row) => ({
+			...rowToDocument(row),
+			sourceName: String(row["source_name"])
+		}));
+	}
+	async getDocument(id) {
+		await this.init();
+		if (this.db === void 0) return void 0;
+		const row = this.db.prepare("SELECT * FROM knowledge_documents WHERE id = ?").get(id);
+		return row === void 0 ? void 0 : rowToDocument(row);
+	}
+	async insertChunk(params) {
+		if (this.db === void 0) throw new Error("knowledge store not initialized");
+		const id = generateId("chk");
+		const createdAt = Date.now();
+		const embeddingBlob = vectorToBlob(params.embedding);
+		this.db.prepare(`INSERT INTO knowledge_chunks
+         (id, source_id, document_id, rank, heading, content, raw_content, embedding_json, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, params.sourceId, params.documentId, params.rank, params.heading, params.content, params.rawContent, embeddingBlob, createdAt);
+		this.db.prepare(`INSERT INTO knowledge_chunks_fts (rowid, heading, content)
+         VALUES ((SELECT rowid FROM knowledge_chunks WHERE id = ?), ?, ?)`).run(id, toFtsText(params.heading ?? ""), toFtsText(params.content));
+		return {
+			id,
+			sourceId: params.sourceId,
+			documentId: params.documentId,
+			rank: params.rank,
+			heading: params.heading,
+			content: params.content,
+			rawContent: params.rawContent,
+			embedding: params.embedding,
+			createdAt
+		};
+	}
+	async getChunk(id) {
+		await this.init();
+		if (this.db === void 0) return void 0;
+		const row = this.db.prepare("SELECT * FROM knowledge_chunks WHERE id = ?").get(id);
+		return row === void 0 ? void 0 : rowToChunk(row);
+	}
+	async listChunksByDocument(documentId) {
+		await this.init();
+		if (this.db === void 0) return [];
+		return this.db.prepare("SELECT * FROM knowledge_chunks WHERE document_id = ? ORDER BY rank ASC").all(documentId).map(rowToChunk);
+	}
+	/** Load all chunk embeddings + ids for vector search. */
+	async loadAllChunkEmbeddings() {
+		await this.init();
+		if (this.db === void 0) return [];
+		const rows = this.db.prepare("SELECT id, embedding_json FROM knowledge_chunks WHERE embedding_json IS NOT NULL").all();
+		const out = [];
+		for (const row of rows) {
+			const vec = blobToVector(row.embedding_json);
+			if (vec !== null) out.push({
+				id: row.id,
+				embedding: vec
+			});
+		}
+		return out;
+	}
+	async insertEvent(params) {
+		if (this.db === void 0) throw new Error("knowledge store not initialized");
+		const id = generateId("evt");
+		const createdAt = Date.now();
+		this.db.prepare(`INSERT INTO knowledge_events
+         (id, source_id, document_id, chunk_id, rank, title, summary, content, category, keywords,
+          title_embedding_json, content_embedding_json, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, params.sourceId, params.documentId, params.chunkId, params.rank, params.title, params.summary, params.content, params.category, JSON.stringify(params.keywords), vectorToBlob(params.titleEmbedding), vectorToBlob(params.contentEmbedding), createdAt);
+		this.db.prepare(`INSERT INTO knowledge_events_fts (rowid, title, summary, content)
+         VALUES ((SELECT rowid FROM knowledge_events WHERE id = ?), ?, ?, ?)`).run(id, toFtsText(params.title), toFtsText(params.summary ?? ""), toFtsText(params.content));
+		return {
+			id,
+			sourceId: params.sourceId,
+			documentId: params.documentId,
+			chunkId: params.chunkId,
+			rank: params.rank,
+			title: params.title,
+			summary: params.summary,
+			content: params.content,
+			category: params.category,
+			keywords: params.keywords,
+			titleEmbedding: params.titleEmbedding,
+			contentEmbedding: params.contentEmbedding,
+			createdAt
+		};
+	}
+	async getEvent(id) {
+		await this.init();
+		if (this.db === void 0) return void 0;
+		const row = this.db.prepare("SELECT * FROM knowledge_events WHERE id = ?").get(id);
+		return row === void 0 ? void 0 : rowToEvent(row);
+	}
+	async listEventsByDocument(documentId) {
+		await this.init();
+		if (this.db === void 0) return [];
+		return this.db.prepare("SELECT * FROM knowledge_events WHERE document_id = ? ORDER BY rank ASC").all(documentId).map(rowToEvent);
+	}
+	/** Find events by title vector similarity. */
+	async findEventsByTitleVector(queryVec, options = {}) {
+		await this.init();
+		if (this.db === void 0) return [];
+		const limit = options.limit ?? 20;
+		const threshold = options.threshold ?? 0;
+		const rows = this.db.prepare("SELECT id, title_embedding_json FROM knowledge_events WHERE title_embedding_json IS NOT NULL").all();
+		const scored = [];
+		for (const row of rows) {
+			const vec = blobToVector(row.title_embedding_json);
+			if (vec === null) continue;
+			const score = this.embeddingEngine?.cosineSimilarity(queryVec, vec) ?? 0;
+			if (score >= threshold) scored.push({
+				id: row.id,
+				score
+			});
+		}
+		scored.sort((a, b) => b.score - a.score);
+		const top = scored.slice(0, limit);
+		const out = [];
+		for (const item of top) {
+			const event = await this.getEvent(item.id);
+			if (event !== void 0) out.push({
+				event,
+				score: item.score
+			});
+		}
+		return out;
+	}
+	async upsertEntity(params) {
+		if (this.db === void 0) throw new Error("knowledge store not initialized");
+		if (!isEntityType(params.type)) throw new Error(`invalid entity type: ${params.type}`);
+		const normalizedName = normalizeName(params.name);
+		const existing = this.db.prepare("SELECT * FROM knowledge_entities WHERE source_id = ? AND type = ? AND normalized_name = ?").get(params.sourceId, params.type, normalizedName);
+		if (existing !== void 0) {
+			const existingId = String(existing["id"]);
+			let descriptionChanged = false;
+			if (params.description !== null && existing["description"] === null) {
+				this.db.prepare("UPDATE knowledge_entities SET description = ? WHERE id = ?").run(params.description, existingId);
+				existing["description"] = params.description;
+				descriptionChanged = true;
+			}
+			if (params.embedding !== null && existing["embedding_json"] === null) {
+				this.db.prepare("UPDATE knowledge_entities SET embedding_json = ? WHERE id = ?").run(vectorToBlob(params.embedding), existingId);
+				existing["embedding_json"] = vectorToBlob(params.embedding);
+			}
+			if (descriptionChanged) {
+				const ftsRow = this.db.prepare("SELECT rowid, name, description FROM knowledge_entities WHERE id = ?").get(existingId);
+				if (ftsRow !== void 0) {
+					this.db.prepare("INSERT INTO knowledge_entities_fts (knowledge_entities_fts, rowid, name, description) VALUES ('delete', ?, ?, ?)").run(ftsRow.rowid, toFtsText(ftsRow.name), "");
+					this.db.prepare(`INSERT INTO knowledge_entities_fts (rowid, name, description) VALUES (?, ?, ?)`).run(ftsRow.rowid, toFtsText(ftsRow.name), toFtsText(ftsRow.description ?? ""));
+				}
+			}
+			return rowToEntity(existing);
+		}
+		const id = generateId("ent");
+		const createdAt = Date.now();
+		this.db.prepare(`INSERT INTO knowledge_entities
+         (id, source_id, type, name, normalized_name, description, embedding_json, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, params.sourceId, params.type, params.name, normalizedName, params.description, vectorToBlob(params.embedding), createdAt);
+		this.db.prepare(`INSERT INTO knowledge_entities_fts (rowid, name, description)
+         VALUES ((SELECT rowid FROM knowledge_entities WHERE id = ?), ?, ?)`).run(id, toFtsText(params.name), toFtsText(params.description ?? ""));
+		return {
+			id,
+			sourceId: params.sourceId,
+			type: params.type,
+			name: params.name,
+			normalizedName,
+			description: params.description,
+			embedding: params.embedding,
+			createdAt
+		};
+	}
+	async findEntitiesByName(name, sourceId) {
+		await this.init();
+		if (this.db === void 0) return [];
+		const normalized = normalizeName(name);
+		return (sourceId === void 0 ? this.db.prepare("SELECT * FROM knowledge_entities WHERE normalized_name = ?").all(normalized) : this.db.prepare("SELECT * FROM knowledge_entities WHERE normalized_name = ? AND source_id = ?").all(normalized, sourceId)).map(rowToEntity);
+	}
+	/** Find entities by name vector similarity. */
+	async findEntitiesByVector(queryVec, options = {}) {
+		await this.init();
+		if (this.db === void 0) return [];
+		const limit = options.limit ?? 20;
+		const threshold = options.threshold ?? 0;
+		const rows = this.db.prepare("SELECT id, embedding_json FROM knowledge_entities WHERE embedding_json IS NOT NULL").all();
+		const scored = [];
+		for (const row of rows) {
+			const vec = blobToVector(row.embedding_json);
+			if (vec === null) continue;
+			const score = this.embeddingEngine?.cosineSimilarity(queryVec, vec) ?? 0;
+			if (score >= threshold) scored.push({
+				id: row.id,
+				score
+			});
+		}
+		scored.sort((a, b) => b.score - a.score);
+		const top = scored.slice(0, limit);
+		const out = [];
+		for (const item of top) {
+			const row = this.db.prepare("SELECT * FROM knowledge_entities WHERE id = ?").get(item.id);
+			if (row !== void 0) out.push({
+				entity: rowToEntity(row),
+				score: item.score
+			});
+		}
+		return out;
+	}
+	async insertEventEntity(params) {
+		if (this.db === void 0) throw new Error("knowledge store not initialized");
+		const id = generateId("ee");
+		this.db.prepare(`INSERT OR IGNORE INTO knowledge_event_entities
+         (id, event_id, entity_id, weight, description, embedding_json)
+         VALUES (?, ?, ?, ?, ?, ?)`).run(id, params.eventId, params.entityId, params.weight ?? 1, params.description, vectorToBlob(params.embedding));
+		return {
+			id,
+			eventId: params.eventId,
+			entityId: params.entityId,
+			weight: params.weight ?? 1,
+			description: params.description,
+			embedding: params.embedding
+		};
+	}
+	async findEventsByEntity(entityId) {
+		await this.init();
+		if (this.db === void 0) return [];
+		return this.db.prepare(`SELECT e.* FROM knowledge_events e
+         JOIN knowledge_event_entities ee ON ee.event_id = e.id
+         WHERE ee.entity_id = ?`).all(entityId).map(rowToEvent);
+	}
+	async findEntitiesByEvent(eventId) {
+		await this.init();
+		if (this.db === void 0) return [];
+		return this.db.prepare(`SELECT en.* FROM knowledge_entities en
+         JOIN knowledge_event_entities ee ON ee.entity_id = en.id
+         WHERE ee.event_id = ?`).all(eventId).map(rowToEntity);
+	}
+	async listEntities(sourceId) {
+		await this.init();
+		if (this.db === void 0) return [];
+		const sql = sourceId ? `SELECT e.*, COUNT(ee.id) AS event_count
+         FROM knowledge_entities e
+         LEFT JOIN knowledge_event_entities ee ON ee.entity_id = e.id
+         WHERE e.source_id = ?
+         GROUP BY e.id
+         ORDER BY event_count DESC` : `SELECT e.*, COUNT(ee.id) AS event_count
+         FROM knowledge_entities e
+         LEFT JOIN knowledge_event_entities ee ON ee.entity_id = e.id
+         GROUP BY e.id
+         ORDER BY event_count DESC`;
+		return (sourceId ? this.db.prepare(sql).all(sourceId) : this.db.prepare(sql).all()).map((row) => ({
+			...rowToEntity(row),
+			eventCount: Number(row["event_count"] ?? 0)
+		}));
+	}
+	async listEvents(sourceId) {
+		await this.init();
+		if (this.db === void 0) return [];
+		const sql = sourceId ? "SELECT * FROM knowledge_events WHERE source_id = ? ORDER BY rank ASC" : "SELECT * FROM knowledge_events ORDER BY created_at DESC";
+		return (sourceId ? this.db.prepare(sql).all(sourceId) : this.db.prepare(sql).all()).map(rowToEvent);
+	}
+	async listEventEntities(sourceId) {
+		await this.init();
+		if (this.db === void 0) return [];
+		const sql = sourceId ? `SELECT ee.event_id, ee.entity_id
+         FROM knowledge_event_entities ee
+         JOIN knowledge_events e ON e.id = ee.event_id
+         WHERE e.source_id = ?` : "SELECT event_id, entity_id FROM knowledge_event_entities";
+		return (sourceId ? this.db.prepare(sql).all(sourceId) : this.db.prepare(sql).all()).map((row) => ({
+			eventId: asString(row["event_id"]),
+			entityId: asString(row["entity_id"])
+		}));
+	}
+	/** FTS hits ranked by bm25 relevance — score = -bm25 (larger is better). */
+	async ftsSearchChunks(query, limit = 50) {
+		await this.init();
+		if (this.db === void 0) return [];
+		const ftsQuery = buildFtsQuery(query);
+		if (ftsQuery === void 0) return [];
+		return this.db.prepare(`SELECT c.*, bm25(knowledge_chunks_fts) AS bm
+         FROM knowledge_chunks c
+         JOIN knowledge_chunks_fts f ON c.rowid = f.rowid
+         WHERE f.knowledge_chunks_fts MATCH ?
+         ORDER BY bm ASC
+         LIMIT ?`).all(ftsQuery, limit).map((row) => ({
+			chunk: rowToChunk(row),
+			score: -Number(row["bm"] ?? 0)
+		}));
+	}
+	async searchChunksByVector(queryVec, options = {}) {
+		await this.init();
+		if (this.db === void 0) return [];
+		const limit = options.limit ?? 50;
+		const threshold = options.threshold ?? 0;
+		const rows = this.db.prepare("SELECT id, embedding_json FROM knowledge_chunks WHERE embedding_json IS NOT NULL").all();
+		const scored = [];
+		for (const row of rows) {
+			const vec = blobToVector(row.embedding_json);
+			if (vec === null) continue;
+			const score = this.embeddingEngine?.cosineSimilarity(queryVec, vec) ?? 0;
+			if (score >= threshold) scored.push({
+				id: row.id,
+				score
+			});
+		}
+		scored.sort((a, b) => b.score - a.score);
+		const top = scored.slice(0, limit);
+		const out = [];
+		for (const item of top) {
+			const chunk = await this.getChunk(item.id);
+			if (chunk !== void 0) out.push({
+				chunk,
+				score: item.score
+			});
+		}
+		return out;
+	}
+	/**
+	* Recompute every embedding for one source from the already-stored texts
+	* (no LLM extraction). Repairs libraries whose vectors are missing
+	* (ingested while the embedding model was unavailable) or stale (produced
+	* by a different model). All texts are embedded up front — any batch
+	* failure aborts before the first write, so the library is never left
+	* half-updated. On success the embedding-model meta is stamped with the
+	* engine's identity, unblocking future ingests after a model change.
+	*/
+	async reembedSource(sourceId, engine) {
+		await this.init();
+		if (this.db === void 0) throw new Error("knowledge store not initialized");
+		if (!engine.available) throw new Error("embedding engine unavailable");
+		const chunkRows = this.db.prepare("SELECT id, heading, content FROM knowledge_chunks WHERE source_id = ? ORDER BY rank ASC").all(sourceId);
+		const chunkTexts = chunkRows.map((c) => c.heading !== null ? `${c.heading}\n${c.content}` : c.content);
+		const eventRows = this.db.prepare("SELECT id, title, content FROM knowledge_events WHERE source_id = ? ORDER BY rank ASC").all(sourceId);
+		const eventTitleTexts = eventRows.map((e) => e.title);
+		const eventContentTexts = eventRows.map((e) => `${e.title}\n\n${e.content}`);
+		const entityRows = this.db.prepare("SELECT id, name FROM knowledge_entities WHERE source_id = ?").all(sourceId);
+		const relationRows = this.db.prepare(`SELECT ee.id, ee.description, e.title, en.name
+         FROM knowledge_event_entities ee
+         JOIN knowledge_events e ON e.id = ee.event_id
+         JOIN knowledge_entities en ON en.id = ee.entity_id
+         WHERE e.source_id = ?`).all(sourceId);
+		const relationTexts = relationRows.map((r) => r.description !== null && r.description.length > 0 ? r.description : `${r.title} ${r.name}`);
+		const embedAll = async (texts) => {
+			if (texts.length === 0) return [];
+			const vectors = await engine.embedBatch(texts);
+			if (vectors === null || vectors.length !== texts.length) throw new Error("向量嵌入失败，已取消本次重新嵌入");
+			return vectors;
+		};
+		const chunkVecs = await embedAll(chunkTexts);
+		const eventTitleVecs = await embedAll(eventTitleTexts);
+		const eventContentVecs = await embedAll(eventContentTexts);
+		const entityVecs = await embedAll(entityRows.map((e) => e.name));
+		const relationVecs = await embedAll(relationTexts);
+		this.beginTransaction();
+		try {
+			const updChunk = this.db.prepare("UPDATE knowledge_chunks SET embedding_json = ? WHERE id = ?");
+			for (let i = 0; i < chunkRows.length; i++) updChunk.run(vectorToBlob(chunkVecs[i] ?? null), chunkRows[i].id);
+			const updEvent = this.db.prepare("UPDATE knowledge_events SET title_embedding_json = ?, content_embedding_json = ? WHERE id = ?");
+			for (let i = 0; i < eventRows.length; i++) updEvent.run(vectorToBlob(eventTitleVecs[i] ?? null), vectorToBlob(eventContentVecs[i] ?? null), eventRows[i].id);
+			const updEntity = this.db.prepare("UPDATE knowledge_entities SET embedding_json = ? WHERE id = ?");
+			for (let i = 0; i < entityRows.length; i++) updEntity.run(vectorToBlob(entityVecs[i] ?? null), entityRows[i].id);
+			const updRelation = this.db.prepare("UPDATE knowledge_event_entities SET embedding_json = ? WHERE id = ?");
+			for (let i = 0; i < relationRows.length; i++) updRelation.run(vectorToBlob(relationVecs[i] ?? null), relationRows[i].id);
+			await this.setMeta(EMBEDDING_MODEL_META_KEY, engine.modelName);
+			this.commitTransaction();
+		} catch (error) {
+			this.rollbackTransaction();
+			throw error;
+		}
+		return {
+			chunks: chunkRows.length,
+			events: eventRows.length,
+			entities: entityRows.length,
+			relations: relationRows.length
+		};
+	}
+	/**
+	* Chunk vector coverage — how many of the stored chunks carry an embedding.
+	* Used by the TUI to surface partial/skipped embedding after an ingest.
+	*/
+	async embeddingCoverage() {
+		await this.init();
+		if (this.db === void 0) return {
+			total: 0,
+			embedded: 0
+		};
+		const row = this.db.prepare(`SELECT COUNT(*) AS total,
+                SUM(CASE WHEN embedding_json IS NOT NULL THEN 1 ELSE 0 END) AS embedded
+         FROM knowledge_chunks`).get();
+		if (row === void 0) return {
+			total: 0,
+			embedded: 0
+		};
+		return {
+			total: Number(row["total"] ?? 0),
+			embedded: Number(row["embedded"] ?? 0)
+		};
+	}
+	async stats() {
+		await this.init();
+		if (this.db === void 0) return {
+			sources: 0,
+			documents: 0,
+			chunks: 0,
+			events: 0,
+			entities: 0
+		};
+		const count = (table) => {
+			return this.db.prepare(`SELECT COUNT(*) AS c FROM ${table}`).get()?.c ?? 0;
+		};
+		return {
+			sources: count("knowledge_sources"),
+			documents: count("knowledge_documents"),
+			chunks: count("knowledge_chunks"),
+			events: count("knowledge_events"),
+			entities: count("knowledge_entities")
+		};
+	}
+	async buildSearchResult(chunkId, score, eventId = null) {
+		if (this.db === void 0) return void 0;
+		const chunk = await this.getChunk(chunkId);
+		if (chunk === void 0) return void 0;
+		if (this.db.prepare("SELECT * FROM knowledge_documents WHERE id = ?").get(chunk.documentId) === void 0) return void 0;
+		const sourceRow = this.db.prepare("SELECT * FROM knowledge_sources WHERE id = ?").get(chunk.sourceId);
+		if (sourceRow === void 0) return void 0;
+		let eventTitle = null;
+		if (eventId !== null) eventTitle = (await this.getEvent(eventId))?.title ?? null;
+		return {
+			chunkId: chunk.id,
+			documentId: chunk.documentId,
+			sourceId: chunk.sourceId,
+			sourceName: String(sourceRow["name"]),
+			heading: chunk.heading,
+			content: chunk.content,
+			score,
+			eventId,
+			eventTitle
+		};
+	}
+};
+function asString(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") return String(value);
+	return "";
+}
+function asNullableString(value) {
+	if (value === null || value === void 0) return null;
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") return String(value);
+	return null;
+}
+function rowToSource(row) {
+	return {
+		id: asString(row["id"]),
+		name: asString(row["name"]),
+		filePath: asNullableString(row["file_path"]),
+		description: asNullableString(row["description"]),
+		contentHash: asNullableString(row["content_hash"]),
+		createdAt: Number(row["created_at"])
+	};
+}
+function rowToDocument(row) {
+	return {
+		id: asString(row["id"]),
+		sourceId: asString(row["source_id"]),
+		title: asString(row["title"]),
+		content: asNullableString(row["content"]),
+		status: asString(row["status"]),
+		chunkCount: Number(row["chunk_count"] ?? 0),
+		createdAt: Number(row["created_at"])
+	};
+}
+function rowToChunk(row) {
+	return {
+		id: asString(row["id"]),
+		sourceId: asString(row["source_id"]),
+		documentId: asString(row["document_id"]),
+		rank: Number(row["rank"]),
+		heading: asNullableString(row["heading"]),
+		content: asString(row["content"]),
+		rawContent: asNullableString(row["raw_content"]),
+		embedding: blobToVector(row["embedding_json"]),
+		createdAt: Number(row["created_at"])
+	};
+}
+function rowToEvent(row) {
+	let keywords = [];
+	try {
+		const parsed = JSON.parse(asString(row["keywords"] ?? "[]"));
+		if (Array.isArray(parsed)) keywords = parsed.filter((k) => typeof k === "string");
+	} catch {}
+	return {
+		id: asString(row["id"]),
+		sourceId: asString(row["source_id"]),
+		documentId: asString(row["document_id"]),
+		chunkId: asString(row["chunk_id"]),
+		rank: Number(row["rank"]),
+		title: asString(row["title"]),
+		summary: asNullableString(row["summary"]),
+		content: asString(row["content"]),
+		category: asNullableString(row["category"]),
+		keywords,
+		titleEmbedding: blobToVector(row["title_embedding_json"]),
+		contentEmbedding: blobToVector(row["content_embedding_json"]),
+		createdAt: Number(row["created_at"])
+	};
+}
+function rowToEntity(row) {
+	return {
+		id: asString(row["id"]),
+		sourceId: asString(row["source_id"]),
+		type: asString(row["type"]),
+		name: asString(row["name"]),
+		normalizedName: asString(row["normalized_name"]),
+		description: asNullableString(row["description"]),
+		embedding: blobToVector(row["embedding_json"]),
+		createdAt: Number(row["created_at"])
+	};
+}
+/**
+* Tokenize text so FTS5's unicode61 tokenizer can index mixed CJK/ASCII text.
+* Mirrors the memory package's `toFtsText`.
+*/
+function toFtsText(text) {
+	const parts = text.toLowerCase().replaceAll(/([一-鿿㐀-䶿])([a-z0-9])/g, "$1 $2").replaceAll(/([a-z0-9])([一-鿿㐀-䶿])/g, "$1 $2").split(/[^a-z0-9一-鿿㐀-䶿]+/);
+	const tokens = [];
+	for (const part of parts) {
+		if (part.length === 0) continue;
+		if (/^[a-z0-9]+$/.test(part)) tokens.push(part);
+		else for (const ch of part) if (ch.length > 0) tokens.push(ch);
+	}
+	return tokens.join(" ");
+}
+function buildFtsQuery(search) {
+	const tokens = toFtsText(search).split(/\s+/).filter((t) => t.length > 0);
+	if (tokens.length === 0) return void 0;
+	return tokens.map((t) => `"${t.replaceAll("\"", "\"\"")}"`).join(" AND ");
+}
+//#endregion
+//#region ../../packages/knowledge/src/shared-store.ts
+const entries = /* @__PURE__ */ new Map();
+function entryFor(homeDir) {
+	const existing = entries.get(homeDir);
+	if (existing !== void 0) return existing;
+	const store = new KnowledgeStore(homeDir);
+	const entry = {
+		store,
+		ready: (async () => {
+			try {
+				await store.init();
+				const cacheDir = join$1(homeDir, "cache", "fastembed");
+				mkdirSync(cacheDir, { recursive: true });
+				store.setEmbeddingEngine(createFastEmbedEngine(cacheDir));
+			} catch (error) {
+				entries.delete(homeDir);
+				throw error;
+			}
+		})()
+	};
+	entries.set(homeDir, entry);
+	return entry;
+}
+/**
+* Process-level KnowledgeStore per homeDir, plus the embedding engine wired
+* onto it — one handle and one status source instead of one per host (TUI
+* command vs agent session).
+*
+* The map key is the raw homeDir string so the engine cache key
+* join(homeDir, 'cache', 'fastembed') stays byte-identical with every other
+* createFastEmbedEngine call site: same string → same engine instance.
+*/
+function sharedKnowledgeStore(homeDir) {
+	return entryFor(homeDir).store;
+}
+/** Resolves once init + engine wiring finished; rejects once per failed build. */
+function sharedKnowledgeStoreReady(homeDir) {
+	return entryFor(homeDir).ready;
+}
+//#endregion
+//#region ../../packages/knowledge/src/chunking.ts
+const HEADING_RE = /^(#{1,6})\s+(.+?)\s*$/;
+const CODE_FENCE_RE = /^(\s*)(`{3,}|~{3,})/;
+/**
+* Soft cap on chunk token count. BGE-small-zh-v1.5 (the fastembed model used
+* here) has a 512-token sequence limit; chunks longer than that get truncated
+* at the embedding layer, hurting retrieval quality. We split at ~480 to leave
+* headroom for the heading line that gets prepended at embed time.
+*/
+const MAX_CHUNK_TOKENS = 480;
+/**
+* Split a markdown document into sections using heading_strict strategy:
+* each section begins at a heading and contains all body content until the
+* next heading. Consecutive headings collapse to the lowest-level one as the
+* main heading. Content before the first heading is grouped as "Introduction".
+*
+* Mirrors SAG's `buildHeadingStrictSections`.
+*/
+function chunkMarkdown(content) {
+	const lines = content.split("\n");
+	const sections = [];
+	let buffer = [];
+	let currentHeading = null;
+	let currentLevel = null;
+	let rank = 0;
+	let inFence = false;
+	const flush = () => {
+		const raw = buffer.join("\n").trim();
+		const heading = currentHeading;
+		const level = currentLevel;
+		buffer = [];
+		if (raw.length === 0) return;
+		const body = stripMarkdown(raw);
+		if (body.length === 0 && heading === null) return;
+		const subSections = splitLargeSection({
+			heading,
+			headingLevel: level,
+			content: body,
+			rawContent: raw,
+			rank
+		});
+		for (const section of subSections) {
+			sections.push({
+				...section,
+				rank
+			});
+			rank += 1;
+		}
+	};
+	for (const line of lines) {
+		if (CODE_FENCE_RE.exec(line)) {
+			inFence = !inFence;
+			buffer.push(line);
+			continue;
+		}
+		if (inFence) {
+			buffer.push(line);
+			continue;
+		}
+		const headingMatch = HEADING_RE.exec(line);
+		if (headingMatch) {
+			flush();
+			currentHeading = headingMatch[2].trim();
+			currentLevel = headingMatch[1].length;
+		} else buffer.push(line);
+	}
+	flush();
+	return sections;
+}
+/**
+* Strip markdown decorations that hurt embedding quality:
+* code fences, inline code, images, links, emphasis markers.
+*
+* Mirrors SAG's `stripMarkdown`.
+*/
+function stripMarkdown(text) {
+	return text.replaceAll(/^(\s*)```[^\n]*$\n?/gm, "$1").replaceAll(/^(\s*)```[^\n]*$/gm, "").replaceAll(/`([^`]+)`/g, "$1").replaceAll(/!\[([^\]]*)\]\([^)]+\)/g, "$1").replaceAll(/\[([^\]]+)\]\([^)]+\)/g, "$1").replaceAll(/\*\*([^*]+)\*\*/g, "$1").replaceAll(/__([^_]+)__/g, "$1").replaceAll(/(?<!\w)\*([^*\n]+)\*(?!\w)/g, "$1").replaceAll(/(?<!\w)_([^_\n]+)_(?!\w)/g, "$1").replaceAll(/^#{1,6}\s+/gm, "").replaceAll(/\n{3,}/g, "\n\n").trim();
+}
+/**
+* Split a plain text file into chunks by blank-line paragraphs.
+* Each non-empty paragraph becomes one chunk with no heading.
+* Long paragraphs are split at sentence boundaries to stay under the
+* embedding model's token cap (same MAX_CHUNK_TOKENS as markdown).
+*/
+function chunkText(content) {
+	const MAX_PARA_TOKENS = MAX_CHUNK_TOKENS;
+	const MAX_PARA_CHARS = MAX_PARA_TOKENS * 4;
+	const paragraphs = content.split(/\n\s*\n/).map((p) => p.trim()).filter((p) => p.length > 0);
+	const sections = [];
+	let rank = 0;
+	for (const para of paragraphs) {
+		if (estimateTokens(para) <= MAX_PARA_TOKENS) {
+			sections.push({
+				heading: null,
+				headingLevel: null,
+				content: para,
+				rawContent: para,
+				rank: rank++
+			});
+			continue;
+		}
+		const sentences = para.match(/[^.!?。！？\n]+[.!?。！？\n]+|[^.!?。！？\n]+$/g) ?? [para];
+		let buffer = "";
+		const flushBuffer = () => {
+			const text = buffer.trim();
+			if (text.length === 0) return;
+			sections.push({
+				heading: null,
+				headingLevel: null,
+				content: text,
+				rawContent: text,
+				rank: rank++
+			});
+			buffer = "";
+		};
+		for (const sentence of sentences) {
+			const candidate = (buffer + " " + sentence).trim();
+			if (buffer.length > 0 && candidate.length > MAX_PARA_CHARS) flushBuffer();
+			buffer = buffer.length === 0 ? sentence : `${buffer} ${sentence}`;
+		}
+		flushBuffer();
+	}
+	return sections;
+}
+/** Rough token estimate — chars / 4 (English-leaning; CJK underestimates). */
+function estimateTokens(text) {
+	return Math.ceil(text.length / 4);
+}
+/**
+* Split a section that exceeds MAX_CHUNK_TOKENS into smaller sub-sections.
+* Strategy (mirrors SAG's `splitLargeSection`):
+*   1. Split into paragraphs by blank lines.
+*   2. Greedily pack paragraphs into chunks under the token cap.
+*   3. A paragraph that alone exceeds the cap is split at sentence boundaries;
+*      a sentence that itself exceeds the cap is split by character limit.
+*
+* Sections under the cap are returned unchanged (single-element array).
+* The heading is preserved across all sub-sections; rank is reassigned by the
+* caller. rawContent is rebuilt from the sub-chunk's content paragraphs.
+*/
+function splitLargeSection(section) {
+	if (estimateTokens(section.content) <= MAX_CHUNK_TOKENS) return [section];
+	const paragraphs = section.rawContent.split(/\n{2,}/).map((p) => p.trim()).filter((p) => p.length > 0);
+	if (paragraphs.length <= 1) return splitBySentences(section, section.rawContent);
+	const result = [];
+	let buffer = [];
+	let bufferTokens = 0;
+	const flushBuffer = () => {
+		if (buffer.length === 0) return;
+		const raw = buffer.join("\n\n").trim();
+		if (raw.length === 0) {
+			buffer = [];
+			bufferTokens = 0;
+			return;
+		}
+		result.push({
+			heading: section.heading,
+			headingLevel: section.headingLevel,
+			content: stripMarkdown(raw),
+			rawContent: raw,
+			rank: 0
+		});
+		buffer = [];
+		bufferTokens = 0;
+	};
+	for (const para of paragraphs) {
+		const paraTokens = estimateTokens(para);
+		if (paraTokens > MAX_CHUNK_TOKENS) {
+			flushBuffer();
+			for (const frag of splitBySentences(section, para)) result.push(frag);
+			continue;
+		}
+		if (buffer.length > 0 && bufferTokens + paraTokens > MAX_CHUNK_TOKENS) flushBuffer();
+		buffer.push(para);
+		bufferTokens += paraTokens;
+	}
+	flushBuffer();
+	return result.length > 0 ? result : [section];
+}
+/**
+* Split a long text into sub-sections at sentence boundaries.
+* Falls back to a hard character cut when a single sentence exceeds the cap.
+*/
+function splitBySentences(section, text) {
+	const sentences = splitSentences(text);
+	const result = [];
+	let buffer = "";
+	let bufferTokens = 0;
+	const flush = () => {
+		const trimmed = buffer.trim();
+		if (trimmed.length === 0) {
+			buffer = "";
+			bufferTokens = 0;
+			return;
+		}
+		result.push({
+			heading: section.heading,
+			headingLevel: section.headingLevel,
+			content: stripMarkdown(trimmed),
+			rawContent: trimmed,
+			rank: 0
+		});
+		buffer = "";
+		bufferTokens = 0;
+	};
+	for (const sentence of sentences) {
+		const sentTokens = estimateTokens(sentence);
+		if (sentTokens > MAX_CHUNK_TOKENS) {
+			flush();
+			for (const frag of splitByCharLimit(sentence)) result.push({
+				heading: section.heading,
+				headingLevel: section.headingLevel,
+				content: stripMarkdown(frag),
+				rawContent: frag,
+				rank: 0
+			});
+			continue;
+		}
+		if (buffer.length > 0 && bufferTokens + sentTokens > MAX_CHUNK_TOKENS) flush();
+		buffer = buffer.length === 0 ? sentence : `${buffer} ${sentence}`;
+		bufferTokens += sentTokens;
+	}
+	flush();
+	return result.length > 0 ? result : [{
+		heading: section.heading,
+		headingLevel: section.headingLevel,
+		content: section.content,
+		rawContent: section.rawContent,
+		rank: 0
+	}];
+}
+/** Split text into sentences using CJK + ASCII punctuation. */
+function splitSentences(text) {
+	return text.match(/[^。！？!?.\n]+[。！？!?.\n]+|[^。！？!?.\n]+$/g) ?? [text];
+}
+/** Hard character cut for pathological single sentences longer than the cap. */
+function splitByCharLimit(text) {
+	const maxChars = MAX_CHUNK_TOKENS * 4;
+	const chunks = [];
+	let remaining = text.trim();
+	while (remaining.length > maxChars) {
+		chunks.push(remaining.slice(0, maxChars));
+		remaining = remaining.slice(maxChars).trimStart();
+	}
+	if (remaining.length > 0) chunks.push(remaining);
+	return chunks;
+}
+//#endregion
+//#region ../../packages/knowledge/src/extractor.ts
+/** Max LLM call attempts for extraction — fails fall back to a heading-derived event. */
+const EXTRACTION_MAX_ATTEMPTS = 3;
+/** Base delay (ms) for exponential backoff: 100, 200, 400. */
+const EXTRACTION_BACKOFF_BASE_MS = 100;
+function backoffDelay(attempt) {
+	return EXTRACTION_BACKOFF_BASE_MS * 2 ** Math.max(0, attempt - 1);
+}
+async function callLlmWithBackoff(llm, systemPrompt, userPrompt) {
+	let lastError;
+	for (let attempt = 1; attempt <= EXTRACTION_MAX_ATTEMPTS; attempt += 1) try {
+		return await llm.generate(systemPrompt, userPrompt);
+	} catch (error) {
+		lastError = error;
+		if (attempt < EXTRACTION_MAX_ATTEMPTS) await new Promise((resolve) => setTimeout(resolve, backoffDelay(attempt)));
+	}
+	throw lastError;
+}
+const ENTITY_TYPES = [
+	"person",
+	"organization",
+	"location",
+	"time",
+	"product",
+	"metric",
+	"action",
+	"work",
+	"group",
+	"subject",
+	"tags"
+];
+const EXTRACTION_SYSTEM_PROMPT = `You are a professional knowledge content extractor for a SAG-style event-centric knowledge graph.
+
+Your task: given a markdown section (one chunk), extract exactly ONE fused event that captures the section's core informational content, plus the entities mentioned.
+
+# Output Format
+
+Return a JSON object with this exact shape:
+
+{
+  "items": [
+    {
+      "title": "short event title (≤80 chars, noun phrase or short sentence)",
+      "summary": "one-sentence summary of what this section is about",
+      "content": "the full informational content of this section, rephrased as a self-contained event description (1-4 sentences)",
+      "category": "one of: definition, process, comparison, decision, history, reference, other",
+      "keywords": ["3-5 short keywords or phrases"],
+      "entities": [
+        { "type": "one of ENTITY_TYPES below", "name": "entity name", "description": "one-line context for the entity" }
+      ]
+    }
+  ]
+}
+
+# Entity Types
+
+Use only these types:
+- person — named individuals
+- organization — companies, teams, institutions
+- location — places, geographic regions
+- time — dates, time periods, eras
+- product — products, services, software, tools
+- metric — numbers, statistics, measurements
+- action — processes, operations, activities
+- work — books, papers, projects, artworks
+- group — categories, classes, groups of things
+- subject — abstract topics, concepts, fields
+- tags — use sparingly for cross-cutting labels
+
+# Rules
+
+1. Produce EXACTLY ONE item in the "items" array.
+2. The event title should be specific enough to disambiguate from sibling sections.
+3. The content must be self-contained — a reader should understand it without the surrounding context.
+4. Extract 2-6 entities per chunk. Only include entities that are clearly referenced in the text.
+5. Use the entity's most specific name (e.g. "Anthropic" rather than "the company").
+6. Output language must follow the main input language. Chinese input requires Chinese title, summary, content, category, keywords, and entity descriptions. English input requires English fields.
+7. Output ONLY the JSON object — no prose, no markdown fences, no commentary.
+
+# Example
+
+Input section:
+"""
+## Model Context Protocol
+
+The Model Context Protocol (MCP) is an open standard introduced by Anthropic in 2024. It defines a JSON-RPC interface between AI assistants and external tools. MCP servers expose resources, prompts, and tools that clients like Claude Desktop can consume.
+"""
+
+Output:
+{
+  "items": [
+    {
+      "title": "Model Context Protocol introduction",
+      "summary": "MCP is an open standard for AI assistant / tool integration introduced by Anthropic in 2024.",
+      "content": "The Model Context Protocol (MCP) is an open standard introduced by Anthropic in 2024 that defines a JSON-RPC interface between AI assistants and external tools. MCP servers expose resources, prompts, and tools that clients like Claude Desktop can consume.",
+      "category": "definition",
+      "keywords": ["MCP", "JSON-RPC", "Anthropic", "AI tools"],
+      "entities": [
+        { "type": "product", "name": "Model Context Protocol", "description": "Open standard for AI assistant / tool integration" },
+        { "type": "organization", "name": "Anthropic", "description": "Company that introduced MCP in 2024" },
+        { "type": "time", "name": "2024", "description": "Year MCP was introduced" },
+        { "type": "product", "name": "Claude Desktop", "description": "An MCP client application" }
+      ]
+    }
+  ]
+}`;
+/**
+* Build the user prompt for extracting events/entities from a chunk.
+* Includes a one-shot example to anchor the expected output shape.
+*/
+function buildExtractionUserPrompt(chunk) {
+	return [
+		"Extract the fused event and entities from the following markdown section.",
+		"",
+		`Section heading: ${chunk.heading ?? "(no heading)"}`,
+		"",
+		"Section content:",
+		"\"\"\"",
+		chunk.content,
+		"\"\"\"",
+		"",
+		"Return only the JSON object per the schema."
+	].join("\n");
+}
+/** Extract the first {...} JSON block from a text response. */
+function extractJsonFromText(text) {
+	const match = text.match(/\{[\s\S]*\}/);
+	return match === null ? null : match[0];
+}
+/** Parse LLM extraction output into structured events. Returns at most 1 event. */
+function parseExtractionResponse(text, fallbackChunk) {
+	const jsonText = extractJsonFromText(text);
+	if (jsonText === null) return fallbackEvent(fallbackChunk);
+	try {
+		const items = JSON.parse(jsonText)["items"];
+		if (!Array.isArray(items) || items.length === 0) return fallbackEvent(fallbackChunk);
+		const first = items[0];
+		if (first === null || typeof first !== "object") return fallbackEvent(fallbackChunk);
+		const obj = first;
+		return {
+			title: typeof obj["title"] === "string" && obj["title"].trim().length > 0 ? obj["title"].trim() : fallbackChunk.heading ?? "Untitled",
+			summary: typeof obj["summary"] === "string" ? obj["summary"].trim() : "",
+			content: typeof obj["content"] === "string" && obj["content"].trim().length > 0 ? obj["content"].trim() : fallbackChunk.content,
+			category: typeof obj["category"] === "string" ? obj["category"].trim() : "other",
+			keywords: parseKeywords(obj["keywords"]),
+			entities: parseEntities(obj["entities"])
+		};
+	} catch {
+		return fallbackEvent(fallbackChunk);
+	}
+}
+function parseKeywords(value) {
+	if (!Array.isArray(value)) return [];
+	const out = [];
+	for (const item of value) if (typeof item === "string" && item.trim().length > 0) out.push(item.trim());
+	return out.slice(0, 10);
+}
+function parseEntities(value) {
+	if (!Array.isArray(value)) return [];
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const item of value) {
+		if (item === null || typeof item !== "object") continue;
+		const obj = item;
+		const type = typeof obj["type"] === "string" ? obj["type"] : "";
+		const name = typeof obj["name"] === "string" ? obj["name"].trim() : "";
+		const description = typeof obj["description"] === "string" ? obj["description"].trim() : "";
+		if (name.length === 0) continue;
+		if (!ENTITY_TYPES.includes(type)) continue;
+		const key = `${type}|${name.toLowerCase()}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push({
+			type,
+			name,
+			description
+		});
+	}
+	return out.slice(0, 20);
+}
+function fallbackEvent(chunk) {
+	return {
+		title: chunk.heading ?? "Untitled section",
+		summary: "",
+		content: chunk.content,
+		category: "other",
+		keywords: [],
+		entities: []
+	};
+}
+/**
+* Run extraction on a single chunk via the LLM caller.
+* Retries with exponential backoff on transient failures; falls back to a
+* heading-derived event only after all attempts fail.
+*/
+async function extractEventFromChunk(llm, chunk) {
+	try {
+		return parseExtractionResponse(await callLlmWithBackoff(llm, EXTRACTION_SYSTEM_PROMPT, buildExtractionUserPrompt(chunk)), chunk);
+	} catch {
+		return fallbackEvent(chunk);
+	}
+}
+/**
+* Ask the LLM to rerank candidate events by relevance to a query.
+* Returns the candidate ids in reranked order (most relevant first).
+*
+* If the LLM fails or returns unparseable output, returns the input order.
+*/
+async function rerankEventsWithLlm(llm, query, candidates, topK) {
+	if (candidates.length === 0) return [];
+	if (candidates.length <= topK) return candidates.map((c) => c.id);
+	const candidateList = candidates.map((c, i) => `[${i}] id=${c.id}\n    title: ${c.title}\n    summary: ${c.summary}`).join("\n");
+	const system = `You are a precise relevance judge for a knowledge base retrieval system.
+
+Given a user query and a list of candidate events, select the ${topK} event ids most useful for answering the query.
+
+Return ONLY a JSON object: {"ids": ["id1", "id2", ...]}
+
+The ids must come from the candidate list. Output at most ${topK} ids, most relevant first. No prose, no markdown.`;
+	const user = `Query: ${query}
+
+Candidates:
+${candidateList}
+
+Return the JSON object now.`;
+	try {
+		const jsonText = extractJsonFromText(await llm.generate(system, user));
+		if (jsonText === null) return candidates.slice(0, topK).map((c) => c.id);
+		const parsed = JSON.parse(jsonText);
+		if (!Array.isArray(parsed["ids"])) return candidates.slice(0, topK).map((c) => c.id);
+		const validIds = new Set(candidates.map((c) => c.id));
+		const result = [];
+		for (const id of parsed["ids"]) {
+			if (typeof id === "string" && validIds.has(id) && !result.includes(id)) result.push(id);
+			if (result.length >= topK) break;
+		}
+		if (result.length === 0) return candidates.slice(0, topK).map((c) => c.id);
+		return result;
+	} catch {
+		return candidates.slice(0, topK).map((c) => c.id);
+	}
+}
+/**
+* Extract named entities from a query for entity-recall retrieval.
+* Returns a list of {type, name} pairs. Best-effort — falls back to empty.
+*/
+async function extractQueryEntities(llm, query) {
+	const system = `Extract named entities from the user query. Return ONLY a JSON object: {"entities": [{"type": "...", "name": "..."}]}
+
+Use these entity types: ${ENTITY_TYPES.join(", ")}.
+
+Only include entities that explicitly appear in the query. If no clear entities, return an empty array.`;
+	try {
+		const jsonText = extractJsonFromText(await llm.generate(system, `Query: ${query}`));
+		if (jsonText === null) return [];
+		const parsed = JSON.parse(jsonText);
+		if (!Array.isArray(parsed["entities"])) return [];
+		const out = [];
+		for (const item of parsed["entities"]) {
+			if (item === null || typeof item !== "object") continue;
+			const obj = item;
+			const type = typeof obj["type"] === "string" ? obj["type"] : "";
+			const name = typeof obj["name"] === "string" ? obj["name"].trim() : "";
+			if (name.length === 0) continue;
+			if (!ENTITY_TYPES.includes(type)) continue;
+			out.push({
+				type,
+				name
+			});
+		}
+		return out;
+	} catch {
+		return [];
+	}
+}
+//#endregion
+//#region ../../packages/knowledge/src/ingest.ts
+/**
+* Embed texts, returning null-array if embeddings are skipped or on failure.
+* Caller should set skipEmbedding=true when the model didn't load in time,
+* so the entire ingestion is consistent (all or nothing for embeddings).
+* Search falls back to FTS5 keyword match for chunks without embeddings.
+*/
+async function embedOrNulls(engine, texts, skipEmbedding) {
+	if (engine === void 0 || texts.length === 0 || skipEmbedding) return texts.map(() => null);
+	if (!engine.available) return texts.map(() => null);
+	const vectors = await engine.embedBatch(texts);
+	if (vectors === null || vectors.length !== texts.length) return texts.map(() => null);
+	return vectors;
+}
+/** LLM concurrency for extraction — callers and comments below refer to this constant. */
+const LLM_CONCURRENCY = 20;
+const SUPPORTED_EXTENSIONS = new Set([
+	".md",
+	".markdown",
+	".txt"
+]);
+/** Read a file and return its content. */
+async function readFileContent(filePath) {
+	return readFile(filePath, "utf-8");
+}
+function getFileExtension(filePath) {
+	const lastDot = filePath.lastIndexOf(".");
+	return lastDot > 0 ? filePath.slice(lastDot).toLowerCase() : "";
+}
+function chunkContent(content, ext) {
+	return ext === ".txt" ? chunkText(content) : chunkMarkdown(content);
+}
+function isSupportedFile(filePath) {
+	return SUPPORTED_EXTENSIONS.has(getFileExtension(filePath));
+}
+/** Map async iterator values with a concurrency limit. */
+async function mapWithConcurrency(items, limit, fn, onProgress) {
+	const results = Array.from({ length: items.length });
+	let cursor = 0;
+	let completed = 0;
+	const total = items.length;
+	async function worker() {
+		while (cursor < items.length) {
+			const idx = cursor;
+			cursor += 1;
+			const item = items[idx];
+			const result = await fn(item, idx);
+			results[idx] = result;
+			completed += 1;
+			onProgress?.(completed, total, result);
+		}
+	}
+	const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
+	await Promise.all(workers);
+	return results;
+}
+/**
+* Stamp or verify the embedding-model identity recorded in the library.
+* A library written by a different model would mix vector spaces — block the
+* ingest with a clear message instead of silently storing incompatible
+* embeddings. A legacy library without the marker is stamped with the current
+* model (all existing data was written by it).
+*/
+async function ensureEmbeddingModelMatches(store, engine) {
+	if (engine === void 0) return;
+	const recorded = await store.getMeta(EMBEDDING_MODEL_META_KEY);
+	if (recorded === null) {
+		await store.setMeta(EMBEDDING_MODEL_META_KEY, engine.modelName);
+		return;
+	}
+	if (recorded !== engine.modelName) throw new Error(`知识库由模型 ${recorded} 嵌入，当前模型为 ${engine.modelName}，请先在 /knowledge 中重新嵌入知识库`);
+}
+/**
+* Ingest a markdown file into the knowledge base.
+*
+* Steps:
+* 1. Dedupe by file_path — if a source already exists for this file, error.
+* 2. Read file → chunkMarkdown (heading_strict).
+* 3. Embed chunks ("{heading}\n{content}") → store knowledge_chunks.
+* 4. For each chunk (concurrency LLM_CONCURRENCY): LLM extract 1 event + N entities.
+* 5. Embed event title + content ("{title}\n\n{content}") → store knowledge_events.
+* 6. Upsert entities (dedupe by source_id+type+normalizedName) + embed entity name → store.
+* 7. For each (event, entity) pair: embed relation (entity.description || "{eventTitle} {entityName}") → store knowledge_event_entities.
+* 8. Update document status = 'completed'.
+*
+* All writes run inside a single transaction — a mid-ingest failure rolls back
+* every partial row (source/document/chunks/events/entities/edges).
+*
+* Reports progress via callback.
+*/
+async function ingestFile(store, llm, filePath, onProgress) {
+	const engine = store.getEmbeddingEngine();
+	const skipEmbed = engine === void 0 || !engine.available;
+	if (skipEmbed) onProgress?.({
+		stage: "embedding-check",
+		message: "向量模型未就绪，本次摄入跳过向量嵌入"
+	});
+	await ensureEmbeddingModelMatches(store, engine);
+	onProgress?.({
+		stage: "chunking",
+		message: `读取并切分文件: ${basename$1(filePath)}`
+	});
+	const content = await readFileContent(filePath);
+	const contentHash = createHash("sha256").update(content).digest("hex");
+	const existing = await store.findSourceByFilePath(filePath);
+	let replacedOldVersion = false;
+	if (existing !== void 0) {
+		if (existing.contentHash === contentHash || existing.contentHash === null) {
+			if (existing.contentHash === null) await store.updateSourceContentHash(existing.id, contentHash);
+			onProgress?.({
+				stage: "completed",
+				message: "内容未变化，已跳过"
+			});
+			return {
+				documentId: null,
+				chunkCount: 0,
+				eventCount: 0,
+				entityCount: 0,
+				outcome: "unchanged"
+			};
+		}
+		onProgress?.({
+			stage: "chunking",
+			message: `检测到内容变更，替换旧版本: ${existing.name}`
+		});
+		await store.deleteSource(existing.id);
+		replacedOldVersion = true;
+	}
+	const sections = chunkContent(content, getFileExtension(filePath));
+	store.beginTransaction();
+	try {
+		if (sections.length === 0) {
+			onProgress?.({
+				stage: "error",
+				message: "文件无有效内容"
+			});
+			throw new Error("文件无有效内容可摄入");
+		}
+		const fileName = basename$1(filePath);
+		const source = await store.createSource({
+			name: fileName,
+			filePath,
+			description: null,
+			contentHash
+		});
+		const document = await store.createDocument({
+			sourceId: source.id,
+			title: fileName,
+			content
+		});
+		const { chunks, events, uniqueEntities } = await ingestSections(store, llm, {
+			source,
+			document,
+			sections,
+			engine,
+			skipEmbed
+		}, onProgress);
+		return {
+			documentId: document.id,
+			chunkCount: chunks.length,
+			eventCount: events.length,
+			entityCount: uniqueEntities.length,
+			outcome: replacedOldVersion ? "updated" : "created"
+		};
+	} catch (error) {
+		store.rollbackTransaction();
+		if (replacedOldVersion) {
+			const message = error instanceof Error ? error.message : String(error);
+			throw new Error(`旧版本已删除、新版本摄入失败，请重新摄入该文件: ${filePath}（${message}）`);
+		}
+		throw error;
+	}
+}
+/**
+* Shared steps 4-9 of both ingest paths: embed + store chunks, extract events
+* via LLM, embed + store events, upsert entities, store relations, commit the
+* caller-opened transaction, and emit the completed progress. The file and
+* content pipelines were identical here modulo formatting — one body keeps
+* them from drifting apart again (content had already diverged: it dropped
+* the per-chunk embedding variable and the entity-embedding temp). The caller
+* owns beginTransaction and the catch/rollback.
+*/
+async function ingestSections(store, llm, args, onProgress) {
+	const { source, document, sections, engine, skipEmbed } = args;
+	onProgress?.({
+		stage: "embedding-chunks",
+		chunkIndex: 0,
+		totalChunks: sections.length,
+		message: `嵌入 chunks: 0/${sections.length}`
+	});
+	const chunkEmbeddings = await embedOrNulls(engine, sections.map((s) => s.heading !== null ? `${s.heading}\n${s.content}` : s.content), skipEmbed);
+	const chunks = [];
+	for (let i = 0; i < sections.length; i++) {
+		const section = sections[i];
+		const embedding = chunkEmbeddings[i] ?? null;
+		const chunk = await store.insertChunk({
+			sourceId: source.id,
+			documentId: document.id,
+			rank: section.rank,
+			heading: section.heading,
+			content: section.content,
+			rawContent: section.rawContent,
+			embedding
+		});
+		chunks.push(chunk);
+		onProgress?.({
+			stage: "embedding-chunks",
+			chunkIndex: i + 1,
+			totalChunks: sections.length,
+			message: `嵌入 chunks: ${i + 1}/${sections.length}`
+		});
+	}
+	onProgress?.({
+		stage: "extracting",
+		chunkIndex: 0,
+		totalChunks: sections.length,
+		message: `抽取事件: 0/${sections.length}`
+	});
+	const extractedEvents = await mapWithConcurrency(sections, LLM_CONCURRENCY, (section) => extractEventFromChunk(llm, section), (completed, total) => {
+		onProgress?.({
+			stage: "extracting",
+			chunkIndex: completed,
+			totalChunks: total,
+			message: `抽取事件: ${completed}/${total}`
+		});
+	});
+	onProgress?.({
+		stage: "embedding-events",
+		chunkIndex: 0,
+		totalChunks: sections.length,
+		message: `嵌入 events: 0/${sections.length}`
+	});
+	const titleTexts = extractedEvents.map((e) => e.title);
+	const contentTexts = extractedEvents.map((e) => `${e.title}\n\n${e.content}`);
+	const [titleEmbeddings, contentEmbeddings] = await Promise.all([embedOrNulls(engine, titleTexts, skipEmbed), embedOrNulls(engine, contentTexts, skipEmbed)]);
+	const events = [];
+	for (let i = 0; i < extractedEvents.length; i++) {
+		const extracted = extractedEvents[i];
+		const chunk = chunks[i];
+		const event = await store.insertEvent({
+			sourceId: source.id,
+			documentId: document.id,
+			chunkId: chunk.id,
+			rank: i,
+			title: extracted.title,
+			summary: extracted.summary.length > 0 ? extracted.summary : null,
+			content: extracted.content,
+			category: extracted.category.length > 0 ? extracted.category : null,
+			keywords: extracted.keywords,
+			titleEmbedding: titleEmbeddings[i] ?? null,
+			contentEmbedding: contentEmbeddings[i] ?? null
+		});
+		events.push(event);
+		onProgress?.({
+			stage: "embedding-events",
+			chunkIndex: i + 1,
+			totalChunks: sections.length,
+			message: `嵌入 events: ${i + 1}/${sections.length}`
+		});
+	}
+	onProgress?.({
+		stage: "embedding-entities",
+		message: "嵌入 entities..."
+	});
+	const entityMap = /* @__PURE__ */ new Map();
+	for (const extracted of extractedEvents) for (const entity of extracted.entities) {
+		const key = `${entity.type}|${entity.name.toLowerCase()}`;
+		if (!entityMap.has(key)) entityMap.set(key, entity);
+	}
+	const uniqueEntities = Array.from(entityMap.values());
+	const entityEmbeddings = uniqueEntities.length > 0 ? await embedOrNulls(engine, uniqueEntities.map((e) => e.name), skipEmbed) : [];
+	const entityIdByEntityKey = /* @__PURE__ */ new Map();
+	for (let i = 0; i < uniqueEntities.length; i++) {
+		const entity = uniqueEntities[i];
+		const embedding = entityEmbeddings[i] ?? null;
+		const stored = await store.upsertEntity({
+			sourceId: source.id,
+			type: entity.type,
+			name: entity.name,
+			description: entity.description.length > 0 ? entity.description : null,
+			embedding
+		});
+		entityIdByEntityKey.set(`${entity.type}|${entity.name.toLowerCase()}`, stored.id);
+	}
+	onProgress?.({
+		stage: "embedding-relations",
+		message: "嵌入关系..."
+	});
+	const relationPairs = [];
+	for (let i = 0; i < extractedEvents.length; i++) {
+		const extracted = extractedEvents[i];
+		for (const entity of extracted.entities) relationPairs.push({
+			eventIndex: i,
+			entity
+		});
+	}
+	const relationTexts = relationPairs.map(({ eventIndex, entity }) => {
+		const event = events[eventIndex];
+		return entity.description.length > 0 ? entity.description : `${event.title} ${entity.name}`;
+	});
+	const relationEmbeddings = relationPairs.length > 0 ? await embedOrNulls(engine, relationTexts, skipEmbed) : [];
+	for (let i = 0; i < relationPairs.length; i++) {
+		const pair = relationPairs[i];
+		const event = events[pair.eventIndex];
+		const entityKey = `${pair.entity.type}|${pair.entity.name.toLowerCase()}`;
+		const entityId = entityIdByEntityKey.get(entityKey);
+		if (entityId === void 0) continue;
+		const embedding = relationEmbeddings?.[i] ?? null;
+		await store.insertEventEntity({
+			eventId: event.id,
+			entityId,
+			weight: 1,
+			description: pair.entity.description.length > 0 ? pair.entity.description : null,
+			embedding
+		});
+	}
+	await store.updateDocumentStatus(document.id, "completed", chunks.length);
+	store.commitTransaction();
+	onProgress?.({
+		stage: "completed",
+		message: `摄入完成：${chunks.length} chunks, ${events.length} events, ${uniqueEntities.length} entities`
+	});
+	return {
+		chunks,
+		events,
+		uniqueEntities
+	};
+}
+async function collectSupportedFiles(dirPath) {
+	const files = [];
+	const entries = await readdir(dirPath, { withFileTypes: true });
+	for (const entry of entries) {
+		const fullPath = join$1(dirPath, entry.name);
+		if (entry.isDirectory()) files.push(...await collectSupportedFiles(fullPath));
+		else if (entry.isFile() && isSupportedFile(fullPath)) files.push(fullPath);
+	}
+	return files.sort();
+}
+async function ingestDirectory(store, llm, dirPath, onProgress) {
+	const files = await collectSupportedFiles(dirPath);
+	if (files.length === 0) throw new Error(`目录下没有支持的文件 (.md, .markdown, .txt): ${dirPath}`);
+	const errors = [];
+	let succeeded = 0;
+	let created = 0;
+	let updated = 0;
+	let unchanged = 0;
+	let totalChunks = 0;
+	let totalEvents = 0;
+	let totalEntities = 0;
+	for (let i = 0; i < files.length; i++) {
+		const filePath = files[i];
+		const fileProgress = (progress) => {
+			const prefix = `批量摄入 ${i + 1}/${files.length}: ${basename$1(filePath)}`;
+			onProgress?.({
+				...progress,
+				message: `${prefix} · ${progress.message}`
+			});
+		};
+		try {
+			const result = await ingestFile(store, llm, filePath, fileProgress);
+			succeeded += 1;
+			if (result.outcome === "created") created += 1;
+			else if (result.outcome === "updated") updated += 1;
+			else unchanged += 1;
+			totalChunks += result.chunkCount;
+			totalEvents += result.eventCount;
+			totalEntities += result.entityCount;
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			errors.push({
+				filePath,
+				message
+			});
+			onProgress?.({
+				stage: "error",
+				message: `批量摄入 ${i + 1}/${files.length}: ${basename$1(filePath)} · 失败: ${message}`
+			});
+		}
+	}
+	onProgress?.({
+		stage: "completed",
+		message: `批量摄入完成：新增 ${created} · 更新 ${updated} · 未变化 ${unchanged} · 失败 ${errors.length}（${totalChunks} chunks, ${totalEvents} events, ${totalEntities} entities）`
+	});
+	return {
+		succeeded,
+		failed: errors.length,
+		created,
+		updated,
+		unchanged,
+		totalChunks,
+		totalEvents,
+		totalEntities,
+		errors
+	};
+}
+//#endregion
+//#region ../../packages/knowledge/src/search.ts
+const DEFAULT_TOP_K = 5;
+const MAX_TOP_K = 20;
+const SEED_EVENT_LIMIT = 30;
+const EXPANDED_EVENT_LIMIT = 100;
+const COARSE_RANK_LIMIT = 50;
+const ENTITY_VECTOR_THRESHOLD = .7;
+const TITLE_VECTOR_THRESHOLD = .4;
+async function timed(onStep, step, detail, fn, payload) {
+	const start = performance.now();
+	try {
+		const result = await fn();
+		const traceStep = {
+			step,
+			detail,
+			durationMs: Math.round((performance.now() - start) * 100) / 100,
+			...payload !== void 0 ? { payload: payload(result) } : {}
+		};
+		onStep?.(traceStep);
+		return result;
+	} catch (error) {
+		const durationMs = Math.round((performance.now() - start) * 100) / 100;
+		onStep?.({
+			step,
+			detail: `${detail} 失败：${error instanceof Error ? error.message : String(error)}`,
+			durationMs
+		});
+		throw error;
+	}
+}
+/**
+* Multi-hop retrieval:
+* 1. Vectorize query.
+* 2. Entity recall — LLM extracts entities from query → match by name + vector.
+* 3. Seed events — events linked to recalled entities + events by title vector similarity.
+* 4. BFS expand (1 hop) — from seed events, walk to entities, then to other events.
+* 5. Coarse rank — score graph-reachable events by content embedding similarity.
+*    Graph associativity is the gate; content vector orders within it.
+* 6. LLM rerank — pick top-K most relevant.
+* 7. Return corresponding chunks (deduped by chunk_id) with scores and provenance.
+*    If rerank yields fewer than topK chunks, backfill by direct chunk vector search.
+*
+* Optional `onStep` callback receives a trace step at each phase — used by the
+* KnowledgeLookup tool to expose retrieval diagnostics to the agent.
+*/
+async function multiSearch(store, llm, query, options = {}) {
+	return (await multiSearchWithTrace(store, llm, query, options)).results;
+}
+/** Like multiSearch but also returns the retrieval trace for diagnostics. */
+async function multiSearchWithTrace(store, llm, query, options = {}) {
+	const topK = Math.min(options.topK ?? DEFAULT_TOP_K, MAX_TOP_K);
+	const skipLlm = options.skipLlm === true;
+	const skipRerank = skipLlm || options.skipRerank === true;
+	const steps = [];
+	const onStep = (step) => steps.push(step);
+	const rerankedEventTitles = [];
+	let fallbackReason = null;
+	const engine = store.getEmbeddingEngine();
+	if (engine === void 0 || !engine.available) {
+		fallbackReason = "embedding engine unavailable; used FTS5 keyword fallback";
+		return {
+			results: await ftsFallback(store, query, topK),
+			trace: {
+				steps,
+				rerankedEventTitles,
+				fallbackReason
+			}
+		};
+	}
+	const recordedModel = await store.getMeta(EMBEDDING_MODEL_META_KEY);
+	if (recordedModel !== null && recordedModel !== engine.modelName) {
+		fallbackReason = `embedding model mismatch (library: ${recordedModel}, current: ${engine.modelName}); used FTS5 keyword fallback`;
+		return {
+			results: await ftsFallback(store, query, topK),
+			trace: {
+				steps,
+				rerankedEventTitles,
+				fallbackReason
+			}
+		};
+	}
+	const queryEmbeddings = await timed(onStep, "queryEmbedding", "把用户问题转成向量，用于召回相关事件和切片。", async () => engine.embedBatch([query]));
+	if (queryEmbeddings === null || queryEmbeddings.length === 0) {
+		fallbackReason = "query embedding returned null; used FTS5 fallback";
+		return {
+			results: await ftsFallback(store, query, topK),
+			trace: {
+				steps,
+				rerankedEventTitles,
+				fallbackReason
+			}
+		};
+	}
+	const queryVec = queryEmbeddings[0];
+	const recalledEntities = await timed(onStep, "entityRecall", skipLlm ? "本地向量实体召回（skipLlm，不调 LLM）。" : "LLM 抽 query 实体 + 名字精确匹配 + 向量召回。", () => recallEntities(store, llm, query, queryVec, !skipLlm), (entities) => ({ count: entities.length }));
+	const seedEventIds = /* @__PURE__ */ new Set();
+	for (const entity of recalledEntities) {
+		const events = await store.findEventsByEntity(entity.id);
+		for (const event of events) seedEventIds.add(event.id);
+	}
+	const titleMatches = await timed(onStep, "seedEventsByTitle", "按查询向量在事件标题向量上召回 seed events。", () => store.findEventsByTitleVector(queryVec, {
+		limit: SEED_EVENT_LIMIT,
+		threshold: TITLE_VECTOR_THRESHOLD
+	}), (matches) => ({ count: matches.length }));
+	for (const { event } of titleMatches) seedEventIds.add(event.id);
+	if (seedEventIds.size === 0) {
+		const results = await chunkVectorFallback(store, queryVec, topK);
+		if (results.length > 0) {
+			fallbackReason = "no seed events; used direct chunk vector search";
+			return {
+				results,
+				trace: {
+					steps,
+					rerankedEventTitles,
+					fallbackReason
+				}
+			};
+		}
+		fallbackReason = "no seed events and direct chunk vector search returned no results; used FTS5 keyword fallback";
+		return {
+			results: await ftsFallback(store, query, topK),
+			trace: {
+				steps,
+				rerankedEventTitles,
+				fallbackReason
+			}
+		};
+	}
+	const expandedEventIds = await timed(onStep, "bfsExpand", "从 seed events 沿实体关系 1 跳扩展候选事件。", async () => {
+		const ids = new Set(seedEventIds);
+		let capped = false;
+		for (const eventId of seedEventIds) {
+			const entities = await store.findEntitiesByEvent(eventId);
+			for (const entity of entities) {
+				const neighborEvents = await store.findEventsByEntity(entity.id);
+				for (const neighbor of neighborEvents) {
+					ids.add(neighbor.id);
+					if (ids.size >= EXPANDED_EVENT_LIMIT) {
+						capped = true;
+						break;
+					}
+				}
+				if (ids.size >= EXPANDED_EVENT_LIMIT) break;
+			}
+			if (ids.size >= EXPANDED_EVENT_LIMIT) break;
+		}
+		return {
+			ids,
+			capped
+		};
+	}, (result) => ({
+		expandedCount: result.ids.size,
+		capped: result.capped
+	}));
+	const { candidates, topCandidates } = await timed(onStep, "coarseRank", "按 content 向量相似度对候选事件排序，取前 COARSE_RANK_LIMIT 个。", async () => {
+		const cands = [];
+		for (const eventId of expandedEventIds.ids) {
+			const event = await store.getEvent(eventId);
+			if (event === void 0) continue;
+			const vec = event.contentEmbedding;
+			const score = vec === null ? 0 : engine.cosineSimilarity(queryVec, vec);
+			cands.push({
+				id: event.id,
+				title: event.title,
+				summary: event.summary ?? "",
+				score,
+				chunkId: event.chunkId
+			});
+		}
+		cands.sort((a, b) => b.score - a.score);
+		return {
+			candidates: cands,
+			topCandidates: cands.slice(0, COARSE_RANK_LIMIT)
+		};
+	}, (result) => ({
+		totalCandidates: result.candidates.length,
+		kept: result.topCandidates.length,
+		topScore: result.topCandidates[0]?.score ?? 0
+	}));
+	if (candidates.length === 0) {
+		const results = await chunkVectorFallback(store, queryVec, topK);
+		if (results.length > 0) {
+			fallbackReason = "no graph-reachable events with content; used chunk vector fallback";
+			return {
+				results,
+				trace: {
+					steps,
+					rerankedEventTitles,
+					fallbackReason
+				}
+			};
+		}
+		fallbackReason = "no graph-reachable events with content and chunk vector search returned no results; used FTS5 keyword fallback";
+		return {
+			results: await ftsFallback(store, query, topK),
+			trace: {
+				steps,
+				rerankedEventTitles,
+				fallbackReason
+			}
+		};
+	}
+	let rankedIds;
+	if (skipRerank) {
+		rankedIds = topCandidates.map((c) => c.id);
+		onStep({
+			step: "rerank",
+			detail: "跳过 LLM rerank（skipRerank/skipLlm），直接用 coarse rank 顺序。",
+			durationMs: 0,
+			payload: { count: rankedIds.length }
+		});
+	} else if (topCandidates.length <= topK) {
+		rankedIds = topCandidates.map((c) => c.id);
+		onStep({
+			step: "rerank",
+			detail: `候选数 ${topCandidates.length} ≤ topK ${topK}，无需 LLM rerank。`,
+			durationMs: 0,
+			payload: { count: rankedIds.length }
+		});
+	} else rankedIds = await timed(onStep, "rerank", `LLM 从 ${topCandidates.length} 个候选中选最相关的 ${topK} 个。`, () => rerankEventsWithLlm(llm, query, topCandidates.map((c) => ({
+		id: c.id,
+		title: c.title,
+		summary: c.summary
+	})), topK), (ids) => ({ count: ids.length }));
+	for (const id of rankedIds) {
+		const c = topCandidates.find((x) => x.id === id);
+		if (c !== void 0) rerankedEventTitles.push(c.title);
+	}
+	const seen = /* @__PURE__ */ new Set();
+	const results = [];
+	for (const eventId of rankedIds) {
+		const candidate = topCandidates.find((c) => c.id === eventId);
+		if (candidate === void 0) continue;
+		if (seen.has(candidate.chunkId)) continue;
+		seen.add(candidate.chunkId);
+		const result = await store.buildSearchResult(candidate.chunkId, candidate.score, eventId);
+		if (result !== void 0) results.push(result);
+		if (results.length >= topK) break;
+	}
+	if (results.length < topK) {
+		let supplemented = 0;
+		for (const candidate of topCandidates) {
+			if (results.length >= topK) break;
+			if (rankedIds.includes(candidate.id)) continue;
+			if (seen.has(candidate.chunkId)) continue;
+			seen.add(candidate.chunkId);
+			const result = await store.buildSearchResult(candidate.chunkId, candidate.score, candidate.id);
+			if (result !== void 0) {
+				results.push(result);
+				supplemented += 1;
+			}
+		}
+		if (supplemented > 0) onStep({
+			step: "supplementFromCoarse",
+			detail: `rerank 结果不足，从 coarse rank 残余补 ${supplemented} 个。`,
+			durationMs: 0,
+			payload: { supplemented }
+		});
+	}
+	if (results.length < topK) {
+		const remaining = topK - results.length;
+		const backfill = await timed(onStep, "backfill", `rerank 结果不足，回退到 chunk 向量搜索补 ${remaining} 个。`, () => store.searchChunksByVector(queryVec, { limit: remaining * 2 }), (matches) => ({ backfillCandidates: matches.length }));
+		for (const { chunk, score } of backfill) {
+			if (results.length >= topK) break;
+			if (seen.has(chunk.id)) continue;
+			seen.add(chunk.id);
+			const result = await store.buildSearchResult(chunk.id, score);
+			if (result !== void 0) results.push(result);
+		}
+	}
+	if (results.length === 0) {
+		fallbackReason = "vector retrieval returned no results; used FTS5 keyword fallback";
+		return {
+			results: await ftsFallback(store, query, topK),
+			trace: {
+				steps,
+				rerankedEventTitles,
+				fallbackReason
+			}
+		};
+	}
+	return {
+		results,
+		trace: {
+			steps,
+			rerankedEventTitles,
+			fallbackReason
+		}
+	};
+}
+/** Recall entities by name (LLM-extracted) and by vector similarity. */
+async function recallEntities(store, llm, query, queryVec, useLlm) {
+	const out = /* @__PURE__ */ new Map();
+	if (useLlm) {
+		const queryEntities = await extractQueryEntities(llm, query);
+		for (const { name } of queryEntities) {
+			const matches = await store.findEntitiesByName(name);
+			for (const entity of matches) out.set(entity.id, { id: entity.id });
+		}
+	}
+	const vectorMatches = await store.findEntitiesByVector(queryVec, {
+		limit: 20,
+		threshold: ENTITY_VECTOR_THRESHOLD
+	});
+	for (const { entity } of vectorMatches) out.set(entity.id, { id: entity.id });
+	return Array.from(out.values());
+}
+/** FTS5 keyword fallback when embeddings are unavailable. */
+async function ftsFallback(store, query, topK) {
+	const hits = await store.ftsSearchChunks(query, topK * 2);
+	const results = [];
+	for (const { chunk, score } of hits) {
+		const result = await store.buildSearchResult(chunk.id, score);
+		if (result !== void 0) results.push(result);
+		if (results.length >= topK) break;
+	}
+	return results;
+}
+/** Direct chunk vector search fallback. */
+async function chunkVectorFallback(store, queryVec, topK) {
+	const matches = await store.searchChunksByVector(queryVec, { limit: topK * 2 });
+	const results = [];
+	for (const { chunk, score } of matches) {
+		const result = await store.buildSearchResult(chunk.id, score);
+		if (result !== void 0) results.push(result);
+		if (results.length >= topK) break;
+	}
+	return results;
+}
+//#endregion
+export { classifyEmbeddingFailure as A, rankMemos as B, applyConsolidation as C, parseMemoryMemos as D, buildExitExtractionPrompt as E, createMemoryMemo as F, normalize as G, dirname$1 as H, toSummary as I, resolve$1 as J, parse as K, generateTags as L, createFastEmbedEngine as M, hasEmbeddingModelCache as N, stripMemoryTags as O, probeLocalEmbeddingSupport as P, normalizeTags as R, DreamTracker as S, EXIT_EXTRACTION_SYSTEM_PROMPT as T, isAbsolute$1 as U, basename$1 as V, join$1 as W, splitLargeSection as _, isSupportedFile as a, sharedKnowledgeStoreReady as b, buildExtractionUserPrompt as c, extractQueryEntities as d, parseExtractionResponse as f, estimateTokens as g, chunkText as h, ingestFile as i, clearEmbeddingModelCache as j, MemoryMemoStore as k, extractEventFromChunk as l, chunkMarkdown as m, multiSearchWithTrace as n, ENTITY_TYPES as o, rerankEventsWithLlm as p, relative$1 as q, ingestDirectory as r, EXTRACTION_SYSTEM_PROMPT as s, multiSearch as t, extractJsonFromText as u, stripMarkdown as v, buildConsolidationPlan as w, KnowledgeStore as x, sharedKnowledgeStore as y, buildProjectTagCloud as z };