@avantf/dsh-mem 0.4.0 → 0.4.2

package/lib/index.js

@@ -96,6 +96,16 @@ const DEGRADED_WEIGHTS = {
 	fts: .65,
 	jaccard: .35
 };
+/**
+* The human/model-facing sentence a caller renders when {@link RecallResult.degraded} is true (方案 G).
+*
+* The signal itself is the EXISTING `degraded` flag — this constant adds NO field and no new state,
+* it only spells out what that flag means so the tool output, the CLI and the panel say the same
+* thing instead of each keeping its own copy. Deliberately not awaited on a model warm-up: the
+* three-stage prewarm gate keeps the model off the first screen, so a cold semantic leg is annotated,
+* never waited for.
+*/
+const DEGRADED_LEG_NOTE = "本次仅词法腿，语义腿未就绪（语义后端不可用，结果只来自 FTS 与实体腿）。";
 //#endregion
 //#region ../contract/lib/config.js
 /**
@@ -106,12 +116,24 @@ const DEGRADED_WEIGHTS = {
 const maxInputTokens = z.number().int().nonnegative().default(0);
 const semanticSchema = z.object({
 	backend: z.string().default("local_bge"),
-	local_model: z.string().default("Xenova/bge-small-zh-v1.5"),
-	dim: z.number().int().positive().default(512),
+	local_model: z.string().default("Xenova/bge-base-zh-v1.5"),
+	dim: z.number().int().positive().default(768),
 	max_input_tokens: maxInputTokens,
 	mirror: z.string().default("https://hf-mirror.com"),
 	cache_dir: z.string().default(""),
-	auto_download: z.boolean().default(true)
+	auto_download: z.boolean().default(true),
+	/**
+	* Migrate persisted vectors that belong to an OLDER vector space (a changed model or width) in a
+	* bounded background pass. Default ON: changing the embedding space IS a data migration, and
+	* without this the semantic leg silently skips every old-space vector while lexical+entity keep
+	* answering — measured on the real library after the 512→768 default-model swap, 78 of 80 ACTIVE
+	* facts became semantically unreachable with no error anywhere.
+	*
+	* Off = the loud startup warning and the manual entry (`vectors --fix` / `mem_admin vectors_fix`)
+	* stay, but nothing re-encodes on its own. Set to `false` on a metered/embedded host that must not
+	* spend CPU on background re-encoding.
+	*/
+	auto_migrate: z.boolean().default(true)
 });
 const rerankSchema = z.object({
 	backend: z.string().default("none"),
@@ -126,23 +148,26 @@ const vectorStoreSchema = z.object({
 	/**
 	* Vector counts at which `backend: auto` migrates to an ANN index.
 	*
-	* Measured with `node scripts/bench-vstore.mjs` (2000 and 8000 uniform-random vectors, dim 512,
-	* k=50): at 2000 the brute-force store answers in a few ms and hnswlib in under 1 ms
-	* (3.3 ms → 0.83 ms on the machine that measured it; the RATIO moves with the CPU, so compare
-	* your own run of the script rather than this pair) at recall 0.999, so migrating there is both
-	* worthwhile and nearly exact. Two reasons not to lower
-	* it: the native index takes ~0.9 s to BUILD (paid on the upgrade and on every batch eviction,
-	* i.e. on the write path), and below a few hundred vectors brute force is already
-	* sub-millisecond. At 8000 recall falls to 0.89, so for a larger corpus raise
+	* Measured with `node scripts/bench-vstore.mjs` at the shipped width (**dim 768**, k=50,
+	* uniform-random vectors = the ANN worst case): at 2000 the brute-force store answers in 3.3 ms
+	* and hnswlib in 1.0 ms (recall 0.9987) while the native index takes **1.17 s** to BUILD; at
+	* 8000 it is 14.3 ms → 2.5 ms at recall 0.864 (build 10.7 s). The earlier dim-512 run was
+	* 2.5 ms → 0.7 ms at recall 0.9993 / build 0.83 s — the RATIO moves with the CPU, so compare your
+	* own run of the script rather than these pairs. Migrating at 2000 is both worthwhile and nearly
+	* exact. Two reasons not to lower
+	* it: the native index build is paid on the upgrade and on every batch eviction,
+	* i.e. on the write path, and below a few hundred vectors brute force is already
+	* millisecond-scale. Recall falls as the corpus grows, so for a larger corpus raise
 	* `hnswlib_ef_search` (or accept the loss) instead of moving this threshold.
 	*/
 	auto_thresholds: z.object({ hnswlib: z.number().int().positive().default(2e3) }).default({ hnswlib: 2e3 }),
 	/**
 	* ANN search beam width (`ef`). This is the recall/speed knob of the hnswlib index, and it is
-	* NOT optional in practice: the library's own default (10) returned 0.45 of the true top-10 in
-	* a measured benchmark at dim 512, while 256 returned 1.00 at ~0.7 ms per query (brute force:
-	* ~3 ms at n=2000). Recall falls as the corpus grows, so raise this before raising
-	* `auto_thresholds.hnswlib`. The store uses `max(ef_search, 8 × k)`.
+	* NOT optional in practice: the library's own narrow default returned only 0.29 of the true
+	* top-10 in a measured benchmark at the shipped dim 768 (0.36 at dim 512), while 256 returned
+	* 0.99 at 0.72 ms per query (brute force: 3.3 ms at n=2000, dim 768). Recall falls as the corpus
+	* grows (at n=8000 / dim 768, R@10 is 0.86 at `ef=256` and 0.91 at `ef=400`), so raise this before
+	* raising `auto_thresholds.hnswlib`. The store uses `max(ef_search, 8 × k)`.
 	*/
 	hnswlib_ef_search: z.number().int().min(16).max(2048).default(256)
 });
@@ -165,7 +190,7 @@ const retrieverSchema = z.object({
 	* the fused number is relative to the query and cannot carry an absolute cutoff (DESIGN §7 /
 	* §20.19). A score EQUAL to the floor is kept — only strictly-lower candidates are dropped.
 	*
-	* The default is calibrated for the shipped embedder (`Xenova/bge-small-zh-v1.5`, dim 512,
+	* The default is calibrated for the shipped embedder (`Xenova/bge-base-zh-v1.5`, dim 768,
 	* mean-pooled AND normalized). A different model is a different cosine scale: re-measure before
 	* keeping 0.5 (see DESIGN §20.19).
 	*/
@@ -353,7 +378,7 @@ const KnowledgeConfigSchema = z.object({
 	]),
 	/**
 	* Characters per chunk, derived from the SHIPPED model's window rather than chosen by feel:
-	* `bge-small-zh-v1.5` reads {@link DEFAULT_MODEL_WINDOW_TOKENS} tokens and Chinese costs
+	* `bge-base-zh-v1.5` reads {@link DEFAULT_MODEL_WINDOW_TOKENS} tokens and Chinese costs
 	* ~1 token per character, so ~510 characters fit minus the two wrapper tokens; 500 leaves
 	* room and keeps the number round. Longer chunks are not
 	* rejected — the embedder bounds them and warns once — but their tail would only reach the
@@ -1400,9 +1425,10 @@ const DEFAULT_COMMON_CONFIG = `# avantf-mem 公共配置（分层第②层）。
 
 # semantic:                           # 嵌入后端（记忆与知识共用，跨库分数才可比）
 #   backend: local_bge
-#   local_model: Xenova/bge-small-zh-v1.5   # 必须是 ONNX 仓库
-#   dim: 512
+#   local_model: Xenova/bge-base-zh-v1.5    # 必须是 ONNX 仓库
+#   dim: 768
 #   auto_download: true
+#   auto_migrate: true                # 换模型/宽度后自动分批重算旧空间的向量（默认开）；关掉只剩启动告警 + vectors --fix
 #   ⚠️ cache_dir / mirror 由家族底座 @avantf/dsh-plugin-base 管理：写在这里会被忽略并告警。
 #      缓存目录用环境变量 AVANTF_MEM_MODEL_CACHE，镜像用 AVANTF_MEM_MODEL_MIRROR（或 HF_ENDPOINT）。
 
@@ -1422,7 +1448,7 @@ const DEFAULT_COMMON_CONFIG = `# avantf-mem 公共配置（分层第②层）。
 #   weight_jaccard: 0.15
 #   # 绝对门槛打在每条腿的原始分上、fuse() 之前（融合分只在一次查询内可比，不能当门槛）。
 #   # 0 = 关闭该门槛；分数等于门槛保留。语义后端不可用时 min_fts_terms 的生效值放宽到 1。
-#   min_semantic_similarity: 0.5      # 语义腿余弦；0.5 只对 bge-small-zh-v1.5/512 标定过，换模型要重标
+#   min_semantic_similarity: 0.5      # 语义腿余弦；0.5 只对 bge-base-zh-v1.5/768（mean pooling）标定过，换模型要重标
 #   min_fts_terms: 2                  # FTS 腿：这一行命中几个不同的查询词元（拉丁词≥5字符 + CJK 3-gram）
 #   min_jaccard: 0.2                  # 实体腿 Jaccard 比值
 
@@ -3799,7 +3825,7 @@ function round(value, digits) {
 * Token budgets for every MODEL-FACING text path (embedder input, reranker pair, retrieval
 * output). See DESIGN §20.
 *
-* Why this exists: the shipped ONNX models have a hard input window (`bge-small-zh-v1.5` and
+* Why this exists: the shipped ONNX models have a hard input window (`bge-base-zh-v1.5` and
 * `bge-reranker-base`: 512 tokens) and transformers.js truncates SILENTLY past it —
 * `feature-extraction` and `text-classification` both tokenize with `truncation: true` and
 * default `max_length` to the tokenizer's `model_max_length`. A Chinese chunk of 800
@@ -6734,16 +6760,117 @@ function probeTerms(text, holds, stopAt = Number.POSITIVE_INFINITY) {
 	};
 }
 //#endregion
+//#region ../core/lib/store/self_query.js
+/**
+* Query-side SELF-REFERENCE rewriting (方案 A, `mem/docs/SELF_QUERY_RELEVANCE.md` §4-A).
+*
+* THE PROBLEM. The corpus writes the user in the THIRD person ("用户的名字是…"), the user asks in
+* the FIRST ("我是谁？" / "我的名字"). On the measured model that costs 0.15–0.24 of cosine and,
+* worse, the two sides share NO lexical term — so the FTS and entity legs contribute exactly
+* nothing and the semantic leg has to carry the whole decision. Rewriting the query onto the
+* canonical third-person form the corpus is written in is the one measured change that lifts this
+* family of questions over the strict bar (0.685 / 0.677 / 0.626 vs 0.476 / 0.459 / 0.420).
+*
+* WHAT THIS MODULE IS, AND IS NOT. A pure string table: cues (substrings) → ONE canonical rewrite.
+* No model, no tokenizer, no await, no I/O — that is what lets the SAME table serve the synchronous
+* conditional hint (`runtime.relevance`, 方案 A②) and the async retrieval path (`store/hybrid.ts`).
+*
+* WHY THE TABLE IS CLOSED AND WHY ONLY ONE REWRITE. The first match wins and produces exactly one
+* canonical string. Chinese self-reference has unbounded variants ("我叫啥" / "本人是" / "我是干啥的"),
+* so no closed table can recognize all of them; keeping the OUTPUT set closed (one canonical form per
+* intent) bounds the cost and keeps the fused numbers comparable across queries. Recognizing more
+* variants is a job for the (future) slot/structured work, not for an ever-growing cue list.
+*
+* WHY A WRONG MATCH IS AFFORDABLE. The rewrite is applied as AUGMENTATION, never replacement
+* (`store/hybrid.ts`): the original query still runs and its candidates are still kept, so a false
+* positive can only ADD recall — it can never change what the user actually asked. That is also why
+* the cues can be a little generous: the measured cost of over-matching is "one more leg run", where
+* the cost of under-matching is the failure this whole file exists to remove.
+*
+* @module store/self_query
+*/
+/**
+* The intent table. ORDER IS LOAD-BEARING: the first rule with a matching cue wins, so a more
+* specific intent must precede a broader one that would also match (e.g. the occupation forms sit
+* before the bare identity cue). All cues are first-person ("我") or the formal self-reference
+* "本人"; nothing here can match a question about somebody else.
+*/
+const SELF_QUERY_RULES = [
+	{
+		cues: [
+			"我是做什么的",
+			"我是干什么的",
+			"我是干啥的",
+			"我是做哪行的",
+			"我的职业",
+			"我的工作"
+		],
+		rewrite: "用户是做什么的"
+	},
+	{
+		cues: [
+			"我的名字",
+			"我叫什么",
+			"我叫啥",
+			"我的姓名",
+			"我叫什么名字"
+		],
+		rewrite: "用户的名字"
+	},
+	{
+		cues: [
+			"我是谁",
+			"本人是谁",
+			"我是什么人",
+			"本人是什么人"
+		],
+		rewrite: "用户是谁"
+	},
+	{
+		cues: [
+			"我在哪",
+			"我在哪里",
+			"我住在哪",
+			"我的位置",
+			"我的所在地"
+		],
+		rewrite: "用户在哪里"
+	},
+	{
+		cues: [
+			"我的偏好",
+			"我喜欢什么",
+			"我的喜好",
+			"我的习惯"
+		],
+		rewrite: "用户的偏好"
+	}
+];
+/**
+* The ONE canonical rewrite for `text`, or `undefined` when the input is not self-referential.
+*
+* `undefined` (not `text`) is the "nothing to add" answer on purpose: the retrieval path keys
+* "run a second leg set" off it, and returning the input unchanged would make every query pay for
+* an augmentation that cannot add anything.
+*/
+function selfQueryRewrite(text) {
+	const query = text.trim();
+	if (query === "") return void 0;
+	for (const rule of SELF_QUERY_RULES) for (const cue of rule.cues) if (query.includes(cue)) return rule.rewrite;
+}
+//#endregion
 //#region ../core/lib/store/floors.js
 /**
 * What the RELAXED pass lowers each floor TO, as absolute values.
 *
-*  - semantic **0.40**: strictly BETWEEN the measured unrelated-query ceiling (0.384) and the
-*    pronoun-query top-1 (0.444). Both bounds are load-bearing. Above 0.384, so a genuinely
+*  - semantic **0.40**: strictly BETWEEN the measured unrelated-query ceiling and the
+*    pronoun-query top-1. Both bounds are load-bearing. Above the ceiling, so a genuinely
 *    unrelated question still comes back EMPTY from the relaxed pass — the four measured samples
-*    topped out at 0.300/0.384/0.315/0.351, and a 0.35 bar would already admit two of them. Below
-*    0.444, so 「我是谁」 finds its fact. 0.40 keeps the larger margin on the noise side, which is
-*    where a false positive costs the caller a wrong answer rather than a missing one.
+*    topped out at 0.300/0.384/0.315/0.351 under the original 512-dim default and at
+*    0.271/0.353/0.350/0.269 under the shipped 768-dim `bge-base-zh-v1.5` (a 0.35 bar would already
+*    admit two of them in either scale). Below the top-1, so 「我是谁」 finds its fact (0.444 at 512,
+*    0.459 at 768). 0.40 keeps the larger margin on the noise side, which is where a false positive
+*    costs the caller a wrong answer rather than a missing one.
 *  - fts: NOT a constant — {@link looseTermFloor}, half the query's distinct terms with a floor of
 *    1. `1` here is the "no terms to scale by" baseline (the previously constant value); a query
 *    that cannot produce terms is not graded at all, and one that produces a single term (every
@@ -6796,9 +6923,11 @@ function emptyFloorDrops() {
 * and changing the REPORTED value there would misdescribe what the caller is reading. `0` stays `0`
 * (the operator's off switch).
 *
-* This is the ONE place the clamp lives; `resolveFloors` (what the result reports) and
-* `applyTermFloor` (what the leg does) both call it, so the number the caller reads is the number
-* the leg used.
+* This is the ONE place the clamp lives; `resolveFloors` (what the result reports / a run is handed)
+* and `applyTermFloor` (what the leg does) both call it, so the number a run reads is the number its
+* leg used. It is a `min`, i.e. one-directional: it can LOWER an unreachable configured bar but never
+* RAISE a bar inherited from another text, which is why the caller must resolve per graded text
+* rather than reusing one text's resolution for another.
 */
 function effectiveTermFloor(floor, termCount) {
 	if (!(floor > 0)) return floor;
@@ -7009,6 +7138,48 @@ async function hybridSearch(deps, plan) {
 	const legCap = legCapFor(deps.config, overFetch);
 	const termCount = relevanceTerms(query).length;
 	/**
+	* 方案 A — the self-reference AUGMENTATION (docs/SELF_QUERY_RELEVANCE.md §4-A).
+	*
+	* The corpus writes the user in the third person and the user asks in the first, so a
+	* first-person question shares no lexical term with the fact that answers it and the semantic leg
+	* has to carry the whole decision. The intent table (`store/self_query.ts`) supplies ONE canonical
+	* third-person rewrite and the ORIGINAL query and the rewrite each run the full leg set.
+	*
+	* THE FLOOR IS RESOLVED PER RUN (0.4.2). Each run is graded by ITS OWN reachability clamp —
+	* `min(configured, relevanceTerms(variant).length)` — because a variant with MORE terms has a
+	* HIGHER bar, and grading it at the original's lower bar is what let a single incidental trigram
+	* from the rewrite become that leg's head. Measured on the live store: `我是谁？` yields ONE term
+	* (`我是谁`) while its rewrite `用户是谁` yields TWO (`用户是` / `户是谁`), and the rewrite's
+	* `用户是` is a literal substring of an unrelated long note — that note then took the FTS leg's
+	* head (weight × 1.0) and outvoted the identity fact, which the rewrite had correctly put first.
+	* `applyTermFloor` re-clamps to the query it is grading, but the clamp is one-directional
+	* (`min`): it can only LOWER an unreachable bar, never RAISE a bar inherited from another text, so
+	* the resolution has to happen per variant (see {@link resolveFloors}). Each variant's own bar is
+	* then floored at the reported one, so every run is graded at or ABOVE what the envelope says: the
+	* envelope reports the ORIGINAL query's floors (the question the user actually asked) and can never
+	* overstate the bar a run was held to.
+	*
+	* WHY AUGMENT, NOT REPLACE. The table is a closed cue list over a language with unbounded
+	* self-reference variants, so a wrong match is inevitable. Under augmentation a false positive can
+	* only add candidates; the original query's candidates are always kept, exactly like the relaxed
+	* floor policy ("only ever widens"). Under replacement it would change what the user actually
+	* asked. `queries.length === 1` (the overwhelming majority) leaves the run below bit-identical to
+	* the pre-A path: one `deps.legs` call, same context, same vector wiring.
+	*
+	* FLOORS, `relaxed` AND `dropped_by_floor` UNDER AUGMENTATION. The PROFILE is resolved once per
+	* pass from the ORIGINAL query and handed to both runs; only the per-variant reachability clamp
+	* above differs, and it can only raise. Every leg of every run is therefore judged by AT LEAST the
+	* numbers the result reports — the envelope can never say "strict" while a rewrite run answered from
+	* the relaxed band (the distortion this design exists to rule out). `relaxed` is decided exactly as
+	* it was: the automatic loose pass fires only when the strict pass returned NOTHING with drops, and
+	* it re-runs BOTH variants under the loosened floors. Because a leg only ever REMOVES entries, the
+	* per-leg merge of the two runs' drop counts uses `max` (summing would count the same candidate
+	* twice) and `capped` uses OR — both conservative, neither inflates the report that feeds the retry
+	* decision.
+	*/
+	const augment = (plan.rewriteQuery ?? selfQueryRewrite)(query);
+	const queries = augment !== void 0 && augment !== query ? [query, augment] : [query];
+	/**
 	* The query vector in force, ACROSS both passes.
 	*
 	* The single-store path is handed no vector by its caller (only the cross-store router encodes
@@ -7019,6 +7190,12 @@ async function hybridSearch(deps, plan) {
 	*/
 	let passVector = plan.queryVector;
 	/**
+	* The rewrite's own vector, ACROSS both passes, for the same reason as {@link passVector}: the
+	* rewrite is a different text, so it needs its own encode, and the relaxed retry must not pay for
+	* it twice. Keyed by variant text (there is at most one).
+	*/
+	const augmentVectors = /* @__PURE__ */ new Map();
+	/**
 	* One full pass under ONE floor profile: legs → fuse → live filter → rerank → slice → budget.
 	*
 	* `onReturn` (the store's reinforcement) is deliberately NOT called here: the strict pass is a
@@ -7034,19 +7211,34 @@ async function hybridSearch(deps, plan) {
 			termCount,
 			...relaxLegs === void 0 ? {} : { relaxLegs }
 		});
-		const legs = await runLegs(deps, {
-			query,
-			limit,
-			overFetch,
-			legCap,
-			semAvail,
-			weights,
-			floors,
-			...passVector === void 0 ? {} : { queryVector: passVector },
-			onQueryVector: (vec) => {
-				passVector = vec;
-			}
-		});
+		const runs = await Promise.all(queries.map(async (variant, index) => {
+			const isOriginal = index === 0;
+			const vector = isOriginal ? passVector : augmentVectors.get(variant);
+			const ownFloors = isOriginal ? floors : resolveFloors(retriever, semAvail, {
+				profile,
+				termCount: relevanceTerms(variant).length,
+				...relaxLegs === void 0 ? {} : { relaxLegs }
+			});
+			const variantFloors = ownFloors === floors ? floors : {
+				...ownFloors,
+				fts: Math.max(floors.fts, ownFloors.fts)
+			};
+			return runLegs(deps, {
+				query: variant,
+				limit,
+				overFetch,
+				legCap,
+				semAvail,
+				weights,
+				floors: variantFloors,
+				...vector === void 0 ? {} : { queryVector: vector },
+				onQueryVector: (vec) => {
+					if (isOriginal) passVector = vec;
+					else augmentVectors.set(variant, vec);
+				}
+			});
+		}));
+		const legs = runs.length === 1 ? runs[0] : unionLegs(runs);
 		let capped = 0;
 		for (const leg of legs) if (leg.capped === true) capped += 1;
 		const droppedByFloor = emptyFloorDrops();
@@ -7102,6 +7294,48 @@ async function hybridSearch(deps, plan) {
 	};
 }
 /**
+* Union the per-leg raw scores of the augmented runs (方案 A) — original first, then the rewrite(s).
+*
+* Same leg INDEX, not "same `leg` label": both runs come from ONE store with an identical context
+* except for the query text, so the leg array has the same shape and order (memory: semantic,
+* jaccard, fts[, hrr]; knowledge: semantic, fts, jaccard). Merging by index is what keeps this from
+* becoming a second leg with its own weight — the weight, `leg` label and `capped` bookkeeping stay
+* the ORIGINAL run's.
+*
+* A candidate present in both runs keeps its MAX score, and `capped` is the OR. `droppedByFloor`
+* is the MAX too: both runs commonly drop the SAME candidate (the rewrite is a third-person
+* paraphrase of the same question), and we do not carry the pre-floor raw sets, so summing would
+* double-count it. The max is the conservative number that never inflates the drop report — which
+* is what `feeds` the relaxed-retry decision and the health counters. A store returning a different
+* leg count for one variant is a contract violation; the extra legs are appended rather than
+* silently discarded, so it cannot narrow the union either.
+*/
+function unionLegs(runs) {
+	const [first, ...rest] = runs;
+	const out = (first ?? []).map((leg) => ({
+		...leg,
+		scores: new Map(leg.scores)
+	}));
+	for (const run of rest) run.forEach((leg, index) => {
+		const current = out[index];
+		if (current === void 0) {
+			out.push({
+				...leg,
+				scores: new Map(leg.scores)
+			});
+			return;
+		}
+		for (const [id, score] of leg.scores) {
+			const previous = current.scores.get(id);
+			if (previous === void 0 || score > previous) current.scores.set(id, score);
+		}
+		if (leg.capped === true) current.capped = true;
+		if (leg.leg !== void 0) current.leg = leg.leg;
+		if (leg.droppedByFloor !== void 0) current.droppedByFloor = Math.max(current.droppedByFloor ?? 0, leg.droppedByFloor);
+	});
+	return out;
+}
+/**
 * Await the store's legs, isolating a failure to the leg that caused it.
 *
 * A rejected leg contributes nothing and is reported; the query still answers from the others. The
@@ -7171,10 +7405,16 @@ function vectorSpaceId(backend, model, dim) {
 * The rows come from the owning store's DAO (DESIGN §19): this helper decodes and
 * filters them, it never runs SQL itself.
 *
+* A row whose width does not fit the store is skipped (never `add()`ed — the store
+* would throw). The OWNING store reports that condition itself, as one actionable
+* line with the count, the reason and the manual re-encode entry (`reportStaleVectors`),
+* so this helper stays quiet: two warnings for one condition read as two problems.
+*
 * @param rows - `id` (fact/chunk id) + `vec` (BLOB), as read back from the store.
-* @param label - store name used in the dim-mismatch warning.
+* @param _label - store name; unused here (the owning store owns the warning), kept so call sites read
+*                 as "which store is reloading".
 */
-function reloadVectorIndex(vstore, rows, label) {
+function reloadVectorIndex(vstore, rows, _label) {
 	const entries = [];
 	let skipped = 0;
 	for (const r of rows) {
@@ -7185,7 +7425,6 @@ function reloadVectorIndex(vstore, rows, label) {
 		});
 		else skipped++;
 	}
-	if (skipped > 0) retrievalLogger().warn(`${label} index reload: skipped ${skipped} vector(s) with dim != ${vstore.dim}`);
 	vstore.rebuild(entries);
 	return {
 		loaded: entries.length,
@@ -7250,21 +7489,32 @@ function evictVectors(vstore, ids) {
 	else for (const id of ids) vstore.remove(id);
 }
 /**
-* Tell the operator that persisted vectors came from ANOTHER vector space.
+* Tell the operator that persisted vectors came from ANOTHER vector space — loudly, and with the
+* manual remedy.
+*
+* Changing the embedding space (model, width, pooling, normalization) is a DATA MIGRATION: the
+* persisted bytes stay valid-looking but are no longer comparable with the current query vector, so
+* the semantic leg must not serve them. Measured on the real library after the 512→768 default-model
+* swap: 78 of 80 ACTIVE facts fell out of the semantic leg and retrieval silently degraded to
+* lexical+entity (every probe query answered with the same unrelated short fact), with no error
+* anywhere. The count, the reason and the ONE manual entry have to be visible at start.
 *
-* A dim-valid vector from a different space is still RANKED — the reload cannot tell the difference
-* — so a silent model swap would mix two spaces in one index and degrade every semantic query
-* without an error anywhere. Said once per process; acting on it is the operator's choice because
-* re-encoding is a real cost (and they should see the count first).
+* Both halves are reported in one message because they are one condition seen two ways: a changed
+* WIDTH (`stale`, whose bytes cannot even be decoded into the current store) and a changed SPACE at
+* the same width (`space_stale`, whose bytes decode but rank in another model's coordinates).
 *
 * @param kind   store label for the message (`memory` / `knowledge`)
 * @param space  the vector space the store writes into now
-* @param foreign how many persisted vectors were written in a different one
-* @param fix    the action that re-encodes them, as the operator would type it
+* @param counts how many persisted vectors are unusable in the current space, by kind
+* @param fix    the manual entry that re-encodes them, as the operator would type it
 */
-function reportForeignVectors(kind, space, foreign, fix) {
-	if (foreign <= 0) return;
-	retrievalLogger().warn(`${kind} index: ${String(foreign)} vector(s) were written in another space than ${space} — they are still ranked; run ${fix} to re-encode them`);
+function reportStaleVectors(kind, space, counts, fix) {
+	const total = counts.stale + counts.space_stale;
+	if (total <= 0) return;
+	const reasons = [];
+	if (counts.stale > 0) reasons.push(`${String(counts.stale)} with a width that no longer matches`);
+	if (counts.space_stale > 0) reasons.push(`${String(counts.space_stale)} written by another model`);
+	retrievalLogger().warn(`${kind} index: ${String(total)} persisted vector(s) belong to an OLDER embedding space than ${space} (${reasons.join("; ")}) — the semantic leg cannot use them, so retrieval degrades to lexical+entity (this is a data migration, not a transient error); run ${fix} to re-encode them`);
 }
 /**
 * Hand the event loop back between two synchronous batches.
@@ -7846,6 +8096,17 @@ var FactsDao = class FactsDao {
           WHERE semantic_vector IS NOT NULL AND status = 'active'`).all();
 	}
 	/**
+	* Width + recorded space of every ACTIVE persisted vector, WITHOUT reading the bytes.
+	*
+	* `length(blob)` is the byte count, so `bytes / 4` is the float width — enough to detect a
+	* changed `semantic.dim` without decoding a corpus. This is the cheap detection the startup
+	* warning and the `/mem` status surface read (see `MemoryStore.vectorSpaceHealth`).
+	*/
+	activeVectorSpaces() {
+		return this.db.prepare(`SELECT fact_id, length(semantic_vector) AS bytes, embedding_model FROM facts
+          WHERE semantic_vector IS NOT NULL AND status = 'active'`).all();
+	}
+	/**
 	* Facts per archive reason — the trust diagnostics breakdown. One grouped scan rather than
 	* a count per reason, because the reasons are few but the table is not.
 	*/
@@ -9393,13 +9654,38 @@ var MemoryStore = class {
 	*/
 	reloadIndex() {
 		const space = this.vectorSpace();
-		const persisted = this.facts.activeVectorRows();
-		const rows = persisted.map((r) => ({
+		const rows = this.facts.activeVectorRows().map((r) => ({
 			id: r.fact_id,
 			vec: r.semantic_vector
 		}));
 		reloadVectorIndex(this.vstore, rows, "memory");
-		reportForeignVectors("memory", space, persisted.filter((r) => r.embedding_model !== space).length, "mem_admin vectors_fix (dry_run=true previews the count)");
+		reportStaleVectors("memory", space, this.vectorSpaceHealth(), "`avantf-mem vectors --fix` (MCP/plugin: `mem_admin vectors_fix`)");
+	}
+	/**
+	* Cheapest possible DETECTION of "the embedding space changed under this store": counts of ACTIVE
+	* persisted vectors whose width or recorded space id no longer matches the one this store writes
+	* into. Reads blob LENGTHS only — never decodes — so the `/mem` status surface and the startup
+	* warning can afford it at any corpus size.
+	*
+	* The counts are the same two `VectorsDiagnostic` already separates (`stale` / `space_stale`); this
+	* is the read model those surfaces use instead of the full diagnose pass.
+	*/
+	vectorSpaceHealth() {
+		const space = this.vectorSpace();
+		const expectedBytes = this.vstore.dim * 4;
+		let stale = 0;
+		let spaceStale = 0;
+		for (const row of this.facts.activeVectorSpaces()) {
+			if (row.bytes !== expectedBytes) {
+				stale++;
+				continue;
+			}
+			if (row.embedding_model !== space) spaceStale++;
+		}
+		return {
+			stale,
+			space_stale: spaceStale
+		};
 	}
 	async add(content, category, ttlDays) {
 		const normalized = normalizeWrite(content).trim();
@@ -9828,7 +10114,7 @@ var MemoryStore = class {
 		};
 	}
 	/**
-	* Repair the semantic read model:
+	* Repair the semantic read model, in ONE bounded slice or in full:
 	*  (a) reload persisted, dim-valid vectors missing from the live index
 	*      (restart / index loss — needs no model),
 	*  (b) drop persisted vectors whose dim no longer matches `semantic.dim` so a
@@ -9836,64 +10122,162 @@ var MemoryStore = class {
 	*      throws on dim mismatch),
 	*  (c) encode active facts that have no vector yet (needs the semantic backend),
 	*  (d) re-encode vectors written in ANOTHER vector space (a model swap, or the one-time
-	*      adoption of a store predating the space id). Deliberately here and not at open: this is
-	*      the only path that re-encodes the whole table, so it is an explicit, counted action.
-	* `dry_run` previews every count without writing — and without loading the model, which is why
-	* the preview also reports `would_warm` (see the contract's `VectorsFixReport`).
+	*      adoption of a store predating the space id).
+	*
+	* `limit` is what makes the SAME logic usable as a background migration: at most that many rows are
+	* dropped and at most that many are re-encoded, so one call is a bounded unit of work the caller can
+	* yield between. `vectorsFix` passes no limit (the explicit operator action drains everything);
+	* `migrateVectorsBatch` passes the migration's batch size.
 	*/
-	async vectorsFix(dryRun = false) {
+	async repairVectors(opts) {
+		const limit = opts.limit ?? Number.POSITIVE_INFINITY;
 		const c = this.classifyVectors();
 		const loadedNow = this.semantic.isAvailable();
 		let semAvailable = loadedNow;
-		if (!semAvailable && !dryRun) semAvailable = await this.warmupSemantic();
+		if (!semAvailable && !opts.dryRun) semAvailable = await this.warmupSemantic();
 		const wouldWarm = !loadedNow;
-		if (dryRun) return {
-			missing: c.missing,
-			stale: c.staleIds.length,
-			space_stale: c.spaceStaleIds.length,
-			unindexed: c.unindexed.length,
-			reindexed: 0,
-			dropped: 0,
-			fixed: 0,
-			semantic_available: semAvailable,
-			would_warm: wouldWarm,
-			dry_run: true
+		const remainingOf = (fixed) => Math.max(0, c.staleIds.length + c.spaceStaleIds.length + c.missing - fixed);
+		if (opts.dryRun) return {
+			report: {
+				missing: c.missing,
+				stale: c.staleIds.length,
+				space_stale: c.spaceStaleIds.length,
+				unindexed: c.unindexed.length,
+				reindexed: 0,
+				dropped: 0,
+				fixed: 0,
+				semantic_available: semAvailable,
+				would_warm: wouldWarm,
+				dry_run: true
+			},
+			remaining: remainingOf(0)
 		};
 		let reindexed = 0;
-		for (const u of c.unindexed) {
+		for (const u of c.unindexed.slice(0, limit)) {
 			this.vstore.add(u.id, u.vec);
 			reindexed++;
 		}
 		let dropped = 0;
 		if (semAvailable) {
-			const toDrop = [...c.staleIds, ...c.spaceStaleIds];
+			const toDrop = [...c.staleIds, ...c.spaceStaleIds].slice(0, limit);
 			if (toDrop.length) {
+				const spaceStale = new Set(c.spaceStaleIds);
 				dropped = this.facts.clearVectors(toDrop);
-				this.evictVectors(c.spaceStaleIds);
+				this.evictVectors(toDrop.filter((id) => spaceStale.has(id)));
 			}
 		}
 		let fixed = 0;
 		if (semAvailable) {
-			const missingRows = this.facts.missingVectorRows();
+			const missingRows = this.facts.missingVectorRows().slice(0, limit);
 			for (const m of missingRows) {
 				if (!await this.maybeIndexSemantic(m.fact_id, m.content)) continue;
 				fixed++;
 			}
 		}
 		return {
-			missing: c.missing,
-			stale: c.staleIds.length,
-			space_stale: c.spaceStaleIds.length,
-			unindexed: c.unindexed.length,
-			reindexed,
-			dropped,
-			fixed,
-			semantic_available: semAvailable,
-			would_warm: wouldWarm,
-			dry_run: false
+			report: {
+				missing: c.missing,
+				stale: c.staleIds.length,
+				space_stale: c.spaceStaleIds.length,
+				unindexed: c.unindexed.length,
+				reindexed,
+				dropped,
+				fixed,
+				semantic_available: semAvailable,
+				would_warm: wouldWarm,
+				dry_run: false
+			},
+			remaining: remainingOf(fixed)
 		};
 	}
 	/**
+	* The explicit, unbounded repair behind `mem_admin vectors_fix` / `avantf-mem vectors --fix`.
+	* `dry_run` previews every count without writing — and without loading the model, which is why
+	* the preview also reports `would_warm` (see the contract's `VectorsFixReport`).
+	*/
+	async vectorsFix(dryRun = false) {
+		return (await this.repairVectors({ dryRun })).report;
+	}
+	/**
+	* ONE bounded slice of the vector-space migration: at most `batchSize` rows are dropped and
+	* re-encoded, so the caller keeps control of the event loop between slices. This is the unit the
+	* background migration ({@link migrateVectors}) and its tests drive.
+	*
+	* Resumability is a property of the DATABASE, not of this process: every slice re-derives what is
+	* stale from the persisted width/space, so a restart simply continues where the last slice stopped.
+	*/
+	async migrateVectorsBatch(batchSize = 16) {
+		const size = Math.max(1, Math.floor(batchSize));
+		const { report, remaining } = await this.repairVectors({
+			dryRun: false,
+			limit: size
+		});
+		return {
+			remaining,
+			migrated: report.fixed,
+			dropped: report.dropped,
+			reindexed: report.reindexed,
+			semantic_available: report.semantic_available
+		};
+	}
+	/**
+	* Drive the bounded background migration until the store is current, the model is unavailable, or
+	* `shouldStop()` turns true (plugin unmount / process shutdown). A batch FAILURE never rejects: it is
+	* logged and reported as `remaining > 0`, which is what makes the next heartbeat a retry (the caller
+	* still owns the outer catch for a closed database, e.g. a shutdown racing the first read). Never
+	* blocks the event loop for longer than one batch.
+	*
+	* Honours `semantic.auto_migrate` (default on) — the switch exists so a host that must not spend CPU
+	* on background re-encoding can leave the loud warning and the manual entry as the only path.
+	*/
+	async migrateVectors(opts = {}) {
+		const enabled = this.config.semantic.auto_migrate !== false;
+		const snapshot = () => ({
+			enabled,
+			remaining: this.migrationRemaining(),
+			migrated: 0,
+			dropped: 0,
+			reindexed: 0,
+			semantic_available: this.semantic.isAvailable()
+		});
+		if (!enabled) return snapshot();
+		let migrated = 0;
+		let dropped = 0;
+		let reindexed = 0;
+		let last = snapshot();
+		if (last.remaining === 0) return last;
+		for (;;) {
+			if (opts.shouldStop?.() === true) break;
+			let step;
+			try {
+				step = await this.migrateVectorsBatch(opts.batchSize);
+			} catch (error) {
+				retrievalLogger().warn(`memory vector migration: batch failed (${describeError$2(error)}) — ${String(this.migrationRemaining())} vector(s) still belong to an older embedding space; the next pass retries`);
+				break;
+			}
+			migrated += step.migrated;
+			dropped += step.dropped;
+			reindexed += step.reindexed;
+			last = {
+				...step,
+				enabled,
+				migrated,
+				dropped,
+				reindexed
+			};
+			opts.onProgress?.(last);
+			if (step.migrated === 0 && step.dropped === 0 && step.reindexed === 0) break;
+			if (last.remaining === 0) break;
+			await yieldToEventLoop();
+		}
+		return last;
+	}
+	/** Active rows the semantic leg still cannot use (old width, old space, or no vector at all). */
+	migrationRemaining() {
+		const health = this.vectorSpaceHealth();
+		return health.stale + health.space_stale + this.facts.vectorCounts().missing;
+	}
+	/**
 	* One lifecycle pass, owned by the store so the DB writes and the live-index
 	* invariant (ACTIVE vectors only) are maintained in ONE place — the runtime no
 	* longer has to patch the index behind the store's back.
@@ -10048,7 +10432,8 @@ var MemoryStore = class {
 			queryVector: input.queryVector,
 			recordStats: input.recordStats,
 			floors: input.floors,
-			...input.relaxLegs === void 0 ? {} : { relaxLegs: input.relaxLegs }
+			...input.relaxLegs === void 0 ? {} : { relaxLegs: input.relaxLegs },
+			...input.rewriteQuery === void 0 ? {} : { rewriteQuery: input.rewriteQuery }
 		});
 		return {
 			hits: result.hits,
@@ -12224,7 +12609,20 @@ var KnowledgeStore = class {
 		const space = this.vectorSpace();
 		const persisted = this.chunks.vectorRows();
 		reloadVectorIndex(this.vstore, persisted, "knowledge");
-		reportForeignVectors("knowledge", space, persisted.filter((r) => r.embedding_model !== space).length, "kb_reindex (dry_run=true previews the count)");
+		let stale = 0;
+		let spaceStale = 0;
+		const expectedBytes = this.vstore.dim * 4;
+		for (const row of persisted) {
+			if (!row.vec || row.vec.byteLength !== expectedBytes) {
+				stale++;
+				continue;
+			}
+			if (row.embedding_model !== space) spaceStale++;
+		}
+		reportStaleVectors("knowledge", space, {
+			stale,
+			space_stale: spaceStale
+		}, "`avantf-mem kb reindex` (MCP/plugin: `kb_reindex`)");
 	}
 	/**
 	* The write-side domain allowlist AND the 知识页 picker's data, in one place: the configured
@@ -13061,7 +13459,8 @@ var KnowledgeStore = class {
 			queryVector: opts?.queryVector,
 			recordStats: opts?.recordStats,
 			floors: opts?.floors,
-			...opts?.relaxLegs === void 0 ? {} : { relaxLegs: opts.relaxLegs }
+			...opts?.relaxLegs === void 0 ? {} : { relaxLegs: opts.relaxLegs },
+			...opts?.rewriteQuery === void 0 ? {} : { rewriteQuery: opts.rewriteQuery }
 		});
 		opts?.onResult?.(result);
 		return result.hits;
@@ -13451,7 +13850,10 @@ function buildRuntime(opts) {
 		knowledge,
 		logger,
 		relevance(text) {
-			return looksRelevant(memory.lexicalProbe(text, 2)) || looksRelevant(knowledge.lexicalProbe(text, 2));
+			if (looksRelevant(memory.lexicalProbe(text, 2)) || looksRelevant(knowledge.lexicalProbe(text, 2))) return true;
+			const rewrite = selfQueryRewrite(text);
+			if (rewrite === void 0) return false;
+			return looksRelevant(memory.lexicalProbe(rewrite, 2)) || looksRelevant(knowledge.lexicalProbe(rewrite, 2));
 		},
 		async remember(req) {
 			switch (req.action) {
@@ -13501,7 +13903,8 @@ function buildRuntime(opts) {
 			switch (req.action) {
 				case "stats": return {
 					...this.memory.countByStatus(),
-					retrieval: retrievalHealthSummary()
+					retrieval: retrievalHealthSummary(),
+					vectors: this.memory.vectorSpaceHealth()
 				};
 				case "list": return this.memory.list(req.category, req.status ?? "active", req.limit ?? 50, req.offset ?? 0);
 				case "detail": return this.memory.get(req.fact_id) ?? { error: `fact_id=${req.fact_id} not found` };
@@ -14631,16 +15034,18 @@ const MODEL_ITEM = "mem:model";
 * {@link MODEL_FILES} describes. A DIFFERENT repo is a different file set, which is why the item
 * omits `spec.files` for it (see {@link managedModelSpec}).
 */
-const DEFAULT_MODEL_REPO = "Xenova/bge-small-zh-v1.5";
+const DEFAULT_MODEL_REPO = "Xenova/bge-base-zh-v1.5";
 /**
 * The files the local embedding runtime actually requests for the DEFAULT ONNX model.
 *
 * Measured, not guessed: with an empty cache, `@huggingface/transformers@4.x` resolving
-* `feature-extraction` for `Xenova/bge-small-zh-v1.5` fetches exactly these four — `config.json`,
+* `feature-extraction` for `Xenova/bge-base-zh-v1.5` fetches exactly these four — `config.json`,
 * `tokenizer.json`, `tokenizer_config.json` and the fp32 `onnx/model.onnx`. The repo ALSO carries
 * `special_tokens_map.json`, `vocab.txt` and seven other ONNX quantisations the default run never
 * opens; declaring them would download hundreds of megabytes of dead weight. The list stays narrow
-* to what is read.
+* to what is read. (It is UNCHANGED from the previous default `Xenova/bge-small-zh-v1.5`: both
+* repos are Xenova BGE ports with the same four runtime files — verified against the local cache of
+* each. Only the bytes behind `onnx/model.onnx` differ, ~95 MB for small vs ~389 MB for base.)
 */
 const MODEL_FILES = [
 	"config.json",
@@ -14677,7 +15082,8 @@ const OWN_PREFIX = "envinit:";
 *   2. **The runtime reads its models from elsewhere** — `semantic.cache_dir` is not the framework's
 *      `<home>/models`. That happens through the operator escape hatch `AVANTF_MEM_MODEL_CACHE`
 *      (env layer ④): the runtime loads from that directory, so a `mem:model` item would install a
-*      full second copy under `<home>/models` that nothing ever reads (~190 MB). Declaring nothing
+*      full second copy under `<home>/models` that nothing ever reads (~389 MB for the default
+*      `Xenova/bge-base-zh-v1.5`). Declaring nothing
 *      is the fix; the caller warms from the override directory instead.
 *
 * `files` is the narrow {@link MODEL_FILES} set only for the DEFAULT repo; a user-changed repo has a
@@ -15197,6 +15603,58 @@ function openDocumentPath(documentPath, target, configured, deps = {}) {
 	throw new Error(`无法启动编辑器（试过：${tried.join("、")}${detail}）`);
 }
 //#endregion
+//#region lib/types/vectorMigration.js
+function createVectorMigration(opts) {
+	const { rt, logger } = opts;
+	let running = false;
+	let stopped = false;
+	let warnedDisabled = false;
+	const run = async () => {
+		const health = rt.memory.vectorSpaceHealth();
+		const pending = health.stale + health.space_stale;
+		if (pending === 0) return;
+		if (rt.closed || !opts.isActive()) return;
+		if (rt.config.common.semantic.auto_migrate === false) {
+			if (!warnedDisabled) {
+				warnedDisabled = true;
+				logger.warn(`vector migration: ${String(pending)} ACTIVE vector(s) belong to an older embedding space and \`semantic.auto_migrate\` is off — the semantic leg stays blind to them; run \`avantf-mem vectors --fix\` (MCP/plugin: \`mem_admin vectors_fix\`) or set \`semantic.auto_migrate: true\``);
+			}
+			return;
+		}
+		const startedAt = Date.now();
+		logger.info(`vector migration: ${String(pending)} ACTIVE vector(s) belong to an older embedding space (${String(health.space_stale)} same-width other-model, ${String(health.stale)} wrong-width) — re-encoding in the background`);
+		const outcome = await rt.memory.migrateVectors({
+			...opts.batchSize === void 0 ? {} : { batchSize: opts.batchSize },
+			shouldStop: () => stopped || rt.closed || !opts.isActive(),
+			onProgress: (progress) => {
+				logger.info(`vector migration: re-encoded ${String(progress.migrated)}/${String(pending)} (${String(progress.remaining)} left)`);
+			}
+		});
+		if (outcome.remaining === 0) {
+			logger.info(`vector migration: complete — ${String(outcome.migrated)} vector(s) re-encoded in ${String(Date.now() - startedAt)}ms; the semantic leg is current`);
+			return;
+		}
+		if (!stopped && !rt.closed && opts.isActive()) logger.warn(`vector migration: ${String(outcome.remaining)} vector(s) still belong to an older embedding space (the embedding model may be unavailable) — the next heartbeat retries; manual entry \`avantf-mem vectors --fix\``);
+	};
+	return {
+		start() {
+			if (stopped || running) return;
+			running = true;
+			run().catch((error) => {
+				logger.warn(`vector migration failed: ${error instanceof Error ? error.message : String(error)}`);
+			}).finally(() => {
+				running = false;
+			});
+		},
+		stop() {
+			stopped = true;
+		},
+		get running() {
+			return running;
+		}
+	};
+}
+//#endregion
 //#region lib/types/tool_schema.js
 /**
 * zod → DSH parameter schema derivation for the agent tools.
@@ -15334,16 +15792,37 @@ function flattenToolSpec(spec) {
 }
 //#endregion
 //#region lib/types/render.js
+/**
+* 方案 G — surface the EXISTING `degraded` flag as a sentence, without inventing a field.
+*
+* A recall/query result already carries `degraded` (with `weights`/`floors`) in its JSON, so a
+* caller COULD read it; the annotation names the consequence in plain words ("本次仅词法腿") for the
+* model and the operator who does not parse the envelope. It is a SECOND text block, never text
+* appended to the JSON block: the JSON block stays strictly parseable (see the module note). Absent
+* whenever the flag is absent/false — a graph-only answer reports `degraded: false`, so no note.
+*/
+function degradedLegNote(value) {
+	const result = value?.result;
+	return result !== null && typeof result === "object" && result.degraded === true ? DEGRADED_LEG_NOTE : void 0;
+}
 /** The tool output spec registered on every mem tool. */
 const OUTPUT = {
 	schema: {
 		type: "object",
 		additionalProperties: true
 	},
-	render: (_args, value) => [{
-		type: "text",
-		text: JSON.stringify(toWellFormedDeep(value), null, 2)
-	}]
+	render: (_args, value) => {
+		const blocks = [{
+			type: "text",
+			text: JSON.stringify(toWellFormedDeep(value), null, 2)
+		}];
+		const note = degradedLegNote(value);
+		if (note !== void 0) blocks.push({
+			type: "text",
+			text: note
+		});
+		return blocks;
+	}
 };
 //#endregion
 //#region lib/types/inject.js
@@ -15922,6 +16401,14 @@ async function apply(ctx, config) {
 		...waitFor === void 0 ? {} : { waitFor },
 		...verdict === void 0 ? {} : { dshCompat: verdict }
 	});
+	const vectorMigration = createVectorMigration({
+		rt,
+		logger,
+		isActive: () => stillActive(ctx)
+	});
+	ctx.effect(() => () => {
+		vectorMigration.stop();
+	});
 	const sweepEntities = () => {
 		rt.memory.reindexEntities(ENTITY_SWEEP_PER_HEARTBEAT).then((swept) => {
 			if (swept.rebuilt > 0) logger.info(`entity sweep: rebuilt ${swept.rebuilt} fact(s) written by older rules (${swept.deferred} still stale)`);
@@ -15933,7 +16420,10 @@ async function apply(ctx, config) {
 		...waitFor === void 0 ? {} : { waitFor },
 		deferTokenizerUntilIdle: true
 	}).then(() => {
-		if (!rt.closed && stillActive(ctx)) sweepEntities();
+		if (!rt.closed && stillActive(ctx)) {
+			sweepEntities();
+			vectorMigration.start();
+		}
 	}).catch((error) => {
 		logger.warn(`entity sweep gate failed: ${error instanceof Error ? error.message : String(error)}`);
 	});
@@ -15946,6 +16436,7 @@ async function apply(ctx, config) {
 				logger.warn(`trust tick failed: ${error instanceof Error ? error.message : String(error)}`);
 			}
 			sweepEntities();
+			vectorMigration.start();
 		}, heartbeatMinutes * 6e4);
 		const unref = timer.unref;
 		if (typeof unref === "function") unref.call(timer);