scream-code 0.18.7 → 0.18.9

package/dist/{src-CQwXASmd.mjs → src-DIVvoAYO.mjs}

@@ -4,14 +4,14 @@ import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
 const __dirname = __cjsShimDirname(__filename);
 import { createHash, randomBytes } from "node:crypto";
-import ro, { mkdir, readFile, readdir, rename, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
+import ro, { mkdir, open, readFile, readdir, rename, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
 import I from "fs";
 import Qr, { EventEmitter } from "events";
 import js, { dirname, parse } from "path";
 import { Buffer as Buffer$1 } from "buffer";
 import Cs from "node:stream";
-import Kt, { createReadStream, existsSync, mkdirSync, rmSync, statSync } from "node:fs";
-import path, { basename, join, posix, win32 } from "node:path";
+import Kt, { createReadStream, existsSync, mkdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import path, { basename, join, posix, resolve, win32 } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { EventEmitter as EventEmitter$1 } from "node:events";
 import { StringDecoder } from "node:string_decoder";
@@ -218,7 +218,7 @@ function computeRelevanceScore(memo, query, usageCount = 0, currentProjectDir, p
 	const ti = intent?.temporalBias ?? .3;
 	const fi = intent?.factualBias ?? .6;
 	const factors = {
-		keywordOverlap: computeKeywordSimilarity(memo, query),
+		keywordOverlap: computeKeywordOverlap(memo, query),
 		recency: computeRecency(memo.recordedAt),
 		usageBoost: Math.min(.3, usageCount * .1),
 		projectBoost: computeProjectBoost(memo.projectDir, currentProjectDir),
@@ -416,7 +416,21 @@ function extractKeywords(text) {
 	return [...new Set(tokens)];
 }
 function computeKeywordSimilarity(memo, query) {
-	const memoWords = extractKeywords(`${memo.userNeed} ${memo.approach} ${memo.whatFailed} ${memo.whatWorked}`);
+	return jaccardSimilarity(keywordText(memo), query);
+}
+/**
+* Ranking variant: the distilled conclusion and the note are separate
+* retrieval surfaces. Score each field on its own and keep the best match —
+* a short conclusion would otherwise be diluted by the long base text.
+*/
+function computeKeywordOverlap(memo, query) {
+	return Math.max(jaccardSimilarity(keywordText(memo), query), jaccardSimilarity(memo.distilled ?? "", query), jaccardSimilarity(memo.note ?? "", query));
+}
+function keywordText(memo) {
+	return `${memo.userNeed} ${memo.approach} ${memo.whatFailed} ${memo.whatWorked}`;
+}
+function jaccardSimilarity(memoText, query) {
+	const memoWords = extractKeywords(memoText);
 	const queryWords = extractKeywords(query);
 	if (memoWords.length === 0 || queryWords.length === 0) return 0;
 	const intersection = memoWords.filter((w) => queryWords.includes(w)).length;
@@ -469,6 +483,10 @@ function createMemoryMemo(partial) {
 		outcome: partial.outcome,
 		whatFailed: partial.whatFailed,
 		whatWorked: partial.whatWorked,
+		distilled: partial.distilled,
+		origin: partial.origin ?? "session",
+		distilledFrom: partial.distilledFrom,
+		distilledAt: partial.distilledAt,
 		extractionSource: partial.extractionSource,
 		recordedAt: partial.recordedAt ?? Date.now(),
 		projectDir: partial.projectDir ?? "",
@@ -490,6 +508,10 @@ function toSummary(memo) {
 		outcome: memo.outcome,
 		whatFailed: memo.whatFailed,
 		whatWorked: memo.whatWorked,
+		distilled: memo.distilled,
+		origin: memo.origin,
+		distilledFrom: memo.distilledFrom,
+		distilledAt: memo.distilledAt,
 		extractionSource: memo.extractionSource,
 		recordedAt: memo.recordedAt,
 		projectDir: memo.projectDir,
@@ -3531,7 +3553,7 @@ function buildEmbeddingText(memo) {
 */
 const engineCache = /* @__PURE__ */ new Map();
 /**
-* Create an embedding engine backed by fastembed.
+* Create an embedding engine backed by the in-process WASM pipeline.
 * 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.
@@ -3539,21 +3561,22 @@ const engineCache = /* @__PURE__ */ new Map();
 *                 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 ?? "";
+function createEmbeddingEngine(cacheDir) {
+	const key = cacheDir === void 0 ? "" : resolve(cacheDir);
 	const cached = engineCache.get(key);
 	if (cached !== void 0) return cached;
-	const engine = createFastEmbedEngineImpl(cacheDir);
+	const engine = createEmbeddingEngineImpl(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) {
+function createEmbeddingEngineImpl(cacheDir) {
 	let embedder = null;
 	let initPromise = null;
 	let loadFailed = false;
 	let lastError;
+	let progressListener;
 	return {
 		modelName: EMBEDDING_MODEL_NAME,
 		get available() {
@@ -3562,6 +3585,9 @@ function createFastEmbedEngineImpl(cacheDir) {
 		get lastError() {
 			return lastError;
 		},
+		setProgressListener(listener) {
+			progressListener = listener;
+		},
 		async embedBatch(texts) {
 			if (!this.available) return null;
 			if (texts.length === 0) return [];
@@ -3598,12 +3624,12 @@ function createFastEmbedEngineImpl(cacheDir) {
 				if (loadFailed || initPromise === null) {
 					loadFailed = false;
 					lastError = void 0;
-					initPromise = loadEmbedder(cacheDir);
+					initPromise = loadEmbeddingRuntime(cacheDir, (progress) => progressListener?.(progress));
 				}
 				embedder = await initPromise;
 				if (embedder === null) {
 					initPromise = null;
-					lastError = "fastembed returned an empty model";
+					lastError = "embedding runtime returned an empty session";
 					return false;
 				}
 				loadFailed = false;
@@ -3618,42 +3644,157 @@ function createFastEmbedEngineImpl(cacheDir) {
 		}
 	};
 }
-async function loadEmbedder(cacheDir) {
-	const { FlagEmbedding, EmbeddingModel } = await import("fastembed");
-	if (cacheDir !== void 0) {
-		mkdirSync(cacheDir, { recursive: true });
-		await ensureEmbeddingModelFiles(cacheDir);
-	}
-	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);
+/** Maximum tokens per text; matches the model's position-embedding limit. */
+const MAX_SEQ_LEN = 512;
+/** Texts per inference batch: 16 × 512 × 512 floats ≈ 16MB of activations. */
+const EMBED_BATCH_SIZE = 16;
+/** Threads for the WASM backend. One keeps resolution deterministic in packaged
+*  builds; `SCREAM_CODE_EMBEDDING_THREADS=4` is the supported opt-in. */
+const EMBEDDING_THREADS_ENV = "SCREAM_CODE_EMBEDDING_THREADS";
+/**
+* Token-level truncation that keeps the sentence boundary tokens.
+*
+* The tokenizer package does not apply the truncation policy itself and the
+* model package ships no truncation config, so this is the only place it can
+* happen. Keeping the head (which starts with `[CLS]`) and re-appending the
+* trailing special token (`[SEP]`) mirrors what a HuggingFace pipeline would
+* produce; slicing the tail off blindly would feed the encoder a sentence that
+* never closes and drift from the reference vectors on long inputs.
+*/
+function truncateEncoded(ids, types) {
+	if (ids.length <= MAX_SEQ_LEN) return {
+		ids: [...ids],
+		types: [...types]
+	};
+	const headSize = MAX_SEQ_LEN - 1;
+	const head = ids.slice(0, headSize);
+	const headTypes = types.slice(0, headSize);
+	return {
+		ids: [...head, ids.at(-1)],
+		types: [...headTypes, types.at(-1)]
+	};
+}
+/**
+* Builds the embedding runtime in-process on `onnxruntime-web` (WASM) and the
+* pure-JS tokenizer. No native binaries, no install scripts: the whole stack is
+* JavaScript plus one WebAssembly artifact resolved from the package.
+*
+* The numeric pipeline is load-bearing and must stay compatible with the
+* reference embeddings of this model: token ids come from `tokenizer.json`, and
+* the sentence vector is the **CLS token** hidden state (`last_hidden_state[0]`)
+* followed by L2 normalization. Mean pooling produces visibly different vectors
+* (cosine ≈ 0.9 against the reference), so pooling is not a stylistic choice.
+*/
+async function createWasmRuntime(modelDir) {
+	const ort = await import("onnxruntime-web");
+	const { Tokenizer } = await import("@huggingface/tokenizers");
+	const requestedThreads = Number(process.env[EMBEDDING_THREADS_ENV]);
+	ort.env.wasm.numThreads = Number.isFinite(requestedThreads) && requestedThreads > 0 ? requestedThreads : 1;
+	ort.env.logLevel = "error";
+	const tokenizer = new Tokenizer(JSON.parse(readFileSync(join(modelDir, "tokenizer.json"), "utf8")), JSON.parse(readFileSync(join(modelDir, "tokenizer_config.json"), "utf8")));
+	const session = await ort.InferenceSession.create(readFileSync(join(modelDir, "model_optimized.onnx")), { executionProviders: ["wasm"] });
+	if (session === null || session === void 0) return null;
+	return { async *embed(textStrings) {
+		if (textStrings.length === 0) return;
+		const encoded = textStrings.map((text, index) => {
+			const encoding = tokenizer.encode(text, { return_token_type_ids: true });
+			const types = encoding.token_type_ids ?? encoding.ids.map(() => 0);
+			const truncated = truncateEncoded(encoding.ids, types);
+			return {
+				index,
+				ids: truncated.ids,
+				types: truncated.types
+			};
+		});
+		const results = Array.from({ length: textStrings.length });
+		const buckets = encoded.toSorted((a, b) => a.ids.length - b.ids.length);
+		for (let start = 0; start < buckets.length; start += EMBED_BATCH_SIZE) {
+			const group = buckets.slice(start, start + EMBED_BATCH_SIZE);
+			const rows = group.length;
+			const width = Math.max(...group.map((entry) => entry.ids.length));
+			const ids = new BigInt64Array(rows * width);
+			const mask = new BigInt64Array(rows * width);
+			const types = new BigInt64Array(rows * width);
+			group.forEach((entry, row) => {
+				for (let column = 0; column < width; column++) {
+					const offset = row * width + column;
+					ids[offset] = BigInt(column < entry.ids.length ? entry.ids[column] : 0);
+					mask[offset] = column < entry.ids.length ? 1n : 0n;
+					types[offset] = BigInt(column < entry.types.length ? entry.types[column] : 0);
+				}
+			});
+			const output = await session.run({
+				input_ids: new ort.Tensor("int64", ids, [rows, width]),
+				attention_mask: new ort.Tensor("int64", mask, [rows, width]),
+				token_type_ids: new ort.Tensor("int64", types, [rows, width])
+			});
+			const hidden = output["last_hidden_state"] ?? output[Object.keys(output)[0]];
+			const hiddenSize = hidden.dims.at(-1);
+			const data = hidden.data;
+			group.forEach((entry, row) => {
+				const rowStart = row * width * hiddenSize;
+				const vector = Array.from(data.subarray(rowStart, rowStart + hiddenSize));
+				let norm = 0;
+				for (const value of vector) norm += value * value;
+				norm = Math.sqrt(norm) || 1;
+				for (let i = 0; i < vector.length; i += 1) vector[i] = vector[i] / norm;
+				results[entry.index] = vector;
+			});
+		}
+		for (let start = 0; start < results.length; start += EMBED_BATCH_SIZE) yield results.slice(start, start + EMBED_BATCH_SIZE);
+	} };
+}
+async function loadEmbeddingRuntime(cacheDir, emit) {
+	if (cacheDir === void 0) {
+		emit?.({ phase: "load" });
+		return createWasmRuntime(join("local_cache", BGESMALLZH_CACHE_NAME));
 	}
+	mkdirSync(cacheDir, { recursive: true });
+	await ensureEmbeddingModelFiles(cacheDir, {
+		onProgress: (received, total) => {
+			emit?.(total === void 0 ? {
+				phase: "download",
+				received
+			} : {
+				phase: "download",
+				received,
+				total
+			});
+		},
+		onPhase: (phase) => {
+			if (phase === "verify") emit?.({ phase: "verify" });
+		}
+	});
+	emit?.({ phase: "load" });
+	return createWasmRuntime(join(cacheDir, BGESMALLZH_CACHE_NAME));
 }
 /**
-* Cache entry names fastembed uses for the fixed BGESmallZH model: it extracts
-* into `<cacheDir>/<name>/` from the staged archive `<cacheDir>/<name>.tar.gz`.
+* Cache entry name for the fixed BGESmallZH model: the staged archive extracts
+* to `<cacheDir>/<name>/` and the runtime loads from that directory.
 */
 const BGESMALLZH_CACHE_NAME = "fast-bge-small-zh-v1.5";
+/** Files the runtime needs before the model can be considered installed. */
+const EMBEDDING_REQUIRED_FILES = [
+	"model_optimized.onnx",
+	"tokenizer.json",
+	"tokenizer_config.json"
+];
 /** Escape hatch for air-gapped installs and tests: points at an archive file. */
 const EMBEDDING_MODEL_URL_ENV = "SCREAM_CODE_EMBEDDING_MODEL_URL";
-function modelWeightsPath(cacheDir) {
-	return join(cacheDir, BGESMALLZH_CACHE_NAME, "model_optimized.onnx");
+/** Default stall guards: a trickling connection must not spin a spinner forever. */
+const DEFAULT_IDLE_TIMEOUT_MS = 6e4;
+const DEFAULT_TOTAL_TIMEOUT_MS = 15 * 6e4;
+/** Progress callback throttle: frequent enough to move, rare enough to be free. */
+const PROGRESS_THROTTLE_MS = 100;
+function modelDirPath(cacheDir) {
+	return join(cacheDir, BGESMALLZH_CACHE_NAME);
 }
 function sha256File(filePath) {
 	return readFile(filePath).then((data) => createHash("sha256").update(data).digest("hex"));
 }
 /**
 * Stage the embedding model files when they are missing: download the pinned
-* archive (HTTP status verified — unlike fastembed's own downloader), extract,
+* archive (HTTP status verified, unlike a naive downloader), extract,
 * and verify the weights payload against the pinned sha256.
 *
 * A partially extracted tree or a hash mismatch is removed so the caller keeps
@@ -3663,62 +3804,149 @@ function sha256File(filePath) {
 async function ensureEmbeddingModelFiles(cacheDir, options) {
 	if (hasEmbeddingModelCache(cacheDir)) return;
 	mkdirSync(cacheDir, { recursive: true });
-	const modelDir = join(cacheDir, BGESMALLZH_CACHE_NAME);
+	const modelDir = modelDirPath(cacheDir);
 	const stagingPath = join(cacheDir, `${BGESMALLZH_CACHE_NAME}.tar.gz.part`);
 	const url = options?.sourceUrl ?? process.env[EMBEDDING_MODEL_URL_ENV] ?? "https://github.com/LIUTod/scream-code/releases/download/embedding-models-v1/fast-bge-small-zh-v1.5.tar.gz";
+	const idleTimeoutMs = options?.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+	const totalTimeoutMs = options?.totalTimeoutMs ?? DEFAULT_TOTAL_TIMEOUT_MS;
+	const controller = new AbortController();
+	const onExternalAbort = () => {
+		controller.abort();
+	};
+	if (options?.signal !== void 0) if (options.signal.aborted) controller.abort();
+	else options.signal.addEventListener("abort", onExternalAbort, { once: true });
+	let idleTimer;
+	const armIdleTimer = () => {
+		if (idleTimer !== void 0) clearTimeout(idleTimer);
+		idleTimer = setTimeout(() => {
+			controller.abort();
+		}, idleTimeoutMs);
+	};
+	const totalTimer = setTimeout(() => {
+		controller.abort();
+	}, totalTimeoutMs);
+	let received = 0;
+	let announcedTotal;
+	let downloadCompleted = false;
+	const announceProgress = () => {
+		options?.onProgress?.(received, announcedTotal);
+	};
 	try {
 		let response;
 		try {
-			response = await fetch(url);
+			armIdleTimer();
+			response = await fetch(url, { signal: controller.signal });
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
 			throw new Error(`fetch failed for ${url}: ${message}`, { cause: error });
 		}
 		if (!response.ok) throw new Error(`model source returned HTTP ${response.status} for ${url}`);
-		await writeFile(stagingPath, Buffer.from(await response.arrayBuffer()));
+		const contentLength = Number(response.headers.get("content-length"));
+		announcedTotal = Number.isFinite(contentLength) && contentLength > 0 ? contentLength : void 0;
+		announceProgress();
+		const body = response.body;
+		if (body === null) throw new Error(`model source returned an empty body for ${url}`);
+		const reader = body.getReader();
+		const abortRejection = new Promise((_, reject) => {
+			if (controller.signal.aborted) {
+				reject(/* @__PURE__ */ new Error("aborted"));
+				return;
+			}
+			controller.signal.addEventListener("abort", () => {
+				reject(/* @__PURE__ */ new Error("aborted"));
+			}, { once: true });
+		});
+		const abortAwareRead = () => Promise.race([reader.read(), abortRejection]);
+		let handle;
+		try {
+			handle = await open(stagingPath, "w");
+		} catch (error) {
+			await reader.cancel().catch(() => void 0);
+			throw error;
+		}
+		let lastProgressAt = 0;
+		try {
+			await (async () => {
+				for (;;) {
+					let chunk;
+					try {
+						chunk = await abortAwareRead();
+					} catch (error) {
+						const message = error instanceof Error ? error.message : String(error);
+						throw new Error(`${message} (received ${received} of ${announcedTotal ?? "?"} bytes): ${url}`, { cause: error });
+					}
+					if (chunk.done) break;
+					const bytes = chunk.value;
+					armIdleTimer();
+					await handle.write(bytes);
+					received += bytes.byteLength;
+					const now = Date.now();
+					if (now - lastProgressAt >= PROGRESS_THROTTLE_MS) {
+						lastProgressAt = now;
+						announceProgress();
+					}
+				}
+				announceProgress();
+				downloadCompleted = true;
+			})();
+		} finally {
+			if (idleTimer !== void 0) clearTimeout(idleTimer);
+			await handle.close();
+			await reader.cancel().catch(() => void 0);
+		}
+		options?.onPhase?.("verify");
 		await So({
 			file: stagingPath,
 			cwd: cacheDir
 		});
-		const weightsPath = modelWeightsPath(cacheDir);
-		if (!existsSync(weightsPath) || statSync(weightsPath).size === 0) throw new Error(`model package did not contain weights after extraction: ${url}`);
-		const sha256 = await sha256File(weightsPath);
+		for (const fileName of EMBEDDING_REQUIRED_FILES) {
+			const target = join(modelDir, fileName);
+			if (!existsSync(target) || statSync(target).size === 0) throw new Error(`model package is missing ${fileName} after extraction: ${url}`);
+		}
+		const sha256 = await sha256File(join(modelDir, "model_optimized.onnx"));
 		const expected = options?.expectedOnnxSha256 ?? "1294ea4b6331115a353d81f96b85e8c8d7fdcc284453d5b2fab5b016230aad38";
 		if (sha256 !== expected) throw new Error(`model weights sha256 mismatch (${sha256.slice(0, 12)}… != ${expected.slice(0, 12)}…): ${url}`);
 	} catch (error) {
-		rmSync(modelDir, {
-			recursive: true,
-			force: true
-		});
-		throw error instanceof Error ? error : new Error(String(error));
+		try {
+			rmSync(modelDir, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+		if (!downloadCompleted && controller.signal.aborted && !(options?.signal?.aborted ?? false)) throw new Error(`model download timed out (received ${received} of ${announcedTotal ?? "?"} bytes): ${url}`, { cause: error });
+		throw error instanceof Error ? error : new Error(String(error), { cause: error });
 	} finally {
+		clearTimeout(totalTimer);
+		if (idleTimer !== void 0) clearTimeout(idleTimer);
+		if (options?.signal !== void 0) options.signal.removeEventListener("abort", onExternalAbort);
 		rmSync(stagingPath, { force: true });
 	}
 }
-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;
+const INSTALL_FAILURE = /Cannot find (?:package|module) '(?:onnxruntime-web|@huggingface\/tokenizers)'|ERR_MODULE_NOT_FOUND|Failed to resolve module specifier/iu;
+const ARCHIVE_FAILURE = /\bTAR_[A-Z_]+|incorrect header check|unexpected end of file|invalid tar|zlib|after extraction|sha256 mismatch/iu;
+const NETWORK_FAILURE = /\b(?:ENOTFOUND|EAI_AGAIN|ETIMEDOUT|ECONNRESET|ECONNREFUSED|EHOSTUNREACH|socket hang up|fetch failed)\b|network error|HTTP \d{3}|timed out|empty body/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.
+* Classify a load failure so callers can say something true about it: an
+* incomplete install, a corrupt cache, a network problem and anything else need
+* four different answers, 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 (INSTALL_FAILURE.test(message)) return "install";
 	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.
+* Loads both runtime packages — no model download — so callers can tell "this
+* installation cannot run the local model at all" apart from "the download
+* failed". The runtime is JavaScript plus WebAssembly, so a failure here is an
+* incomplete installation rather than an unsupported platform.
 */
 async function probeLocalEmbeddingSupport() {
 	try {
-		await import("fastembed");
+		await import("onnxruntime-web");
+		await import("@huggingface/tokenizers");
 		return { supported: true };
 	} catch (error) {
 		return {
@@ -3729,15 +3957,11 @@ async function probeLocalEmbeddingSupport() {
 }
 /**
 * Remove every trace of a previous BGESmallZH download: the extracted model
-* directory *and* the staged archive it came from.
+* directory and the legacy staged archive name.
 *
-* 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.
+* The legacy `<name>.tar.gz` file is still swept because older versions staged
+* the archive under that name; leaving it behind would waste 55MB per doomed
+* attempt. Our own downloader stages `.tar.gz.part` and always removes it.
 *
 * 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.
@@ -3755,48 +3979,19 @@ function clearEmbeddingModelCache(cacheDir) {
 	}
 }
 /**
-* 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.
+* True when every file the runtime needs is already on disk. Loading then never
+* downloads, so callers can safely trigger a local load without risking a
+* surprise mid-query download. All required files are checked (not just the
+* weights): a partially restored cache must count as missing so the setup flow
+* repairs it instead of failing at load time.
 */
 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 modelDir = modelDirPath(cacheDir);
+	if (!existsSync(modelDir)) return false;
+	return EMBEDDING_REQUIRED_FILES.every((fileName) => {
 		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 {}
-	}
+		return existsSync(target) && statSync(target).size > 0;
+	});
 }
 //#endregion
 //#region ../../packages/memory/src/store.ts
@@ -3940,7 +4135,19 @@ var MemoryMemoStore = class MemoryMemoStore {
          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);
+		const rows = projectDir === void 0 ? stmt.all(ftsQuery, limit) : stmt.all(ftsQuery, projectDir, limit);
+		const like = likePattern(query);
+		const remaining = Math.max(0, limit - rows.length);
+		const extraRows = remaining === 0 ? [] : projectDir === void 0 ? this.db.prepare("SELECT * FROM memos WHERE distilled LIKE ? ESCAPE '\\' OR note LIKE ? ESCAPE '\\' ORDER BY recorded_at DESC LIMIT ?").all(like, like, remaining) : this.db.prepare("SELECT * FROM memos WHERE (distilled LIKE ? ESCAPE '\\' OR note LIKE ? ESCAPE '\\') AND (project_dir = ? OR project_dir = '') ORDER BY recorded_at DESC LIMIT ?").all(like, like, projectDir, remaining);
+		const seen = new Set(rows.map((row) => String(row["id"])));
+		const merged = rows.map(rowToMemo);
+		for (const row of extraRows) {
+			const id = String(row["id"]);
+			if (seen.has(id)) continue;
+			seen.add(id);
+			merged.push(rowToMemo(row));
+		}
+		return merged;
 	}
 	/** List memos with optional full-text search and pagination. */
 	async list(options) {
@@ -4082,7 +4289,12 @@ var MemoryMemoStore = class MemoryMemoStore {
         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 '[]'
+        tags TEXT NOT NULL DEFAULT '[]',
+        note TEXT,
+        distilled TEXT NOT NULL DEFAULT '',
+        origin TEXT NOT NULL DEFAULT 'session',
+        distilled_from TEXT,
+        distilled_at INTEGER
       );
 
       CREATE INDEX IF NOT EXISTS idx_memos_project_dir ON memos(project_dir);
@@ -4112,6 +4324,14 @@ var MemoryMemoStore = class MemoryMemoStore {
 		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 '[]'");
+		if (!info.some((col) => col.name === "note")) this.db.exec("ALTER TABLE memos ADD COLUMN note TEXT");
+		if (!info.some((col) => col.name === "distilled")) this.db.exec("ALTER TABLE memos ADD COLUMN distilled TEXT NOT NULL DEFAULT ''");
+		if (!info.some((col) => col.name === "origin")) {
+			this.db.exec("ALTER TABLE memos ADD COLUMN origin TEXT NOT NULL DEFAULT 'session'");
+			this.db.exec("UPDATE memos SET origin = 'dream' WHERE distilled <> ''");
+		}
+		if (!info.some((col) => col.name === "distilled_from")) this.db.exec("ALTER TABLE memos ADD COLUMN distilled_from TEXT");
+		if (!info.some((col) => col.name === "distilled_at")) this.db.exec("ALTER TABLE memos ADD COLUMN distilled_at INTEGER");
 		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);
@@ -4155,15 +4375,16 @@ var MemoryMemoStore = class MemoryMemoStore {
 		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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        outcome, what_failed, what_worked, extraction_source, recorded_at, project_dir, tags,
+        note, distilled, origin, distilled_from, distilled_at
+      ) 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 ?? []));
+				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 ?? []), memo.note ?? null, memo.distilled ?? "", memo.origin ?? "session", stringifyDistilledFrom(memo.distilledFrom), memo.distilledAt ?? null);
 				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 ?? ""));
 			}
@@ -4178,14 +4399,15 @@ var MemoryMemoStore = class MemoryMemoStore {
 		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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        outcome, what_failed, what_worked, extraction_source, recorded_at, project_dir, tags,
+        note, distilled, origin, distilled_from, distilled_at
+      ) 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 ?? []));
+			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 ?? []), entry.note ?? null, entry.distilled ?? "", entry.origin ?? "session", stringifyDistilledFrom(entry.distilledFrom), entry.distilledAt ?? null);
 			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);
@@ -4221,7 +4443,12 @@ var MemoryMemoStore = class MemoryMemoStore {
         extraction_source = ?,
         recorded_at = ?,
         project_dir = ?,
-        tags = ?
+        tags = ?,
+        note = ?,
+        distilled = ?,
+        origin = ?,
+        distilled_from = ?,
+        distilled_at = ?
       WHERE id = ?
       RETURNING rowid`);
 		const updateFts = this.db.prepare(`INSERT INTO memos_fts(rowid, user_need, approach, what_failed, what_worked, source_session_title)
@@ -4235,7 +4462,7 @@ var MemoryMemoStore = class MemoryMemoStore {
 				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);
+			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 ?? []), updated.note ?? null, updated.distilled ?? "", updated.origin ?? "session", stringifyDistilledFrom(updated.distilledFrom), updated.distilledAt ?? null, id);
 			if (row === void 0) {
 				this.db.exec("ROLLBACK");
 				return false;
@@ -4483,6 +4710,9 @@ var MemoryMemoStore = class MemoryMemoStore {
 function rowToMemo(row) {
 	const sourceSessionTitle = row["source_session_title"];
 	const projectDir = row["project_dir"];
+	const distilled = row["distilled"];
+	const note = row["note"];
+	const distilledAt = row["distilled_at"];
 	return {
 		id: String(row["id"]),
 		sourceSessionId: String(row["source_session_id"]),
@@ -4492,12 +4722,36 @@ function rowToMemo(row) {
 		outcome: String(row["outcome"]),
 		whatFailed: String(row["what_failed"]),
 		whatWorked: String(row["what_worked"]),
+		distilled: typeof distilled === "string" && distilled.trim().length > 0 ? distilled : void 0,
+		origin: parseOrigin(row["origin"]),
+		distilledFrom: parseDistilledFrom(row["distilled_from"]),
+		distilledAt: typeof distilledAt === "number" && Number.isFinite(distilledAt) ? distilledAt : void 0,
 		extractionSource: row["extraction_source"],
 		recordedAt: Number(row["recorded_at"]),
 		projectDir: typeof projectDir === "string" ? projectDir : "",
-		tags: parseTags(row["tags"])
+		tags: parseTags(row["tags"]),
+		note: typeof note === "string" && note.length > 0 ? note : void 0
 	};
 }
+function parseOrigin(value) {
+	return value === "dream" || value === "user" || value === "session" ? value : "session";
+}
+/** Column value for `distilled_from`: undefined when there is nothing to store. */
+function stringifyDistilledFrom(sources) {
+	return sources === void 0 || sources.length === 0 ? null : JSON.stringify(sources);
+}
+/** Parse the `distilled_from` JSON column, dropping entries that fail validation. */
+function parseDistilledFrom(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 sources = parsed.filter((item) => typeof item === "object" && item !== null && typeof item.id === "string" && typeof item.title === "string" && typeof item.at === "number" && Number.isFinite(item.at));
+		return sources.length > 0 ? sources.slice(0, 100) : void 0;
+	} catch {
+		return;
+	}
+}
 function parseTags(value) {
 	if (typeof value !== "string" || value.length === 0) return void 0;
 	try {
@@ -4509,12 +4763,17 @@ function parseTags(value) {
 		return;
 	}
 }
+function likePattern(value) {
+	return `%${value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_")}%`;
+}
 function memoMatchesSearch(memo, search) {
 	return [
 		memo.userNeed,
 		memo.approach,
 		memo.whatFailed,
 		memo.whatWorked,
+		memo.distilled ?? "",
+		memo.note ?? "",
 		memo.sourceSessionTitle ?? "",
 		...memo.tags ?? []
 	].join(" ").toLowerCase().replaceAll(/\s+/g, "").includes(search.replaceAll(/\s+/g, ""));
@@ -4688,6 +4947,7 @@ async function buildConsolidationPlan(store, options) {
 async function applyConsolidation(store, plan) {
 	let deleted = 0;
 	let created = 0;
+	let skipped = 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("; ");
@@ -4726,9 +4986,22 @@ async function applyConsolidation(store, plan) {
 			created++;
 		}
 	}
+	const mergeableGroups = [];
 	for (const group of plan.duplicateGroups) {
+		const distilledText = (group.merged.distilled ?? "").trim();
+		if (distilledText.length === 0 && group.memos.some(isDistilledRule)) {
+			skipped++;
+			continue;
+		}
+		mergeableGroups.push({
+			group,
+			distilledText
+		});
+	}
+	for (const { group, distilledText } of mergeableGroups) {
 		const newest = group.memos.reduce((a, b) => a.recordedAt > b.recordedAt ? a : b);
 		const mergedTags = normalizeTags(group.memos.flatMap((m) => m.tags ?? []));
+		const mergedNotes = [...new Set(group.memos.map((memo) => memo.note?.trim() ?? "").filter((note) => note.length > 0))];
 		const merged = createMemoryMemo({
 			sourceSessionId: newest.sourceSessionId,
 			sourceSessionTitle: newest.sourceSessionTitle,
@@ -4737,14 +5010,19 @@ async function applyConsolidation(store, plan) {
 			outcome: group.merged.outcome,
 			whatFailed: group.merged.whatFailed,
 			whatWorked: group.merged.whatWorked,
+			note: mergedNotes.length > 0 ? mergedNotes.join("; ") : void 0,
 			tags: group.merged.tags ?? mergedTags,
+			distilled: distilledText.length > 0 ? distilledText : void 0,
 			projectDir: newest.projectDir,
-			extractionSource: "compaction"
+			extractionSource: "compaction",
+			origin: "dream",
+			distilledAt: distilledText.length > 0 ? Date.now() : void 0,
+			distilledFrom: collectLineage(group.memos)
 		});
 		await store.append(merged);
 		created++;
 	}
-	for (const group of plan.duplicateGroups) for (const memo of group.memos) {
+	for (const { group } of mergeableGroups) for (const memo of group.memos) {
 		await store.delete(memo.id);
 		deleted++;
 	}
@@ -4758,9 +5036,31 @@ async function applyConsolidation(store, plan) {
 	}
 	return {
 		deleted,
-		created
+		created,
+		skipped
 	};
 }
+/**
+* Build the lineage snapshot for a merged memo: every source memo in the group
+* plus each source's own lineage, deduped by id so a rule distilled from other
+* rules keeps its whole ancestry. Sorted oldest-first and capped at 100.
+*/
+function collectLineage(memos) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const memo of memos) {
+		if (!seen.has(memo.id)) seen.set(memo.id, {
+			id: memo.id,
+			title: clip(memo.userNeed, 80),
+			at: memo.recordedAt
+		});
+		for (const source of memo.distilledFrom ?? []) if (!seen.has(source.id)) seen.set(source.id, source);
+	}
+	return [...seen.values()].toSorted((a, b) => a.at - b.at).slice(-100);
+}
+function clip(text, maxLength) {
+	const chars = Array.from(text);
+	return chars.length <= maxLength ? text : chars.slice(0, maxLength).join("");
+}
 function findDuplicateGroups(memos) {
 	const groups = [];
 	const used = /* @__PURE__ */ new Set();
@@ -4839,7 +5139,8 @@ function buildDuplicateGroup(cluster) {
 			approach: `合并 ${cluster.length} 条相关记录。最新方案: ${newest.approach}`,
 			outcome: bestOutcome,
 			whatFailed: failures.size > 0 ? [...failures].join("; ") : "none",
-			whatWorked: successes.size > 0 ? [...successes].join("; ") : "none"
+			whatWorked: successes.size > 0 ? [...successes].join("; ") : "none",
+			distilled: ""
 		},
 		reason: `发现 ${cluster.length} 条相似记录（关键词重叠 > ${Math.round(SIMILARITY_THRESHOLD * 100)}%）`
 	};
@@ -4902,12 +5203,19 @@ function isOutcomeCompleted(outcome) {
 	const lower = outcome.toLowerCase();
 	return lower.includes("完成") || lower.includes("done") || lower.includes("completed") || lower.includes("成功") || lower.includes("success");
 }
+/**
+* A distilled rule is not a stale experience: pruning it by age would delete
+* the conclusion /dream exists to accumulate.
+*/
+function isDistilledRule(memo) {
+	return memo.origin === "dream" || memo.origin === "user" || (memo.distilled ?? "").trim().length > 0;
+}
 function findResolved(memos) {
-	return memos.filter((m) => isOutcomeCompleted(m.outcome) && Date.now() - m.recordedAt > 10080 * 60 * 1e3);
+	return memos.filter((m) => !isDistilledRule(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"));
+	return memos.filter((m) => !isDistilledRule(m) && m.recordedAt < threshold && !isOutcomeCompleted(m.outcome) && !m.outcome.includes("blocked"));
 }
 //#endregion
 //#region ../../packages/memory/src/dream.ts
@@ -5977,7 +6285,7 @@ function entryFor(homeDir) {
 				await store.init();
 				const cacheDir = join$1(homeDir, "cache", "fastembed");
 				mkdirSync(cacheDir, { recursive: true });
-				store.setEmbeddingEngine(createFastEmbedEngine(cacheDir));
+				store.setEmbeddingEngine(createEmbeddingEngine(cacheDir));
 			} catch (error) {
 				entries.delete(homeDir);
 				throw error;
@@ -5994,7 +6302,7 @@ function entryFor(homeDir) {
 *
 * 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.
+* createEmbeddingEngine call site: same string → same engine instance.
 */
 function sharedKnowledgeStore(homeDir) {
 	return entryFor(homeDir).store;
@@ -6008,7 +6316,7 @@ function sharedKnowledgeStoreReady(homeDir) {
 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
+* Soft cap on chunk token count. BGE-small-zh-v1.5 (the embedding 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.
@@ -6544,14 +6852,78 @@ async function embedOrNulls(engine, texts, skipEmbedding) {
 }
 /** LLM concurrency for extraction — callers and comments below refer to this constant. */
 const LLM_CONCURRENCY = 20;
-const SUPPORTED_EXTENSIONS = new Set([
+/** Formats read directly as UTF-8 text. */
+const TEXT_EXTENSIONS = new Set([
 	".md",
 	".markdown",
 	".txt"
 ]);
-/** Read a file and return its content. */
-async function readFileContent(filePath) {
-	return readFile(filePath, "utf-8");
+/**
+* Binary documents run through the markit converter (they become Markdown,
+* then take the exact same chunking/embedding path as a `.md` file).
+*/
+const DOCUMENT_EXTENSIONS = new Set([
+	".pdf",
+	".docx",
+	".xlsx"
+]);
+const SUPPORTED_EXTENSIONS = new Set([...TEXT_EXTENSIONS, ...DOCUMENT_EXTENSIONS]);
+/**
+* Hard ceiling for a converted document. Every chunk costs one LLM extraction
+* call, so an unbounded PDF would silently turn into hundreds of requests.
+*/
+const MAX_DOCUMENT_BYTES = 50 * 1024 * 1024;
+/** Lazily-loaded converter instance: only binary ingests pay the import cost. */
+let markitPromise;
+function getMarkit() {
+	markitPromise ??= import("./markit-CV3BXOV_.mjs").then(({ Markit }) => new Markit()).catch((error) => {
+		markitPromise = void 0;
+		throw error;
+	});
+	return markitPromise;
+}
+/**
+* The converters record images as `<!-- image: id (page N, WxHpt) -->` when
+* they are not asked to write them out. Those comments carry no searchable
+* meaning and would otherwise burn tokens in every chunk they land in.
+*/
+function stripImagePlaceholders(markdown) {
+	return markdown.replaceAll(/<!--\s*image:[^>]*-->/g, "").replaceAll(/\n{3,}/g, "\n\n").trim();
+}
+/**
+* Read a source file and fingerprint it.
+*
+* Text files hash the decoded string — exactly what the previous
+* `sha256(readFile(path, 'utf-8'))` produced, so existing `contentHash` values
+* keep matching even for non-UTF-8 text. Binary files hash the raw bytes, which
+* stays stable across converter upgrades.
+*/
+async function readSource(filePath) {
+	const ext = getFileExtension(filePath);
+	if (!TEXT_EXTENSIONS.has(ext)) {
+		const { size } = await stat(filePath);
+		if (size > MAX_DOCUMENT_BYTES) throw new Error(`文档超过 ${MAX_DOCUMENT_BYTES / 1024 / 1024}MB 上限，已跳过: ${basename$1(filePath)}`);
+	}
+	const bytes = await readFile(filePath);
+	return {
+		bytes,
+		ext,
+		contentHash: TEXT_EXTENSIONS.has(ext) ? createHash("sha256").update(bytes.toString("utf8")).digest("hex") : createHash("sha256").update(bytes).digest("hex")
+	};
+}
+/**
+* Convert a binary document to Markdown. Only called once the bytes are known
+* to be new or changed — an unchanged PDF is never re-parsed.
+*/
+async function convertSource(filePath, bytes, ext, onConverting) {
+	onConverting?.(basename$1(filePath));
+	const { markdown } = await (await getMarkit()).convert(bytes, {
+		extension: ext,
+		filename: basename$1(filePath)
+	});
+	const content = stripImagePlaceholders(markdown ?? "");
+	if (content.length === 0) throw new Error(ext === ".pdf" ? "文档未提取到文字（可能是扫描版 PDF），本功能不含 OCR" : "文档未提取到可索引的文字，文件可能已损坏或为空");
+	return content;
 }
 function getFileExtension(filePath) {
 	const lastDot = filePath.lastIndexOf(".");
@@ -6619,6 +6991,10 @@ async function ensureEmbeddingModelMatches(store, engine) {
 * Reports progress via callback.
 */
 async function ingestFile(store, llm, filePath, onProgress) {
+	if (!isSupportedFile(filePath)) {
+		const ext = getFileExtension(filePath);
+		throw new Error(`不支持的文件类型: ${ext === "" ? "(无扩展名)" : ext}`);
+	}
 	const engine = store.getEmbeddingEngine();
 	const skipEmbed = engine === void 0 || !engine.available;
 	if (skipEmbed) onProgress?.({
@@ -6630,8 +7006,7 @@ async function ingestFile(store, llm, filePath, onProgress) {
 		stage: "chunking",
 		message: `读取并切分文件: ${basename$1(filePath)}`
 	});
-	const content = await readFileContent(filePath);
-	const contentHash = createHash("sha256").update(content).digest("hex");
+	const { bytes, ext, contentHash } = await readSource(filePath);
 	const existing = await store.findSourceByFilePath(filePath);
 	let replacedOldVersion = false;
 	if (existing !== void 0) {
@@ -6653,10 +7028,18 @@ async function ingestFile(store, llm, filePath, onProgress) {
 			stage: "chunking",
 			message: `检测到内容变更，替换旧版本: ${existing.name}`
 		});
+	}
+	const content = TEXT_EXTENSIONS.has(ext) ? bytes.toString("utf8") : await convertSource(filePath, bytes, ext, (file) => {
+		onProgress?.({
+			stage: "converting",
+			message: file
+		});
+	});
+	if (existing !== void 0) {
 		await store.deleteSource(existing.id);
 		replacedOldVersion = true;
 	}
-	const sections = chunkContent(content, getFileExtension(filePath));
+	const sections = chunkContent(content, ext);
 	store.beginTransaction();
 	try {
 		if (sections.length === 0) {
@@ -6860,6 +7243,7 @@ async function collectSupportedFiles(dirPath) {
 	const files = [];
 	const entries = await readdir(dirPath, { withFileTypes: true });
 	for (const entry of entries) {
+		if (entry.name.startsWith(".") || entry.name.startsWith("~$")) continue;
 		const fullPath = join$1(dirPath, entry.name);
 		if (entry.isDirectory()) files.push(...await collectSupportedFiles(fullPath));
 		else if (entry.isFile() && isSupportedFile(fullPath)) files.push(fullPath);
@@ -6868,7 +7252,7 @@ async function collectSupportedFiles(dirPath) {
 }
 async function ingestDirectory(store, llm, dirPath, onProgress) {
 	const files = await collectSupportedFiles(dirPath);
-	if (files.length === 0) throw new Error(`目录下没有支持的文件 (.md, .markdown, .txt): ${dirPath}`);
+	if (files.length === 0) throw new Error(`目录下没有支持的文件 (${[...SUPPORTED_EXTENSIONS].join(", ")}): ${dirPath}`);
 	const errors = [];
 	let succeeded = 0;
 	let created = 0;
@@ -6880,6 +7264,10 @@ async function ingestDirectory(store, llm, dirPath, onProgress) {
 	for (let i = 0; i < files.length; i++) {
 		const filePath = files[i];
 		const fileProgress = (progress) => {
+			if (progress.stage === "converting") {
+				onProgress?.(progress);
+				return;
+			}
 			const prefix = `批量摄入 ${i + 1}/${files.length}: ${basename$1(filePath)}`;
 			onProgress?.({
 				...progress,
@@ -7254,4 +7642,4 @@ async function chunkVectorFallback(store, queryVec, topK) {
 	return results;
 }
 //#endregion
-export { sharedMemoStore as A, buildProjectTagCloud as B, applyConsolidation as C, parseMemoryMemos as D, buildExitExtractionPrompt as E, probeLocalEmbeddingSupport as F, join$1 as G, basename$1 as H, createMemoryMemo as I, relative$1 as J, normalize as K, toSummary as L, clearEmbeddingModelCache as M, createFastEmbedEngine as N, stripMemoryTags as O, hasEmbeddingModelCache as P, generateTags as R, DreamTracker as S, EXIT_EXTRACTION_SYSTEM_PROMPT as T, dirname$2 as U, rankMemos as V, isAbsolute$1 as W, resolve$1 as Y, 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, classifyEmbeddingFailure as j, MemoryMemoStore as k, extractEventFromChunk as l, chunkMarkdown as m, multiSearchWithTrace as n, ENTITY_TYPES as o, rerankEventsWithLlm as p, parse$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, normalizeTags as z };
+export { sharedMemoStore as A, buildProjectTagCloud as B, applyConsolidation as C, parseMemoryMemos as D, buildExitExtractionPrompt as E, probeLocalEmbeddingSupport as F, join$1 as G, basename$1 as H, createMemoryMemo as I, relative$1 as J, normalize as K, toSummary as L, clearEmbeddingModelCache as M, createEmbeddingEngine as N, stripMemoryTags as O, hasEmbeddingModelCache as P, generateTags as R, DreamTracker as S, EXIT_EXTRACTION_SYSTEM_PROMPT as T, dirname$2 as U, rankMemos as V, isAbsolute$1 as W, resolve$1 as Y, 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, classifyEmbeddingFailure as j, MemoryMemoStore as k, extractEventFromChunk as l, chunkMarkdown as m, multiSearchWithTrace as n, ENTITY_TYPES as o, rerankEventsWithLlm as p, parse$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, normalizeTags as z };