@kenz1117/dsh-engram 0.7.1 → 0.7.3

package/lib/index.js

@@ -28,7 +28,15 @@ const CONFIG_KEYS = /* @__PURE__ */ new Set([
 	"injectTokenBudget",
 	"rankRecencyWeight",
 	"rankProofWeight",
-	"queryRewrite"
+	"queryRewrite",
+	"autoSlot",
+	"reviewScheduling",
+	"historyBackfillDays",
+	"historyBackfillMaxTurnsPerSession",
+	"historyBackfillMaxTotalTurns",
+	"historyBackfillIncludeSubagents",
+	"historyBackfillIncludeSeeded",
+	"historyBackfillIncludeNoCwd"
 ]);
 const INGEST_MODES = /* @__PURE__ */ new Set([
 	"off",
@@ -50,13 +58,21 @@ const Config = z.object({
 	injectTokenBudget: z.number().step(1).min(128).max(8192),
 	rankRecencyWeight: z.number().min(0).max(2),
 	rankProofWeight: z.number().min(0).max(2),
-	queryRewrite: z.boolean()
+	queryRewrite: z.boolean(),
+	autoSlot: z.boolean(),
+	reviewScheduling: z.boolean(),
+	historyBackfillDays: z.number().step(1).min(0).max(3650),
+	historyBackfillMaxTurnsPerSession: z.number().step(1).min(1).max(500),
+	historyBackfillMaxTotalTurns: z.number().step(1).min(1).max(5e3),
+	historyBackfillIncludeSubagents: z.boolean(),
+	historyBackfillIncludeSeeded: z.boolean(),
+	historyBackfillIncludeNoCwd: z.boolean()
 });
 /**
 * 显式 resolve 步骤：默认值只在唯一的此处落地，非法值 loud 失败。
 * @param config - cordis.yml 传入的未校验配置。
 * @returns 完整解析配置。
-* @throws 未知键、ingest 档位非法、provider/model 只给其一、decay/预算/排序权重越界时抛错。
+* @throws 未知键、ingest 档位非法、provider/model 只给其一、decay/预算/排序权重/历史回填规则越界时抛错。
 */
 function resolveConfig(config = {}) {
 	for (const key of Object.keys(config)) if (!CONFIG_KEYS.has(key)) throw new Error(`dsh-engram: unknown config key "${key}"`);
@@ -70,6 +86,9 @@ function resolveConfig(config = {}) {
 	if (config.injectTokenBudget !== void 0 && (!Number.isInteger(config.injectTokenBudget) || config.injectTokenBudget < 128 || config.injectTokenBudget > 8192)) throw new Error("dsh-engram: injectTokenBudget must be an integer in [128, 8192]");
 	if (config.rankRecencyWeight !== void 0 && (config.rankRecencyWeight < 0 || config.rankRecencyWeight > 2)) throw new Error("dsh-engram: rankRecencyWeight must be in [0, 2]");
 	if (config.rankProofWeight !== void 0 && (config.rankProofWeight < 0 || config.rankProofWeight > 2)) throw new Error("dsh-engram: rankProofWeight must be in [0, 2]");
+	if (config.historyBackfillDays !== void 0 && (!Number.isInteger(config.historyBackfillDays) || config.historyBackfillDays < 0 || config.historyBackfillDays > 3650)) throw new Error("dsh-engram: historyBackfillDays must be an integer in [0, 3650] (0 = unlimited)");
+	if (config.historyBackfillMaxTurnsPerSession !== void 0 && (!Number.isInteger(config.historyBackfillMaxTurnsPerSession) || config.historyBackfillMaxTurnsPerSession < 1 || config.historyBackfillMaxTurnsPerSession > 500)) throw new Error("dsh-engram: historyBackfillMaxTurnsPerSession must be an integer in [1, 500]");
+	if (config.historyBackfillMaxTotalTurns !== void 0 && (!Number.isInteger(config.historyBackfillMaxTotalTurns) || config.historyBackfillMaxTotalTurns < 1 || config.historyBackfillMaxTotalTurns > 5e3)) throw new Error("dsh-engram: historyBackfillMaxTotalTurns must be an integer in [1, 5000]");
 	const dbDir = config.dbDir ?? join(homedir(), ".dsh", "engram");
 	return {
 		dbDir,
@@ -87,7 +106,17 @@ function resolveConfig(config = {}) {
 		injectTokenBudget: config.injectTokenBudget ?? 1024,
 		rankRecencyWeight: config.rankRecencyWeight ?? .2,
 		rankProofWeight: config.rankProofWeight ?? .1,
-		queryRewrite: config.queryRewrite ?? true
+		queryRewrite: config.queryRewrite ?? true,
+		autoSlot: config.autoSlot ?? true,
+		reviewScheduling: config.reviewScheduling ?? true,
+		historyBackfill: {
+			days: config.historyBackfillDays ?? 7,
+			maxTurnsPerSession: config.historyBackfillMaxTurnsPerSession ?? 20,
+			maxTotalTurns: config.historyBackfillMaxTotalTurns ?? 200,
+			includeSubagents: config.historyBackfillIncludeSubagents ?? false,
+			includeSeeded: config.historyBackfillIncludeSeeded ?? false,
+			includeNoCwd: config.historyBackfillIncludeNoCwd ?? false
+		}
 	};
 }
 //#endregion
@@ -575,8 +604,11 @@ function throttleDecision(events) {
 	if (forbidsCapture(joined)) return "capture-forbidden";
 	return null;
 }
-/** 各 turn/start 事件的下标与轮次号（缺 data.turn 时轮次为 undefined）。 */
+/** 各 turn/start 事件的下标与轮次号（缺 data.turn 时轮次为 undefined）。
+*  events 允许 undefined：会话 dispose 后事件源已 detach，宿主可能给不出日志，
+*  此时按空日志处理而不是抛 TypeError（调用方在会话生命周期之外，异常会变成未处理 rejection）。 */
 function turnStarts(events) {
+	if (events === void 0) return [];
 	const starts = [];
 	for (let i = 0; i < events.length; i++) {
 		if (events[i]?.type !== "turn/start") continue;
@@ -647,7 +679,7 @@ async function ingestPreviousTurn(deps) {
 		written: 0,
 		skipped: "already-ingested"
 	};
-	if (sliceMode === "previous") {
+	if (sliceMode === "previous" || deps.throttle === true) {
 		const throttled = throttleDecision(slice);
 		if (throttled !== null) return {
 			scannedEvents: slice.length,
@@ -717,7 +749,7 @@ async function ingestPreviousTurn(deps) {
 		}
 		if (writtenContents.includes(content)) continue;
 		await store.write({
-			scope: "user",
+			scope: deps.writeScope ?? "user",
 			kind,
 			content,
 			importance,
@@ -725,7 +757,8 @@ async function ingestPreviousTurn(deps) {
 			sourceSessionId: deps.sessionId,
 			sourceRound: round,
 			...minSeq === null ? {} : { sourceSeq: minSeq },
-			...embedder === void 0 ? {} : { embedding: (await embedder.embed([content]))[0] }
+			...embedder === void 0 ? {} : { embedding: (await embedder.embed([content]))[0] },
+			...deps.history === true ? { initialReviewAt: null } : {}
 		});
 		writtenContents.push(content);
 		written += 1;
@@ -751,18 +784,22 @@ async function markPendingIngest(store, sessionId, turn) {
 * 会话结束时的末轮摄取：切片为最后一个 turn/start 到日志末尾，复用提炼管线。
 * 失败/超时只告警并把 (sessionId, turn) pending 键写入 op_log（下次会话首次
 * pre-step 重放补做），绝不影响对话。
+* 本函数不 reject：从取轮次到摄取全程在 try 内，异常一律降级为告警 + pending 键
+* （dispose 观察器是 fire-and-forget，逃逸的 rejection 会被宿主的 fail-loud 当作致命错误）。
 * @returns 摄取结果；无末轮或失败（已落 pending）时返回 null。
 */
 async function ingestFinalTurn(deps) {
-	const round = lastTurnNumber(deps.events);
-	if (round === void 0) return null;
+	/** 末轮轮次号；取不到（无 turn/start 或事件源不可用）时不落 pending——键需要轮次。 */
+	let round;
 	try {
+		round = lastTurnNumber(deps.events);
+		if (round === void 0) return null;
 		return await ingestPreviousTurn({
 			...deps,
 			slice: "last"
 		});
 	} catch (error) {
-		try {
+		if (round !== void 0) try {
 			await markPendingIngest(await deps.openStore(), deps.sessionId, round);
 		} catch {}
 		console.warn("[dsh-engram] 会话结束的末轮摄取失败（已记入待补做队列，不影响对话）：", error);
@@ -811,6 +848,286 @@ async function replayPendingIngests(deps) {
 	};
 }
 //#endregion
+//#region src/ingest/history.ts
+const DAY_MS$1 = 864e5;
+/** 估算时并发读取的会话数（读取是 IO，适度并发；摄取阶段始终串行）。 */
+const ESTIMATE_CONCURRENCY = 4;
+/**
+* 合并规则：默认值来自 Config，覆盖项来自面板/工具；总轮数上限是硬顶（只能调低）。
+* @param defaults - 配置默认规则。
+* @param overrides - 本次覆盖项。
+* @returns 生效规则。
+* @throws 覆盖项越界时抛错（与配置校验同界）。
+*/
+function mergeHistoryRules(defaults, overrides) {
+	const days = overrides.days ?? defaults.days;
+	if (!Number.isInteger(days) || days < 0 || days > 3650) throw new Error("historyBackfill: days 必须是 [0, 3650] 的整数（0 = 不限）");
+	const maxTurnsPerSession = overrides.maxTurnsPerSession ?? defaults.maxTurnsPerSession;
+	if (!Number.isInteger(maxTurnsPerSession) || maxTurnsPerSession < 1 || maxTurnsPerSession > 500) throw new Error("historyBackfill: maxTurnsPerSession 必须是 [1, 500] 的整数");
+	const maxTotalTurns = overrides.maxTotalTurns ?? defaults.maxTotalTurns;
+	if (!Number.isInteger(maxTotalTurns) || maxTotalTurns < 1 || maxTotalTurns > 5e3) throw new Error("historyBackfill: maxTotalTurns 必须是 [1, 5000] 的整数");
+	if ((overrides.provider !== void 0 && overrides.provider !== "") !== (overrides.model !== void 0 && overrides.model !== "")) throw new Error("historyBackfill: provider 与 model 必须成对提供");
+	return {
+		days,
+		maxTurnsPerSession,
+		maxTotalTurns: Math.min(maxTotalTurns, defaults.maxTotalTurns),
+		includeSubagents: overrides.includeSubagents ?? defaults.includeSubagents,
+		includeSeeded: overrides.includeSeeded ?? defaults.includeSeeded,
+		includeNoCwd: overrides.includeNoCwd ?? defaults.includeNoCwd
+	};
+}
+/** 事件流里的轮次号（按出现顺序，缺 data.turn 的 turn/start 忽略）。 */
+function turnNumbers(events) {
+	const turns = [];
+	for (const event of events) {
+		if (event.type !== "turn/start") continue;
+		const turn = event.data?.turn;
+		if (typeof turn === "number" && Number.isFinite(turn)) turns.push(turn);
+	}
+	return turns;
+}
+/** 单个会话的日志是否读取成功（失败返回 undefined，调用方计入 unreadable）。 */
+async function loadSession(source, id) {
+	try {
+		return (await source.load(id)).events;
+	} catch {
+		return;
+	}
+}
+/**
+* 枚举并筛选可回填的会话：过滤子代理/种子/无 cwd/超窗，按单会话与总轮数上限截断。
+* @param deps - 历史回填依赖。
+* @param rules - 生效规则。
+* @returns 候选会话与排除统计。
+*/
+async function selectSessions(deps, rules) {
+	const source = deps.source;
+	if (source === void 0) return {
+		candidates: [],
+		skipped: {
+			subagent: 0,
+			seeded: 0,
+			noCwd: 0,
+			tooOld: 0,
+			unreadable: 0
+		},
+		truncated: false
+	};
+	const now = (deps.now ?? Date.now)();
+	const headers = await source.list();
+	const skipped = {
+		subagent: 0,
+		seeded: 0,
+		noCwd: 0,
+		tooOld: 0,
+		unreadable: 0
+	};
+	/** 时间窗内、需要读日志的 header（按创建时间倒序，先处理最近的）。 */
+	const kept = [];
+	for (const header of [...headers].sort((a, b) => b.createdAt - a.createdAt)) {
+		if (header.origin === "subagent" && !rules.includeSubagents) {
+			skipped.subagent += 1;
+			continue;
+		}
+		if (header.isSeeded === true && !rules.includeSeeded) {
+			skipped.seeded += 1;
+			continue;
+		}
+		if ((header.cwd === void 0 || header.cwd === "") && !rules.includeNoCwd) {
+			skipped.noCwd += 1;
+			continue;
+		}
+		if (rules.days > 0 && header.createdAt < now - rules.days * DAY_MS$1) {
+			skipped.tooOld += 1;
+			continue;
+		}
+		kept.push(header);
+	}
+	const loaded = [];
+	for (let i = 0; i < kept.length; i += ESTIMATE_CONCURRENCY) {
+		const batch = kept.slice(i, i + ESTIMATE_CONCURRENCY);
+		const settled = await Promise.all(batch.map(async (header) => {
+			const events = await loadSession(source, header.id);
+			if (events === void 0) {
+				skipped.unreadable += 1;
+				return;
+			}
+			const all = turnNumbers(events);
+			const turns = all.slice(Math.max(0, all.length - rules.maxTurnsPerSession));
+			if (turns.length === 0) return void 0;
+			const cwd = header.cwd;
+			return cwd === void 0 || cwd === "" ? {
+				header,
+				events,
+				turns,
+				openStore: deps.openUserStore,
+				writeScope: "user",
+				storeKey: "user"
+			} : {
+				header,
+				events,
+				turns,
+				openStore: () => deps.resolveStore(cwd),
+				writeScope: "project",
+				storeKey: cwd
+			};
+		}));
+		loaded.push(...settled);
+	}
+	const candidates = [];
+	let budget = rules.maxTotalTurns;
+	let truncated = false;
+	for (const candidate of loaded) {
+		if (candidate === void 0) continue;
+		if (budget <= 0) {
+			truncated = true;
+			continue;
+		}
+		const allowed = candidate.turns.slice(Math.max(0, candidate.turns.length - budget));
+		if (allowed.length < candidate.turns.length) truncated = true;
+		candidates.push({
+			...candidate,
+			turns: allowed
+		});
+		budget -= allowed.length;
+	}
+	return {
+		candidates,
+		skipped,
+		truncated
+	};
+}
+/** 环境不支持读取历史会话时的统一说明。 */
+const UNAVAILABLE_REASON = "当前环境未挂载会话持久化服务（会话日志不可读，例如 headless 组合），无法回填历史会话";
+/**
+* 估算：候选会话数、规则内轮数、以及扣掉已摄取后的真正待处理轮数。
+* 估算阶段只在库文件已存在时打开目标库（不创建空库、不写入）。
+* @param deps - 历史回填依赖。
+* @param defaults - 配置默认规则。
+* @param overrides - 本次覆盖项。
+* @returns 估算结果；环境不支持时 `unavailable` 有值。
+*/
+async function estimateHistoryBackfill(deps, defaults, overrides = {}) {
+	const rules = mergeHistoryRules(defaults, overrides);
+	if (deps.source === void 0) return {
+		rules,
+		candidates: 0,
+		eligibleTurns: 0,
+		pendingTurns: 0,
+		alreadyIngested: 0,
+		skipped: {
+			subagent: 0,
+			seeded: 0,
+			noCwd: 0,
+			tooOld: 0,
+			unreadable: 0
+		},
+		truncated: false,
+		unavailable: UNAVAILABLE_REASON
+	};
+	const { candidates, skipped, truncated } = await selectSessions(deps, rules);
+	let eligibleTurns = 0;
+	let alreadyIngested = 0;
+	for (const candidate of candidates) {
+		eligibleTurns += candidate.turns.length;
+		const store = candidate.writeScope === "user" ? await deps.resolveExistingUserStore() : await deps.resolveExistingStore(candidate.storeKey);
+		if (store === void 0) continue;
+		for (const turn of candidate.turns) if (await store.hasAudit("ingest-done", encodeTurnKey(candidate.header.id, turn))) alreadyIngested += 1;
+	}
+	return {
+		rules,
+		candidates: candidates.length,
+		eligibleTurns,
+		pendingTurns: eligibleTurns - alreadyIngested,
+		alreadyIngested,
+		skipped,
+		truncated
+	};
+}
+/**
+* 执行回填：逐会话、逐轮调用实时摄取管线；单轮失败只记录并继续，中断后重跑只补未完成轮次。
+* @param deps - 历史回填依赖。
+* @param defaults - 配置默认规则。
+* @param overrides - 本次覆盖项。
+* @param onProgress - 进度回调（每个会话结束时调用一次）。
+* @param signal - 取消信号（面板「暂停」/工具超时）。
+* @returns 运行结果。
+*/
+async function runHistoryBackfill(deps, defaults, overrides, onProgress, signal) {
+	const rules = mergeHistoryRules(defaults, overrides);
+	const { candidates } = deps.source === void 0 ? { candidates: [] } : await selectSessions(deps, rules);
+	const routeOverride = overrides.provider !== void 0 && overrides.model !== void 0 ? {
+		provider: overrides.provider,
+		model: overrides.model
+	} : deps.routeOverride;
+	const failures = [];
+	/** 内部可变累加器（对外以只读的 HistoryRunProgress 暴露）。 */
+	const progress = {
+		state: "running",
+		sessionsTotal: candidates.length,
+		sessionsDone: 0,
+		turnsPlanned: candidates.reduce((sum, candidate) => sum + candidate.turns.length, 0),
+		turnsDone: 0,
+		memoriesWritten: 0,
+		turnsSkipped: 0,
+		turnsFailed: 0,
+		skipReasons: {}
+	};
+	onProgress({ ...progress });
+	for (const candidate of candidates) {
+		if (signal.aborted) break;
+		for (const turn of candidate.turns) {
+			if (signal.aborted) break;
+			try {
+				const outcome = await ingestPreviousTurn({
+					events: candidate.events,
+					sessionId: candidate.header.id,
+					turn,
+					slice: turn,
+					openStore: () => candidate.openStore(),
+					embedder: deps.embedder,
+					mode: deps.mode,
+					routeOverride,
+					call: deps.call,
+					logRequest: deps.logRequest,
+					signal,
+					throttle: true,
+					history: true,
+					writeScope: candidate.writeScope
+				});
+				progress.memoriesWritten += outcome.written;
+				if (outcome.skipped !== null) {
+					progress.turnsSkipped += 1;
+					progress.skipReasons[outcome.skipped] = (progress.skipReasons[outcome.skipped] ?? 0) + 1;
+				}
+			} catch (error) {
+				progress.turnsFailed += 1;
+				failures.push({
+					sessionId: candidate.header.id,
+					turn,
+					reason: error instanceof Error ? error.message : String(error)
+				});
+			}
+			progress.turnsDone += 1;
+		}
+		progress.sessionsDone += 1;
+		onProgress({
+			...progress,
+			currentSession: candidate.header.id
+		});
+	}
+	const state = signal.aborted ? "cancelled" : "done";
+	onProgress({
+		...progress,
+		state
+	});
+	return {
+		...progress,
+		state,
+		failures
+	};
+}
+//#endregion
 //#region src/consolidation/run.ts
 /** 单条整理动作（写入 op_log 的统一标记）。 */
 const CONSOLIDATION_OP = "consolidation";
@@ -958,11 +1275,11 @@ function cosine$1(a, b) {
 //#region src/mirror/markdown.ts
 /**
 * Markdown 镜像：把 SQLite 记忆库导出为可被 Obsidian / VS Code / git 直接漫游的
-* 文件树，每个房间一个 .md + frontmatter，附楼层清单 _meta.json 与全宫殿入口 _index.md。
+* 文件树：按房间（kind）分目录，每条记忆一个 .md + frontmatter，附房间清单 _meta.json 与全宫殿入口 _index.md。
 * 写入过程全部幂等：重复执行只会覆盖同名文件，不会向 SQLite 写任何东西（只读）。
 * @module @kenz1117/dsh-engram/mirror/markdown
 */
-/** 房间铭牌 URL/路径安全的 slug（仅 ASCII、连字符分隔）。 */
+/** 记忆铭牌 URL/路径安全的 slug（仅 ASCII、连字符分隔）。 */
 function slugify(input) {
 	const stripped = input.toLowerCase().replace(/[\u4e00-\u9fa5]+/g, "记").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 	return stripped === "" ? "untitled" : stripped.slice(0, 32);
@@ -977,30 +1294,31 @@ function yaml(value) {
 function iso(ms) {
 	return new Date(ms).toISOString();
 }
-/** 楼层中文别名（与面板 i18n 的 kindLabel 保持一致；只用做目录名）。 */
-const FLOOR_LABEL = {
-	fact: "fact",
-	preference: "preference",
-	decision: "decision",
-	episode: "episode",
-	skill: "skill"
+/** 房间展示名（kind → 中文房间名；与 client 词典的 kindFact… 对应，host 侧不引 client 模块）。
+*  仅用于 _index.md 的可读标签，目录名仍用 kind 原值以保持路径稳定。 */
+const ROOM_LABEL = {
+	fact: "事实厅",
+	preference: "偏好阁",
+	decision: "决策堂",
+	episode: "往事廊",
+	skill: "技法坊"
 };
-/** 顶层 _index.md 的纯文本模板（楼层卡片 + 房间清单链接）。 */
-function renderIndex(scope, data, floors) {
+/** 顶层 _index.md 的纯文本模板（房间导览 + 记忆清单链接）。 */
+function renderIndex(scope, data, rooms) {
 	const total = data.records.length;
 	const active = data.records.filter((r) => r.status === "active").length;
 	const edges = data.edges.length;
 	return `# 记忆宫殿 · ${scope === "user" ? "私人宫殿" : "项目宫殿"}\n` + [
 		"",
-		`> 导出时间 ${iso(data.exportedAt)} · 共 **${total}** 间房间（对外开放 ${active}） · 走廊 ${edges} 条`,
+		`> 导出时间 ${iso(data.exportedAt)} · 共 **${total}** 条记忆（对外开放 ${active}） · 走廊 ${edges} 条`,
 		"",
-		"## 楼层导览",
+		"## 房间导览",
 		"",
-		...floors.map((f) => `- **${FLOOR_LABEL[f.kind] ?? f.kind} 层** · ${f.roomCount} 间（开放 ${f.active} · 展厅 ${f.archived} · 闭馆 ${f.forgotten}）`),
+		...rooms.map((room) => `- **${ROOM_LABEL[room.kind] ?? room.kind}** · ${room.memoryCount} 条记忆（开放 ${room.active} · 展厅 ${room.archived} · 闭馆 ${room.forgotten}）`),
 		"",
-		"## 房间清单",
+		"## 记忆清单",
 		"",
-		...data.records.slice().sort((a, b) => b.importance - a.importance).map((record) => `- [${record.status === "active" ? "●" : record.status === "archived" ? "◇" : "×"}][${FLOOR_LABEL[record.kind] ?? record.kind}] ${record.content.slice(0, 60)}${record.content.length > 60 ? "…" : ""} — [[${record.id.slice(0, 8)}]]`),
+		...data.records.slice().sort((a, b) => b.importance - a.importance).map((record) => `- [${record.status === "active" ? "●" : record.status === "archived" ? "◇" : "×"}][${ROOM_LABEL[record.kind] ?? record.kind}] ${record.content.slice(0, 60)}${record.content.length > 60 ? "…" : ""} — [[${record.id.slice(0, 8)}]]`),
 		"",
 		"## 走廊（关系边）",
 		"",
@@ -1008,8 +1326,8 @@ function renderIndex(scope, data, floors) {
 		""
 	].join("\n");
 }
-/** 单房间 .md 模板：YAML frontmatter + 铭牌正文 + 走廊列表。 */
-function renderRoom(record, edges) {
+/** 单条记忆 .md 模板：YAML frontmatter + 铭牌正文 + 走廊列表。 */
+function renderMemory(record, edges) {
 	const relEdges = edges.filter((edge) => edge.from === record.id || edge.to === record.id);
 	const tags = [];
 	if (record.outcome !== void 0) tags.push(`outcome-${record.outcome}`);
@@ -1035,13 +1353,13 @@ function renderRoom(record, edges) {
 		"---"
 	].join("\n");
 	const body = [
-		`# ${record.content.split("\n")[0]?.slice(0, 80) ?? "房间铭牌"}`,
+		`# ${record.content.split("\n")[0]?.slice(0, 80) ?? "记忆铭牌"}`,
 		"",
 		record.content,
 		"",
 		"## 走廊",
 		"",
-		...relEdges.length === 0 ? ["（此房间暂未连接任何走廊）"] : relEdges.map((edge) => {
+		...relEdges.length === 0 ? ["（此记忆暂未连接任何走廊）"] : relEdges.map((edge) => {
 			const other = edge.from === record.id ? edge.to : edge.from;
 			return `- ${edge.from === record.id ? "→" : "←"} \`${other.slice(0, 8)}\`（${edge.type}）`;
 		}),
@@ -1049,27 +1367,27 @@ function renderRoom(record, edges) {
 	].join("\n");
 	return frontmatter + "\n" + body;
 }
-/** 楼层 _meta.json 模板。 */
-function renderMeta(scope, data, floors) {
+/** 房间清单 _meta.json 模板。 */
+function renderMeta(scope, data, rooms) {
 	const payload = {
 		scope,
 		exportedAt: data.exportedAt,
 		total: data.records.length,
-		floors
+		rooms
 	};
 	return JSON.stringify(payload, null, 2) + "\n";
 }
-/** 计算楼层摘要（按 kind 分组统计 active/archived/forgotten）。 */
-function summarizeFloors(records) {
+/** 计算房间摘要（按 kind 分组统计 active/archived/forgotten 的记忆条数）。 */
+function summarizeRooms(records) {
 	const map = /* @__PURE__ */ new Map();
 	for (const record of records) {
 		const entry = map.get(record.kind) ?? {
-			roomCount: 0,
+			memoryCount: 0,
 			active: 0,
 			archived: 0,
 			forgotten: 0
 		};
-		entry.roomCount += 1;
+		entry.memoryCount += 1;
 		if (record.status === "active") entry.active += 1;
 		else if (record.status === "archived") entry.archived += 1;
 		else if (record.status === "forgotten") entry.forgotten += 1;
@@ -1084,7 +1402,7 @@ function summarizeFloors(records) {
 * 把一份 exportAll 数据写入镜像目录。
 * @param rootDir - 镜像根目录（通常 `${exportDir}/mirror/<scope>/`，由调用方拼）。
 * @param data - exportAll 的产物（含 records + edges）。
-* @returns 写入摘要（rootDir / fileCount / floors）。
+* @returns 写入摘要（rootDir / fileCount / rooms）。
 */
 async function writeMirror(rootDir, data) {
 	const scope = data.records[0]?.scope ?? "user";
@@ -1092,7 +1410,7 @@ async function writeMirror(rootDir, data) {
 		recursive: true,
 		mode: 448
 	});
-	const floors = summarizeFloors(data.records);
+	const rooms = summarizeRooms(data.records);
 	const recordsByKind = /* @__PURE__ */ new Map();
 	for (const record of data.records) {
 		const list = recordsByKind.get(record.kind) ?? [];
@@ -1101,20 +1419,20 @@ async function writeMirror(rootDir, data) {
 	}
 	let fileCount = 0;
 	for (const record of data.records) {
-		const floor = recordsByKind.get(record.kind);
-		if (floor === void 0) continue;
-		const indexInFloor = floor.indexOf(record);
-		const floorDir = join(rootDir, FLOOR_LABEL[record.kind] ?? record.kind);
-		await mkdir(floorDir, {
+		const roomRecords = recordsByKind.get(record.kind);
+		if (roomRecords === void 0) continue;
+		const indexInRoom = roomRecords.indexOf(record);
+		const roomDir = join(rootDir, record.kind);
+		await mkdir(roomDir, {
 			recursive: true,
 			mode: 448
 		});
-		const fileName = `${record.id.slice(0, 8)}-${slugify(record.content)}-${String(indexInFloor).padStart(3, "0")}.md`;
-		await writeFile(join(floorDir, fileName), renderRoom(record, data.edges), { mode: 384 });
+		const fileName = `${record.id.slice(0, 8)}-${slugify(record.content)}-${String(indexInRoom).padStart(3, "0")}.md`;
+		await writeFile(join(roomDir, fileName), renderMemory(record, data.edges), { mode: 384 });
 		fileCount += 1;
 	}
-	await writeFile(join(rootDir, "_index.md"), renderIndex(scope, data, floors), { mode: 384 });
-	await writeFile(join(rootDir, "_meta.json"), renderMeta(scope, data, floors), { mode: 384 });
+	await writeFile(join(rootDir, "_index.md"), renderIndex(scope, data, rooms), { mode: 384 });
+	await writeFile(join(rootDir, "_meta.json"), renderMeta(scope, data, rooms), { mode: 384 });
 	fileCount += 2;
 	if (scope === "shared") {
 		const manifest = buildShareManifest(data);
@@ -1124,7 +1442,7 @@ async function writeMirror(rootDir, data) {
 	return {
 		rootDir,
 		fileCount,
-		floors,
+		rooms,
 		exportedAt: data.exportedAt
 	};
 }
@@ -1146,7 +1464,7 @@ function buildShareManifest(data, now = Date.now()) {
 	return {
 		generatedAt: now,
 		scope: "shared",
-		roomCount: loans.length,
+		memoryCount: loans.length,
 		loans
 	};
 }
@@ -1434,7 +1752,7 @@ function buildTourProposal(scope, records, focusKind) {
 		return focusBoost(b) * 1e3 + b.importance * b.confidence * 100 - scoreA;
 	}).slice(0, limit);
 	return {
-		greeting: empty ? `[${scope}] 宫殿尚空。建议：先放第一段记忆（例如一条 fact 或 preference），让后续会话有锚点可循。` : `[${scope}] 宫殿现存 ${active.length} 间 active 房间。建议开场巡游：${scored.map((r, i) => `第 ${i + 1} 站「${r.content.slice(0, 24)}${r.content.length > 24 ? "…" : ""}」`).join("；")}。`,
+		greeting: empty ? `[${scope}] 宫殿尚空。建议：先放第一段记忆（例如一条 fact 或 preference），让后续会话有锚点可循。` : `[${scope}] 宫殿现存 ${active.length} 条 active 记忆。建议开场巡游：${scored.map((r, i) => `第 ${i + 1} 站「${r.content.slice(0, 24)}${r.content.length > 24 ? "…" : ""}」`).join("；")}。`,
 		suggestedStops: scored,
 		activeCount: active.length,
 		empty
@@ -1444,6 +1762,7 @@ function buildTourProposal(scope, records, focusKind) {
 //#region src/refurb.ts
 /** 缺省参数。 */
 const DEFAULT_REFURB_OPTIONS = {
+	minActive: 8,
 	demoteBelow: .2,
 	staleDays: 60,
 	duplicateTitleWindow: 0
@@ -1451,11 +1770,13 @@ const DEFAULT_REFURB_OPTIONS = {
 /**
 * 扫描一组 active 条目，按规则生成翻新建议。
 * 仅扫描同 scope 内的内容；跨 scope 的相似合并留给上层判定。
+* active 条目少于 `options.minActive` 时返回空列表：小库样本太少，逐条命中噪声大于价值。
 */
 function gatherRefurbSuggestions(records, options = DEFAULT_REFURB_OPTIONS) {
 	const suggestions = [];
 	const now = Date.now();
 	const active = records.filter((r) => r.status === "active");
+	if (active.length < options.minActive) return [];
 	const byScope = /* @__PURE__ */ new Map();
 	for (const record of active) {
 		const list = byScope.get(record.scope) ?? [];
@@ -1493,7 +1814,7 @@ function gatherRefurbSuggestions(records, options = DEFAULT_REFURB_OPTIONS) {
 					primaryId: record.id,
 					candidates: dupes.map((d) => d.id),
 					scope,
-					reason: `与 ${dupes.length} 间房间内容前 20 字重复，建议蒸馏合并。`,
+					reason: `与 ${dupes.length} 条记忆内容前 20 字重复，建议蒸馏合并。`,
 					confidence: .6
 				});
 			}
@@ -1512,9 +1833,22 @@ function gatherRefurbSuggestions(records, options = DEFAULT_REFURB_OPTIONS) {
 		primaryId: record.id,
 		candidates: [],
 		scope: record.scope,
-		reason: `内容长度 ${record.content.length} > 400，建议拆为多条独立房间。`,
+		reason: `内容长度 ${record.content.length} > 400，建议拆为多条独立记忆。`,
 		confidence: .6
 	});
+	for (const record of active) {
+		const score = record.imageryScore;
+		if (score !== void 0 && score >= .5) continue;
+		const slot = record.slot === void 0 ? "" : `${record.slot.room}#${record.slot.index} `;
+		suggestions.push({
+			action: "review",
+			primaryId: record.id,
+			candidates: [],
+			scope: record.scope,
+			reason: score === void 0 ? `${slot}未挂门牌：宫殿纪律要求每个标记唯一、差异化、带日期，建议用 engram_update 的 placard 参数补挂。` : `${slot}门牌得分 ${score.toFixed(2)} < 0.5（不合唯一/差异化/带日期纪律），建议重写铭牌。`,
+			confidence: .4
+		});
+	}
 	return suggestions;
 }
 //#endregion
@@ -1591,6 +1925,36 @@ function scopeOf$1(raw, fallback) {
 	if (raw === "user" || raw === "project" || raw === "shared") return raw;
 	return fallback;
 }
+/** 宽松取数：数字与数字字符串都接受，其余返回 undefined（回退配置默认）。 */
+function toNumber(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim() !== "") {
+		const parsed = Number(value);
+		if (Number.isFinite(parsed)) return parsed;
+	}
+}
+/** 宽松取布尔：真值/假值的字符串与布尔都接受，其余返回 undefined。 */
+function toBoolean(value) {
+	if (value === true || value === "true") return true;
+	if (value === false || value === "false") return false;
+}
+/** 从 query 或 body 收敛历史回填规则（未给或非法的字段留给配置默认值）。 */
+function historyRulesOf(raw) {
+	const days = toNumber(raw["days"]);
+	const maxTurnsPerSession = toNumber(raw["maxTurnsPerSession"]);
+	const maxTotalTurns = toNumber(raw["maxTotalTurns"]);
+	const includeSubagents = toBoolean(raw["includeSubagents"]);
+	const includeSeeded = toBoolean(raw["includeSeeded"]);
+	const includeNoCwd = toBoolean(raw["includeNoCwd"]);
+	return {
+		...days === void 0 ? {} : { days },
+		...maxTurnsPerSession === void 0 ? {} : { maxTurnsPerSession },
+		...maxTotalTurns === void 0 ? {} : { maxTotalTurns },
+		...includeSubagents === void 0 ? {} : { includeSubagents },
+		...includeSeeded === void 0 ? {} : { includeSeeded },
+		...includeNoCwd === void 0 ? {} : { includeNoCwd }
+	};
+}
 /**
 * 注册 /engram 页面与 /api/engram/* 接口（effect 由调用方持有，disposer 可逆）。
 * @param ctx - 携带 webServer 服务的宿主上下文。
@@ -1625,6 +1989,7 @@ function registerEngramRoutes(ctx, deps) {
 						...kind !== null && kind !== "" && kind !== "all" ? { kind } : {},
 						...q !== null && q !== "" ? { q } : {},
 						...redacted === "true" || redacted === "false" ? { redacted: redacted === "true" } : {},
+						...url.searchParams.get("sort") === "tour" ? { sort: "tour" } : {},
 						limit,
 						offset
 					};
@@ -1679,6 +2044,48 @@ function registerEngramRoutes(ctx, deps) {
 					}))).flat().sort((a, b) => b.at - a.at).slice(0, limit) });
 					return;
 				}
+				if (req.method === "GET" && route === "review-due") {
+					const scope = scopeOf$1(url.searchParams.get("scope"), "user");
+					const limit = Math.min(50, Math.max(1, Number(url.searchParams.get("limit") ?? 20) || 20));
+					const now = Date.now();
+					json(res, 200, {
+						scope,
+						items: (await (await deps.openStore(scope)).dueReviews(now, limit)).map((record) => ({
+							id: record.id,
+							kind: record.kind,
+							...record.slot === void 0 ? {} : { slot: record.slot },
+							caption: record.imagery?.caption ?? null,
+							nextReviewAt: record.review?.nextReviewAt ?? null,
+							overdueDays: record.review?.nextReviewAt === null || record.review?.nextReviewAt === void 0 ? 0 : Math.max(0, Math.floor((now - record.review.nextReviewAt) / 864e5)),
+							reps: record.review?.reps ?? 0
+						}))
+					});
+					return;
+				}
+				if (req.method === "POST" && route === "review-answer") {
+					if (!guardWrite(req, res)) return;
+					const body = await readJsonBody(req);
+					if (body === null || typeof body.id !== "string" || body.id === "") {
+						json(res, 400, { error: "id required" });
+						return;
+					}
+					const grade = typeof body.grade === "number" && Number.isInteger(body.grade) && body.grade >= 0 && body.grade <= 5 ? body.grade : null;
+					if (grade === null) {
+						json(res, 400, { error: "grade must be an integer 0-5" });
+						return;
+					}
+					const scope = scopeOf$1(typeof body.scope === "string" ? body.scope : null, "user");
+					const record = await (await deps.openStore(scope)).scheduleReview(body.id, grade);
+					if (record === void 0) {
+						json(res, 404, { error: `未找到条目 ${body.id}` });
+						return;
+					}
+					json(res, 200, {
+						id: record.id,
+						review: record.review ?? null
+					});
+					return;
+				}
 				if (req.method === "GET" && route === "review") {
 					const scope = scopeOf$1(url.searchParams.get("scope"), "user");
 					const id = url.searchParams.get("id");
@@ -1694,6 +2101,53 @@ function registerEngramRoutes(ctx, deps) {
 					json(res, 200, view);
 					return;
 				}
+				if (req.method === "GET" && route === "review-due") {
+					const scope = scopeOf$1(url.searchParams.get("scope"), "user");
+					const limit = Math.min(50, Math.max(1, Number(url.searchParams.get("limit") ?? 20) || 20));
+					const now = Date.now();
+					const due = await (await deps.openStore(scope)).dueReviews(now, limit);
+					json(res, 200, {
+						scope,
+						count: due.length,
+						now,
+						items: due.map((record) => ({
+							id: record.id,
+							kind: record.kind,
+							scope: record.scope,
+							importance: record.importance,
+							confidence: record.confidence,
+							...record.slot === void 0 ? {} : { slot: record.slot },
+							...typeof record.imagery?.caption === "string" ? { caption: record.imagery.caption } : {},
+							...record.review?.nextReviewAt === null || record.review?.nextReviewAt === void 0 ? {} : { overdueDays: Math.max(0, Math.floor((now - record.review.nextReviewAt) / 864e5)) },
+							...record.review === void 0 ? {} : {
+								reps: record.review.reps,
+								intervalDays: record.review.intervalDays
+							}
+						}))
+					});
+					return;
+				}
+				if (req.method === "POST" && route === "review-answer") {
+					if (!guardWrite(req, res)) return;
+					const body = await readJsonBody(req);
+					if (body === null || typeof body.id !== "string" || body.id === "") {
+						json(res, 400, { error: "id required" });
+						return;
+					}
+					const grade = Number(body.grade);
+					if (!Number.isInteger(grade) || grade < 0 || grade > 5) {
+						json(res, 400, { error: "grade must be an integer 0-5" });
+						return;
+					}
+					const scope = scopeOf$1(typeof body.scope === "string" ? body.scope : null, "user");
+					const record = await (await deps.openStore(scope)).scheduleReview(body.id, grade);
+					if (record === void 0) {
+						json(res, 404, { error: `未找到条目 ${body.id}` });
+						return;
+					}
+					json(res, 200, { record });
+					return;
+				}
 				if (req.method === "GET" && route === "export") {
 					const scope = scopeOf$1(url.searchParams.get("scope"), "user");
 					const format = url.searchParams.get("format") === "json" ? "json" : "markdown";
@@ -1722,7 +2176,7 @@ function registerEngramRoutes(ctx, deps) {
 					json(res, 200, {
 						...await writeMirror(join(deps.mirrorDir, scope, stamp), data),
 						scope,
-						roomCount: data.records.length,
+						memoryCount: data.records.length,
 						edgeCount: data.edges.length
 					});
 					return;
@@ -1851,6 +2305,47 @@ function registerEngramRoutes(ctx, deps) {
 					});
 					return;
 				}
+				if (req.method === "GET" && route === "models") {
+					json(res, 200, await deps.history.models());
+					return;
+				}
+				if (req.method === "GET" && route === "history-backfill") {
+					json(res, 200, {
+						defaults: deps.history.defaults,
+						estimate: await deps.history.estimate(historyRulesOf(Object.fromEntries(url.searchParams)))
+					});
+					return;
+				}
+				if (req.method === "GET" && route === "history-backfill/status") {
+					json(res, 200, deps.history.status());
+					return;
+				}
+				if (req.method === "POST" && route === "history-backfill/start") {
+					if (!guardWrite(req, res)) return;
+					const body = await readJsonBody(req);
+					const started = deps.history.start(historyRulesOf(body ?? {}));
+					if (!started.ok) {
+						json(res, 409, {
+							ok: false,
+							error: started.reason ?? "无法启动回填"
+						});
+						return;
+					}
+					json(res, 200, {
+						ok: true,
+						status: deps.history.status()
+					});
+					return;
+				}
+				if (req.method === "POST" && route === "history-backfill/cancel") {
+					if (!guardWrite(req, res)) return;
+					deps.history.cancel();
+					json(res, 200, {
+						ok: true,
+						status: deps.history.status()
+					});
+					return;
+				}
 				if (req.method === "POST" && route === "consolidate") {
 					if (!guardWrite(req, res)) return;
 					const body = await readJsonBody(req);
@@ -2064,6 +2559,106 @@ function migrateProjectDb(dbDir, identity) {
 	}
 	return "none";
 }
+/** kind → 默认房间名。固定映射，保证同主题记忆总是聚在同一间（同类巩固）。 */
+const KIND_ROOMS = {
+	fact: "事实厅",
+	preference: "偏好阁",
+	decision: "决策堂",
+	episode: "往事廊",
+	skill: "技法坊"
+};
+/**
+* 为新条目分配桩位。
+* @param kind - 记忆种类（决定默认房间）。
+* @param occupancy - 各房间占用状态（store.slotCountsByRoom() 的快照）。
+* @returns 分配的桩位与是否开了新房（开新房时调用方应记 op_log 提醒人工命名/拆分）。
+*/
+function assignSlot(kind, occupancy) {
+	const base = KIND_ROOMS[kind];
+	for (let n = 1;; n += 1) {
+		const room = n === 1 ? base : `${base}-${n}`;
+		const state = occupancy[room];
+		if (state === void 0) return {
+			slot: {
+				room,
+				index: 1
+			},
+			openedNewRoom: n > 1
+		};
+		if (state.count < 9) return {
+			slot: {
+				room,
+				index: state.maxIndex + 1
+			},
+			openedNewRoom: false
+		};
+	}
+}
+//#endregion
+//#region src/review/sm2.ts
+/** ease 系数下限（SM-2 标准值）：低于此值记忆会陷入过密复习。 */
+const MIN_EASE = 1.3;
+const DAY_MS = 864e5;
+/**
+* 按回忆质量推进调度。
+* @param grade - 回忆质量 0-5（0/1 完全遗忘，2 模糊错误，3 勉强，4 正确有迟疑，5 完美）。
+* @param state - 当前调度状态。
+* @param now - 答题时刻（epoch 毫秒）。
+* @returns 新调度状态（不修改入参）。
+*/
+function nextSchedule(grade, state, now) {
+	if (grade < 3) {
+		const ease = Math.max(MIN_EASE, state.easeFactor + (.1 - (5 - grade) * (.08 + (5 - grade) * .02)));
+		return {
+			nextReviewAt: now + 1 * DAY_MS,
+			easeFactor: Math.round(ease * 100) / 100,
+			intervalDays: 1,
+			reps: 0
+		};
+	}
+	const reps = state.reps + 1;
+	const intervalDays = reps === 1 ? 1 : reps === 2 ? 6 : Math.max(1, Math.round(state.intervalDays * state.easeFactor));
+	const ease = Math.max(MIN_EASE, state.easeFactor + (.1 - (5 - grade) * (.08 + (5 - grade) * .02)));
+	return {
+		nextReviewAt: now + intervalDays * DAY_MS,
+		easeFactor: Math.round(ease * 100) / 100,
+		intervalDays,
+		reps
+	};
+}
+/** 日期/时间锚点：ISO 日期、中文年月、相对时间词。 */
+const DATE_ANCHOR = /\d{4}[-/年.]\s?\d{1,2}|[今昨]天|本周|上周|周[一二三四五六日天]|\d{1,2}月\d{1,2}[日号]/;
+/** 差异化比较的前缀长度：前 6 字相同即视为「近似到无法区分」。 */
+const DIFF_PREFIX_LEN = 6;
+/**
+* 计算门牌质量分（0-1，保留两位小数）。
+* 构成：caption 有效（4-30 字）且全库唯一 +0.4；带日期/时间锚点 +0.3；
+* 与同房既有门牌差异化（前 6 字不重复）+0.3。无 caption 记 0 分。
+* @param caption - 门牌文字（ImageryLabel.caption）；null/undefined 表示未挂牌。
+* @param context - 既有门牌快照。
+* @returns 0-1 的质量分。
+*/
+function scorePlacard(caption, context) {
+	if (caption === null || caption === void 0) return 0;
+	const text = caption.trim();
+	let score = 0;
+	const valid = text.length >= 4 && text.length <= 30;
+	if (valid && !context.existingCaptions.includes(text)) score += .4;
+	if (DATE_ANCHOR.test(text)) score += .3;
+	const prefix = text.slice(0, DIFF_PREFIX_LEN);
+	const clashes = context.roomCaptions.some((other) => other.slice(0, DIFF_PREFIX_LEN) === prefix);
+	if (valid && !clashes) score += .3;
+	return Math.round(Math.min(1, score) * 100) / 100;
+}
+/**
+* 低分门牌的增强建议（附在 engram_save 输出末尾，中文一行）。
+* @param score - scorePlacard 的得分。
+* @returns 建议文本；非低分返回 null。
+*/
+function placardImprovementHint(score) {
+	if (score >= .5) return null;
+	return "门牌不合规（宫殿纪律：唯一 · 差异化 · 带日期）：建议用 engram_update 的 imagery 参数挂一个 4-30 字、含日期锚点、与同房其他门牌前 6 字不重复的铭牌。";
+}
 //#endregion
 //#region src/store/sqlite.ts
 /**
@@ -2074,18 +2669,31 @@ function migrateProjectDb(dbDir, identity) {
 * @module @kenz1117/dsh-engram/store/sqlite
 */
 /** 当前 schema 版本；结构性变更必须 +1。可空列与伴随表走增量迁移（见 openEngramStore 的迁移段）。 */
-const SCHEMA_VERSION = 5;
+const SCHEMA_VERSION = 6;
 /** 增量迁移表：key 为起始版本，value 为升到下一版本的 SQL（可多语句）。
 *  v2 → v3：nodes 补可空列 outcome（使用效果回报）。
 *  v3 → v4：新增 nodes_revisions 修订表（update 归档旧条目时的内容快照）。
 *  v4 → v5：nodes 补 imagery_json 列（意象铭牌：caption + sensoryTags + emotionalValence + provisional）。
-*  v5 不再升版：闭馆三问用 op_log JSON 详情承载（已有 audit 接口），不改表结构。 */
+*  v5 → v6：桩位（slot_room/slot_index）、意象质量分（imagery_score）、SM-2 调度
+*   （next_review_at/ease_factor/interval_days/review_reps）+ 固定巡游路线表 tour_routes。
+*   全部可空或带默认值，存量条目零搬运；排桩由 backfillSlots 幂等补齐。 */
 const MIGRATIONS = {
 	"2": "ALTER TABLE nodes ADD COLUMN outcome TEXT",
 	"3": `CREATE TABLE IF NOT EXISTS nodes_revisions (
     node_id TEXT NOT NULL, content TEXT NOT NULL, kind TEXT NOT NULL,
     importance REAL NOT NULL, superseded_at INTEGER NOT NULL);`,
-	"4": "ALTER TABLE nodes ADD COLUMN imagery_json TEXT"
+	"4": "ALTER TABLE nodes ADD COLUMN imagery_json TEXT",
+	"5": `ALTER TABLE nodes ADD COLUMN slot_room TEXT;
+    ALTER TABLE nodes ADD COLUMN slot_index INTEGER;
+    ALTER TABLE nodes ADD COLUMN imagery_score REAL;
+    ALTER TABLE nodes ADD COLUMN next_review_at INTEGER;
+    ALTER TABLE nodes ADD COLUMN ease_factor REAL;
+    ALTER TABLE nodes ADD COLUMN interval_days REAL;
+    ALTER TABLE nodes ADD COLUMN review_reps INTEGER DEFAULT 0;
+    CREATE TABLE IF NOT EXISTS tour_routes (
+      position INTEGER PRIMARY KEY, node_id TEXT NOT NULL);
+    CREATE INDEX IF NOT EXISTS nodes_slot ON nodes (slot_room, slot_index);
+    CREATE INDEX IF NOT EXISTS nodes_review_due ON nodes (next_review_at);`
 };
 /** RRF 融合常数：score = Σ 1/(K + rank)。 */
 const RRF_K = 60;
@@ -2130,6 +2738,7 @@ function jsonToImagery(raw) {
 }
 function rowToRecord(row) {
 	const imagery = jsonToImagery(row.imagery_json);
+	const hasReviewState = row.next_review_at !== null || row.ease_factor !== null || row.interval_days !== null;
 	return {
 		id: asMemoryId(row.id),
 		scope: row.scope,
@@ -2145,7 +2754,18 @@ function rowToRecord(row) {
 		sourceSessionId: row.source_session_id,
 		sourceRound: row.source_round,
 		sourceSeq: row.source_seq,
-		...imagery === void 0 ? {} : { imagery }
+		...imagery === void 0 ? {} : { imagery },
+		...row.slot_room === null || row.slot_index === null ? {} : { slot: {
+			room: row.slot_room,
+			index: row.slot_index
+		} },
+		...row.imagery_score === null ? {} : { imageryScore: row.imagery_score },
+		...hasReviewState ? { review: {
+			nextReviewAt: row.next_review_at,
+			easeFactor: row.ease_factor ?? 2.5,
+			intervalDays: row.interval_days ?? 0,
+			reps: row.review_reps ?? 0
+		} } : {}
 	};
 }
 function blobToVec(blob) {
@@ -2198,14 +2818,20 @@ const NO_BOOST = {
 	proofWeight: 0,
 	decayAfterDays: 30
 };
+/** 缺省全开（config 的默认值也在此处对齐）。 */
+const DEFAULT_AUTOMATION = {
+	autoSlot: true,
+	reviewScheduling: true
+};
 /**
 * 打开（必要时创建）一个 scope 分库。
 * @param path - SQLite 文件路径；目录不存在会自动创建（0o700）。
 * @param rankBoost - 排序 boost 参数；缺省不乘任何因子。
+* @param automation - 写入期自动化开关（自动排桩/初始排期）；缺省全开。
 * @returns 就绪的 EngramStore。
 * @throws EngramError(code=SCHEMA_INCOMPATIBLE) 当库的 schema 版本高于当前实现。
 */
-async function openEngramStore(path, rankBoost = NO_BOOST) {
+async function openEngramStore(path, rankBoost = NO_BOOST, automation = DEFAULT_AUTOMATION) {
 	await mkdir(dirname(path), {
 		recursive: true,
 		mode: 448
@@ -2230,7 +2856,10 @@ async function openEngramStore(path, rankBoost = NO_BOOST) {
       importance REAL NOT NULL, confidence REAL NOT NULL, status TEXT NOT NULL,
       created_at INTEGER NOT NULL, last_accessed_at INTEGER NOT NULL, access_count INTEGER NOT NULL,
       source_session_id TEXT, source_round INTEGER, source_seq INTEGER, embedding BLOB, outcome TEXT,
-      imagery_json TEXT);
+      imagery_json TEXT,
+      slot_room TEXT, slot_index INTEGER, imagery_score REAL,
+      next_review_at INTEGER, ease_factor REAL, interval_days REAL,
+      review_reps INTEGER DEFAULT 0);
     CREATE TABLE IF NOT EXISTS edges (
       from_id TEXT NOT NULL, to_id TEXT NOT NULL, type TEXT NOT NULL, created_at INTEGER NOT NULL,
       PRIMARY KEY (from_id, to_id, type));
@@ -2240,12 +2869,17 @@ async function openEngramStore(path, rankBoost = NO_BOOST) {
     CREATE TABLE IF NOT EXISTS nodes_revisions (
       node_id TEXT NOT NULL, content TEXT NOT NULL, kind TEXT NOT NULL,
       importance REAL NOT NULL, superseded_at INTEGER NOT NULL);
+    CREATE TABLE IF NOT EXISTS tour_routes (
+      position INTEGER PRIMARY KEY, node_id TEXT NOT NULL);
     CREATE VIRTUAL TABLE IF NOT EXISTS nodes_fts USING fts5(node_id UNINDEXED, content, tokenize='unicode61');
     CREATE INDEX IF NOT EXISTS nodes_scope_status ON nodes (scope, status);
   `);
 	const versionRow = db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
-	if (versionRow === void 0) db.prepare("INSERT INTO meta (key, value) VALUES ('schema_version', ?)").run(String(SCHEMA_VERSION));
-	else {
+	if (versionRow === void 0) {
+		db.exec(`CREATE INDEX IF NOT EXISTS nodes_slot ON nodes (slot_room, slot_index);
+      CREATE INDEX IF NOT EXISTS nodes_review_due ON nodes (next_review_at);`);
+		db.prepare("INSERT INTO meta (key, value) VALUES ('schema_version', ?)").run(String(SCHEMA_VERSION));
+	} else {
 		let version = Number(versionRow.value);
 		if (!Number.isInteger(version) || version > SCHEMA_VERSION) {
 			db.close();
@@ -2274,8 +2908,9 @@ async function openEngramStore(path, rankBoost = NO_BOOST) {
 	const sqlGet = db.prepare("SELECT * FROM nodes WHERE id = ?");
 	const sqlInsert = db.prepare(`INSERT INTO nodes
     (id, scope, kind, content, importance, confidence, status, created_at, last_accessed_at, access_count,
-     source_session_id, source_round, source_seq, embedding, imagery_json)
-    VALUES (?, ?, ?, ?, ?, ?, 'active', ?, ?, 0, ?, ?, ?, ?, ?)`);
+     source_session_id, source_round, source_seq, embedding, imagery_json,
+     slot_room, slot_index, imagery_score, next_review_at, ease_factor, interval_days)
+    VALUES (?, ?, ?, ?, ?, ?, 'active', ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
 	const sqlFtsInsert = db.prepare("INSERT INTO nodes_fts (node_id, content) VALUES (?, ?)");
 	const sqlSetStatus = db.prepare("UPDATE nodes SET status = ?, last_accessed_at = ? WHERE id = ?");
 	const sqlSetOutcome = db.prepare(`UPDATE nodes
@@ -2316,22 +2951,44 @@ async function openEngramStore(path, rankBoost = NO_BOOST) {
 	const sqlAllNodes = db.prepare("SELECT * FROM nodes ORDER BY created_at");
 	const sqlAllEdges = db.prepare("SELECT * FROM edges");
 	const sqlDecay = db.prepare(`UPDATE nodes SET status = 'archived'
-    WHERE status = 'active' AND importance < ? AND last_accessed_at < ?`);
+    WHERE status = 'active' AND importance < ? AND last_accessed_at < ? AND next_review_at IS NULL`);
+	const sqlScheduleReview = db.prepare(`UPDATE nodes
+    SET next_review_at = ?, ease_factor = ?, interval_days = ?, review_reps = ?, last_accessed_at = ?
+    WHERE id = ?`);
+	const sqlDueReviews = db.prepare(`SELECT * FROM nodes
+    WHERE status = 'active' AND next_review_at IS NOT NULL AND next_review_at <= ?
+    ORDER BY next_review_at ASC LIMIT ?`);
+	const sqlSlotCounts = db.prepare(`SELECT slot_room AS room, MAX(slot_index) AS maxIndex, COUNT(*) AS n
+    FROM nodes WHERE slot_room IS NOT NULL AND status != 'forgotten' GROUP BY slot_room`);
+	const sqlSetSlot = db.prepare("UPDATE nodes SET slot_room = ?, slot_index = ? WHERE id = ?");
+	const sqlUnslotted = db.prepare(`SELECT * FROM nodes WHERE slot_room IS NULL AND status = 'active'
+    ORDER BY kind, created_at`);
+	const sqlRouteAppend = db.prepare(`INSERT INTO tour_routes (position, node_id)
+    VALUES ((SELECT COALESCE(MAX(position), -1) + 1 FROM tour_routes), ?)`);
+	const sqlRouteList = db.prepare("SELECT position, node_id FROM tour_routes ORDER BY position");
+	const sqlRouteHas = db.prepare("SELECT 1 AS x FROM tour_routes WHERE node_id = ? LIMIT 1");
+	const sqlSlotNeighbors = db.prepare(`SELECT id FROM nodes
+    WHERE slot_room = ? AND slot_index IN (?, ?) AND status = 'active' AND id != ?`);
+	const sqlListPlacards = db.prepare(`SELECT slot_room AS room, json_extract(imagery_json, '$.caption') AS caption
+    FROM nodes WHERE imagery_json IS NOT NULL AND status = 'active'`);
 	const sqlPurgeNodes = db.prepare("DELETE FROM nodes");
 	const sqlPurgeEdges = db.prepare("DELETE FROM edges");
 	const sqlPurgeFts = db.prepare("DELETE FROM nodes_fts");
 	const sqlPurgeLog = db.prepare("DELETE FROM op_log");
-	/** FTS 道：按 scope 集合检索（占位符动态生成，scope 集合由调用方去重）。 */
-	const ftsSearch = (match, scopes) => {
+	const sqlPurgeRoutes = db.prepare("DELETE FROM tour_routes");
+	/** FTS 道：按 scope 集合检索（占位符动态生成，scope 集合由调用方去重）；rooms 非空时只查指定房间。 */
+	const ftsSearch = (match, scopes, rooms) => {
 		const placeholders = scopes.map(() => "?").join(",");
+		const roomCond = rooms === void 0 || rooms.length === 0 ? "" : ` AND n.slot_room IN (${rooms.map(() => "?").join(",")})`;
 		return db.prepare(`SELECT n.* FROM nodes_fts f JOIN nodes n ON n.id = f.node_id
-      WHERE nodes_fts MATCH ? AND n.status = 'active' AND n.scope IN (${placeholders})
-      ORDER BY bm25(nodes_fts) LIMIT ${RANK_POOL}`).all(match, ...scopes);
+      WHERE nodes_fts MATCH ? AND n.status = 'active' AND n.scope IN (${placeholders})${roomCond}
+      ORDER BY bm25(nodes_fts) LIMIT ${RANK_POOL}`).all(match, ...scopes, ...rooms ?? []);
 	};
-	/** 向量候选池：active 且带向量的条目，按 scope 集合过滤（占位符动态生成）。 */
-	const vectorPool = (scopes) => {
+	/** 向量候选池：active 且带向量的条目，按 scope 集合过滤（占位符动态生成）；rooms 非空时只查指定房间。 */
+	const vectorPool = (scopes, rooms) => {
 		const placeholders = scopes.map(() => "?").join(",");
-		return db.prepare(`SELECT * FROM nodes WHERE status = 'active' AND embedding IS NOT NULL AND scope IN (${placeholders})`).all(...scopes);
+		const roomCond = rooms === void 0 || rooms.length === 0 ? "" : ` AND slot_room IN (${rooms.map(() => "?").join(",")})`;
+		return db.prepare(`SELECT * FROM nodes WHERE status = 'active' AND embedding IS NOT NULL AND scope IN (${placeholders})${roomCond}`).all(...scopes, ...rooms ?? []);
 	};
 	const getRow = (id) => sqlGet.get(id);
 	/**
@@ -2340,7 +2997,8 @@ async function openEngramStore(path, rankBoost = NO_BOOST) {
 	*/
 	const insertRecord = (id, input, content, importance, confidence, at, sourceSessionId, embedding, imagery, op) => {
 		const stored = embedding === null ? null : embedding instanceof Float32Array ? vecToBlob(embedding) : embedding;
-		sqlInsert.run(id, input.scope, input.kind, content, importance, confidence, at, at, sourceSessionId, input.sourceRound ?? null, input.sourceSeq ?? null, stored, imageryToJson(imagery));
+		const initialReview = input.initialReviewAt ?? null;
+		sqlInsert.run(id, input.scope, input.kind, content, importance, confidence, at, at, sourceSessionId, input.sourceRound ?? null, input.sourceSeq ?? null, stored, imageryToJson(imagery), input.slot?.room ?? null, input.slot?.index ?? null, input.imageryScore ?? null, initialReview, initialReview === null ? null : 2.5, initialReview === null ? null : 0);
 		sqlFtsInsert.run(id, tokenizeForFts(content));
 		sqlLog.run(at, op, id, JSON.stringify({
 			kind: input.kind,
@@ -2366,6 +3024,45 @@ async function openEngramStore(path, rankBoost = NO_BOOST) {
 			related: related.map(asMemoryId)
 		};
 	};
+	/**
+	* 写入期自动化（save/批量/摄取/update/蒸馏全部写入路径统一在此落地；调用方须已持事务）：
+	* 1) 排桩——显式 slot 优先，否则按 kind 分房自动分配（满员开新房并记 op_log）；
+	* 2) 门牌评分——有铭牌时按「唯一/差异化/带日期」启发式落库；
+	* 3) 初始排期——reviewScheduling 开启且未显式指定时，1 天后首次到期（显式 null = 明确不排期）；
+	* 4) 巡游路线——有桩位的条目登记到固定路线末尾。
+	* @returns 合入 WriteInput 的自动化字段。
+	*/
+	const applyWriteAutomation = (input, id, at, imagery) => {
+		let slot = input.slot;
+		if (slot === void 0 && automation.autoSlot) {
+			const occupancy = {};
+			for (const row of sqlSlotCounts.all()) occupancy[row.room] = {
+				count: row.n,
+				maxIndex: row.maxIndex
+			};
+			const assigned = assignSlot(input.kind, occupancy);
+			slot = assigned.slot;
+			if (assigned.openedNewRoom) sqlLog.run(at, "room-open", "BATCH", JSON.stringify({
+				room: slot.room,
+				kind: input.kind
+			}));
+		}
+		let imageryScore = input.imageryScore;
+		if (imageryScore === void 0 && imagery !== void 0) {
+			const placards = sqlListPlacards.all().filter((row) => typeof row.caption === "string" && row.caption !== "");
+			imageryScore = scorePlacard(imagery.caption, {
+				existingCaptions: placards.map((row) => row.caption),
+				roomCaptions: slot === void 0 ? [] : placards.filter((row) => row.room === slot.room).map((row) => row.caption)
+			});
+		}
+		const initialReviewAt = input.initialReviewAt === void 0 ? automation.reviewScheduling ? at + 864e5 : void 0 : input.initialReviewAt ?? void 0;
+		if (slot !== void 0 && sqlRouteHas.get(id) === void 0) sqlRouteAppend.run(id);
+		return {
+			...slot === void 0 ? {} : { slot },
+			...imageryScore === void 0 ? {} : { imageryScore },
+			...initialReviewAt === void 0 ? {} : { initialReviewAt }
+		};
+	};
 	return {
 		async write(input) {
 			const content = input.content.trim();
@@ -2373,7 +3070,11 @@ async function openEngramStore(path, rankBoost = NO_BOOST) {
 			const id = asMemoryId(randomUUID());
 			const at = Date.now();
 			withTransaction(() => {
-				insertRecord(id, input, content, input.importance ?? .5, input.confidence ?? .5, at, input.sourceSessionId ?? null, input.embedding ?? null, input.imagery, "write");
+				const automationFields = applyWriteAutomation(input, id, at, input.imagery);
+				insertRecord(id, {
+					...input,
+					...automationFields
+				}, content, input.importance ?? .5, input.confidence ?? .5, at, input.sourceSessionId ?? null, input.embedding ?? null, input.imagery, "write");
 			});
 			return rowToRecord(sqlGet.get(id));
 		},
@@ -2410,7 +3111,7 @@ async function openEngramStore(path, rankBoost = NO_BOOST) {
 			const limit = query.limit ?? 8;
 			const scores = /* @__PURE__ */ new Map();
 			const match = ftsMatchExpression(query.text);
-			if (match !== void 0) ftsSearch(match, query.scopes).forEach((row, index) => {
+			if (match !== void 0) ftsSearch(match, query.scopes, query.rooms).forEach((row, index) => {
 				scores.set(row.id, {
 					score: 1 / (RRF_K + index + 1),
 					via: "fts"
@@ -2419,7 +3120,7 @@ async function openEngramStore(path, rankBoost = NO_BOOST) {
 			let degraded = true;
 			if (queryVector !== void 0) {
 				degraded = false;
-				vectorPool(query.scopes).map((row) => ({
+				vectorPool(query.scopes, query.rooms).map((row) => ({
 					row,
 					sim: cosine(queryVector, blobToVec(row.embedding))
 				})).filter((entry) => entry.sim >= MIN_COSINE).sort((a, b) => b.sim - a.sim).slice(0, RANK_POOL).forEach((entry, index) => {
@@ -2472,11 +3173,13 @@ async function openEngramStore(path, rankBoost = NO_BOOST) {
 				const row = getRow(id);
 				if (row === void 0) continue;
 				const viaEdge = viaEdgeOf.get(id);
+				const cueNeighbors = hits.length < 5 && row.slot_room !== null && row.slot_index !== null ? sqlSlotNeighbors.all(row.slot_room, row.slot_index - 1, row.slot_index + 1, id).map((neighbor) => asMemoryId(neighbor.id)) : [];
 				hits.push({
 					record: rowToRecord(row),
 					score: info.score,
 					via: info.via,
-					...viaEdge === void 0 ? {} : { viaEdge }
+					...viaEdge === void 0 ? {} : { viaEdge },
+					...cueNeighbors.length === 0 ? {} : { cues: { neighbors: cueNeighbors } }
 				});
 				sqlTouch.run(Date.now(), id);
 			}
@@ -2487,11 +3190,21 @@ async function openEngramStore(path, rankBoost = NO_BOOST) {
 		},
 		async timeline(query) {
 			const limit = query.limit ?? 20;
-			const placeholders = query.scopes.map(() => "?").join(",");
-			return db.prepare(`SELECT * FROM nodes WHERE status = 'active' AND scope IN (${placeholders})
-        AND (? IS NULL OR created_at >= ?) AND (? IS NULL OR created_at <= ?)
-        AND (? IS NULL OR instr(content, ?) > 0)
-        ORDER BY created_at DESC LIMIT ?`).all(...query.scopes, query.since ?? null, query.since ?? null, query.until ?? null, query.until ?? null, query.topic ?? null, query.topic ?? null, limit).map(rowToRecord);
+			const where = `nodes.status = 'active' AND nodes.scope IN (${query.scopes.map(() => "?").join(",")})
+        AND (? IS NULL OR nodes.created_at >= ?) AND (? IS NULL OR nodes.created_at <= ?)
+        AND (? IS NULL OR instr(nodes.content, ?) > 0)`;
+			const params = [
+				...query.scopes,
+				query.since ?? null,
+				query.since ?? null,
+				query.until ?? null,
+				query.until ?? null,
+				query.topic ?? null,
+				query.topic ?? null,
+				limit
+			];
+			return (query.order === "tour" ? db.prepare(`SELECT nodes.* FROM nodes LEFT JOIN tour_routes ON tour_routes.node_id = nodes.id
+            WHERE ${where} ORDER BY tour_routes.position IS NULL, tour_routes.position ASC, nodes.created_at DESC LIMIT ?`).all(...params) : db.prepare(`SELECT nodes.* FROM nodes WHERE ${where} ORDER BY nodes.created_at DESC LIMIT ?`).all(...params)).map(rowToRecord);
 		},
 		async update(input) {
 			const old = getRow(input.id);
@@ -2504,11 +3217,17 @@ async function openEngramStore(path, rankBoost = NO_BOOST) {
 				sqlRevisionInsert.run(input.id, old.content, old.kind, old.importance, at);
 				sqlSetStatus.run("archived", at, input.id);
 				sqlLog.run(at, "superseded", input.id, JSON.stringify({ supersededBy: id }));
-				insertRecord(id, {
+				const imagery = input.imagery ?? jsonToImagery(old.imagery_json);
+				const updateInput = {
 					scope: input.scope,
 					kind: input.kind,
 					content
-				}, content, input.importance ?? old.importance, old.confidence, at, old.source_session_id, input.embedding ?? old.embedding, input.imagery ?? jsonToImagery(old.imagery_json), "update");
+				};
+				const automationFields = applyWriteAutomation(updateInput, id, at, imagery);
+				insertRecord(id, {
+					...updateInput,
+					...automationFields
+				}, content, input.importance ?? old.importance, old.confidence, at, old.source_session_id, input.embedding ?? old.embedding, imagery, "update");
 				sqlEdgeUpsert.run(id, input.id, "supersedes", at);
 			});
 			return rowToRecord(sqlGet.get(id));
@@ -2569,6 +3288,82 @@ async function openEngramStore(path, rankBoost = NO_BOOST) {
 			sqlLog.run(Date.now(), "outcome-report", id, outcome);
 			return rowToRecord(sqlGet.get(id));
 		},
+		async scheduleReview(id, grade) {
+			const row = getRow(id);
+			if (row === void 0) return void 0;
+			const now = Date.now();
+			const next = nextSchedule(grade, rowToRecord(row).review ?? {
+				nextReviewAt: null,
+				easeFactor: 2.5,
+				intervalDays: 0,
+				reps: row.review_reps ?? 0
+			}, now);
+			sqlScheduleReview.run(next.nextReviewAt, next.easeFactor, next.intervalDays, next.reps, now, id);
+			sqlLog.run(now, "review-answer", id, JSON.stringify({
+				grade,
+				nextIntervalDays: next.intervalDays
+			}));
+			return rowToRecord(sqlGet.get(id));
+		},
+		async dueReviews(now, limit) {
+			return sqlDueReviews.all(now, Math.max(1, limit)).map(rowToRecord);
+		},
+		async slotCountsByRoom() {
+			const rows = sqlSlotCounts.all();
+			const result = {};
+			for (const row of rows) result[row.room] = {
+				count: row.n,
+				maxIndex: row.maxIndex
+			};
+			return result;
+		},
+		async assignSlot(id, slot) {
+			sqlSetSlot.run(slot.room, slot.index, id);
+			sqlLog.run(Date.now(), "slot-assign", id, JSON.stringify(slot));
+		},
+		async backfillSlots(capacityNote) {
+			const rows = sqlUnslotted.all();
+			if (rows.length === 0) return 0;
+			const now = Date.now();
+			withTransaction(() => {
+				const occupancy = {};
+				for (const row of sqlSlotCounts.all()) occupancy[row.room] = {
+					count: row.n,
+					maxIndex: row.maxIndex
+				};
+				for (const row of rows) {
+					const { slot, openedNewRoom } = assignSlot(row.kind, occupancy);
+					sqlSetSlot.run(slot.room, slot.index, row.id);
+					if (sqlRouteHas.get(row.id) === void 0) sqlRouteAppend.run(row.id);
+					const state = occupancy[slot.room] ?? {
+						count: 0,
+						maxIndex: 0
+					};
+					occupancy[slot.room] = {
+						count: state.count + 1,
+						maxIndex: Math.max(state.maxIndex, slot.index)
+					};
+					if (openedNewRoom) capacityNote(slot.room);
+				}
+				sqlLog.run(now, "slot-backfill", "BATCH", JSON.stringify({ assigned: rows.length }));
+			});
+			return rows.length;
+		},
+		async routeAppend(id) {
+			sqlRouteAppend.run(id);
+		},
+		async routeHas(id) {
+			return sqlRouteHas.get(id) !== void 0;
+		},
+		async routeList() {
+			return sqlRouteList.all().map((row) => ({
+				position: row.position,
+				id: asMemoryId(row.node_id)
+			}));
+		},
+		async listPlacards() {
+			return sqlListPlacards.all().filter((row) => typeof row.caption === "string" && row.caption !== "");
+		},
 		async restore(id) {
 			if (getRow(id) === void 0) throw new EngramError("NOT_FOUND", `条目 ${id} 不存在`);
 			sqlSetStatus.run("active", Date.now(), id);
@@ -2597,7 +3392,8 @@ async function openEngramStore(path, rankBoost = NO_BOOST) {
 			const where = conds.join(" AND ");
 			const total = db.prepare(`SELECT COUNT(*) AS n FROM nodes WHERE ${where}`).get(...params).n;
 			return {
-				records: db.prepare(`SELECT * FROM nodes WHERE ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params, filter.limit, filter.offset).map(rowToRecord),
+				records: (filter.sort === "tour" ? db.prepare(`SELECT nodes.* FROM nodes LEFT JOIN tour_routes ON tour_routes.node_id = nodes.id
+            WHERE ${where} ORDER BY tour_routes.position IS NULL, tour_routes.position ASC, created_at DESC LIMIT ? OFFSET ?`).all(...params, filter.limit, filter.offset) : db.prepare(`SELECT * FROM nodes WHERE ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params, filter.limit, filter.offset)).map(rowToRecord),
 				total
 			};
 		},
@@ -2696,7 +3492,11 @@ async function openEngramStore(path, rankBoost = NO_BOOST) {
 			const id = asMemoryId(randomUUID());
 			const at = Date.now();
 			withTransaction(() => {
-				insertRecord(id, input, content, input.importance ?? .5, input.confidence ?? .5, at, input.sourceSessionId ?? null, input.embedding ?? null, input.imagery, "distill");
+				const automationFields = applyWriteAutomation(input, id, at, input.imagery);
+				insertRecord(id, {
+					...input,
+					...automationFields
+				}, content, input.importance ?? .5, input.confidence ?? .5, at, input.sourceSessionId ?? null, input.embedding ?? null, input.imagery, "distill");
 				for (const oldId of oldIds) {
 					sqlSetStatus.run("archived", at, oldId);
 					sqlEdgeUpsert.run(id, oldId, "supersedes", at);
@@ -2722,6 +3522,7 @@ async function openEngramStore(path, rankBoost = NO_BOOST) {
 				sqlPurgeEdges.run();
 				sqlPurgeFts.run();
 				sqlPurgeLog.run();
+				sqlPurgeRoutes.run();
 			});
 		},
 		async close() {
@@ -2931,7 +3732,7 @@ function enforceBudget(lines, totalBudget = RECALL_TOTAL_CHARS) {
 //#endregion
 //#region src/tools/create.ts
 /**
-* 9 个 engram_ 工具的定义与执行器。工具 schema 保持窄参数；
+* 15 个 engram_ 工具的定义与执行器。工具 schema 保持窄参数；
 * scope 决定读写哪个分库；嵌入缺失时检索结果显式标记降级。
 * @module @kenz1117/dsh-engram/tools/create
 */
@@ -2942,6 +3743,33 @@ const KINDS = [
 	"episode",
 	"skill"
 ];
+/** 历史回填估算的模型可读文本（零成本，先看数再决定跑不跑）。 */
+function renderHistoryEstimate(estimate) {
+	if (estimate.unavailable !== void 0) return `历史回填不可用：${estimate.unavailable}`;
+	const rules = estimate.rules;
+	const window = rules.days === 0 ? "不限" : `${String(rules.days)} 天`;
+	const lines = [
+		`历史回填估算：候选 ${String(estimate.candidates)} 个会话 · 规则内 ${String(estimate.eligibleTurns)} 轮 · 待处理 ${String(estimate.pendingTurns)} 轮（此前已摄取 ${String(estimate.alreadyIngested)} 轮会自动跳过）。`,
+		`规则：时间窗 ${window} · 单会话≤${String(rules.maxTurnsPerSession)} 轮 · 总轮数≤${String(rules.maxTotalTurns)} · 含子代理 ${rules.includeSubagents ? "是" : "否"} · 含种子 ${rules.includeSeeded ? "是" : "否"} · 含无 cwd ${rules.includeNoCwd ? "是" : "否"}`,
+		`已排除：子代理 ${String(estimate.skipped.subagent)} · 种子 ${String(estimate.skipped.seeded)} · 无 cwd ${String(estimate.skipped.noCwd)} · 超时间窗 ${String(estimate.skipped.tooOld)} · 日志不可读 ${String(estimate.skipped.unreadable)}`
+	];
+	if (estimate.truncated) lines.push("注意：候选超出总轮数上限，本次只会处理最近的一部分会话；可调大 maxTotalTurns 或缩小时间窗分几次跑。");
+	lines.push("实际 LLM 调用次数不超过待处理轮数（低活动/寒暄/显式禁记的轮次会被节流跳过）。确认要真正回填请再传 dryRun=false。");
+	return lines.join("\n");
+}
+/** 历史回填执行结果的模型可读文本。 */
+function renderHistoryRun(result) {
+	const lines = [`历史回填${result.state === "done" ? "完成" : result.state === "cancelled" ? "已中止（可重跑续做）" : "失败"}：处理 ${String(result.sessionsDone)}/${String(result.sessionsTotal)} 个会话 · ${String(result.turnsDone)} 轮 → 写入 ${String(result.memoriesWritten)} 条记忆；跳过 ${String(result.turnsSkipped)} 轮 · 失败 ${String(result.turnsFailed)} 轮。`];
+	const reasons = Object.entries(result.skipReasons).sort(([, a], [, b]) => b - a);
+	if (reasons.length > 0) lines.push(`跳过原因：${reasons.map(([reason, count]) => `${reason} ${String(count)}`).join(" · ")}`);
+	if (result.failures.length > 0) {
+		const shown = result.failures.slice(0, 3).map((failure) => `${failure.sessionId.slice(-12)} 第 ${String(failure.turn)} 轮：${failure.reason}`);
+		lines.push(`失败明细（前 ${String(shown.length)} 条）：${shown.join("；")}`);
+		lines.push("若失败原因是历史会话记录的路由在当前环境不可用，可在 cordis.yml 配 provider/model，或让一个会话先用目标模型跑一轮（回填会优先复用当前在用的路由）后重跑——已完成的轮次会自动跳过。");
+	}
+	lines.push("同一批可重复执行：已完成的轮次按幂等键跳过，只补未完成的部分。");
+	return lines.join("\n");
+}
 /** 从模型参数收敛 scope（非法值或缺失回退 fallback）。 */
 function scopeOf(raw, fallback) {
 	if (raw === "user" || raw === "project" || raw === "shared") return raw;
@@ -3011,7 +3839,8 @@ async function rewriteQueries(deps, exec, query) {
 	}
 }
 /**
-* 构造 10 个工具定义（engram_save/search/timeline/update/forget/report/review/stats/export/distill）。
+* 构造 16 个工具定义（engram_save/search/timeline/update/forget/report/review/review_queue/
+* stats/export/distill/examine/neighbors/audit_forgotten/tour/ingest_history）。
 * @param deps - 分库打开器、嵌入器、辅助 LLM、导出目录。
 * @returns 可直接 register 的工具定义数组。
 */
@@ -3022,7 +3851,10 @@ function createEngramTools(deps) {
 	function renderSaveResultText(value) {
 		if (value.count !== void 0) {
 			const parts = [`已批量保存 ${value.count} 条记忆`];
-			for (const item of value.items ?? []) parts.push(`${item.id}（kind=${item.kind}, importance=${item.importance}）`);
+			for (const item of value.items ?? []) {
+				const slot = item.slot === void 0 ? "" : `, ${item.slot.room}#${item.slot.index}`;
+				parts.push(`${item.id}（kind=${item.kind}, importance=${item.importance}${slot}）`);
+			}
 			const failures = value.failed ?? [];
 			if (failures.length > 0) parts.push(`${failures.length} 条失败：${failures.map((entry) => `#${entry.index + 1} ${entry.reason}`).join("；")}`);
 			parts.push("后续会话可用 engram_search 召回。");
@@ -3040,7 +3872,8 @@ function createEngramTools(deps) {
 			content: item.content,
 			...item.importance === void 0 ? {} : { importance: item.importance },
 			sourceSessionId: item.sourceSessionId,
-			...embedding === void 0 ? {} : { embedding }
+			...embedding === void 0 ? {} : { embedding },
+			...item.imagery === void 0 ? {} : { imagery: item.imagery }
 		});
 		const candidates = embedding === void 0 ? [] : await store.findContradictions(embedding);
 		for (const candidate of candidates) await store.linkEdge(record.id, candidate.id, "contradicts");
@@ -3049,6 +3882,18 @@ function createEngramTools(deps) {
 			candidates
 		};
 	}
+	/** 门牌参数收敛：非空字符串转 ImageryLabel（感官/情绪维度留空——AI 不需要人脑补丁），非法返回 undefined。 */
+	function placardOf(raw) {
+		if (typeof raw !== "string") return void 0;
+		const caption = raw.trim();
+		if (caption === "") return void 0;
+		return {
+			caption,
+			sensoryTags: [],
+			emotionalValence: 0,
+			provisional: false
+		};
+	}
 	/** 批量保存：统一清洗/校验/批量内去重，一次批量嵌入，逐条写入；单条失败不阻塞其余。 */
 	async function saveBatch(sourceSessionId, items, rawScope) {
 		if (items.length > MAX_SAVE_BATCH) throw new Error(`engram_save: 单次最多保存 ${MAX_SAVE_BATCH} 条`);
@@ -3120,7 +3965,8 @@ function createEngramTools(deps) {
 			saved.push({
 				id: record.id,
 				kind: record.kind,
-				importance: record.importance
+				importance: record.importance,
+				...record.slot === void 0 ? {} : { slot: record.slot }
 			});
 		} catch (error) {
 			failed.push({
@@ -3184,6 +4030,10 @@ function createEngramTools(deps) {
 			importance: {
 				type: "number",
 				description: "重要性 0-1，默认 0.5（仅单条模式）"
+			},
+			placard: {
+				type: "string",
+				description: "门牌（可选，仅单条模式）：4-30 字铭牌。宫殿纪律：唯一 · 差异化 · 带日期锚点（如「2026-09 向量检索选型」），禁止与既有门牌近似到无法区分"
 			}
 		},
 		output: {
@@ -3213,6 +4063,20 @@ function createEngramTools(deps) {
 								importance: {
 									type: "number",
 									required: true
+								},
+								slot: {
+									type: "object",
+									additionalProperties: false,
+									properties: {
+										room: {
+											type: "string",
+											required: true
+										},
+										index: {
+											type: "number",
+											required: true
+										}
+									}
 								}
 							}
 						}
@@ -3256,33 +4120,38 @@ function createEngramTools(deps) {
 			const store = await deps.openStore(scope);
 			const embedder = await deps.embedder;
 			const embeddings = embedder === void 0 ? void 0 : await embedder.embed([content.trim()]);
+			const imagery = placardOf(input.placard);
 			const { record, candidates } = await writeWithContradictions(store, {
 				scope,
 				kind: input.kind,
 				content,
 				...typeof input.importance === "number" ? { importance: input.importance } : {},
 				sourceSessionId,
-				...embeddings?.[0] === void 0 ? {} : { embedding: embeddings[0] }
+				...embeddings?.[0] === void 0 ? {} : { embedding: embeddings[0] },
+				...imagery === void 0 ? {} : { imagery }
 			});
+			const placardHint = imagery === void 0 || record.imageryScore === void 0 ? "" : `\n${placardImprovementHint(record.imageryScore) ?? ""}`;
 			if (candidates.length > 0) {
 				const listed = candidates.map((candidate) => `「${candidate.content}」（id=${candidate.id}）`).join("；");
 				return {
 					id: record.id,
 					kind: record.kind,
 					importance: record.importance,
-					text: `已保存 ${record.id}。注意：与现有记忆高度相似——${listed}。若这是修正而非新事实，请用 engram_update 归并，或 engram_forget 去重。`
+					text: `已保存 ${record.id}。注意：与现有记忆高度相似——${listed}。若这是修正而非新事实，请用 engram_update 归并，或 engram_forget 去重。${placardHint}`
 				};
 			}
+			const base = `已保存记忆 ${record.id}（kind=${record.kind}, importance=${record.importance}${record.slot === void 0 ? "" : `, ${record.slot.room}#${record.slot.index}`}）。后续会话可用 engram_search 召回。`;
 			return {
 				id: record.id,
 				kind: record.kind,
-				importance: record.importance
+				importance: record.importance,
+				text: `${base}${placardHint}`
 			};
 		}
 	});
 	const search = defineTool({
 		name: "engram_search",
-		description: "语义 + 关键词混合检索长期记忆。user 作用域存偏好与通用事实，project 作用域存项目约定与决策。结果行尾给出 id，供 engram_update/engram_forget 引用。",
+		description: "语义 + 关键词混合检索长期记忆。宫殿纪律：先想进哪个房间——事实厅（fact）/偏好阁（preference）/决策堂（decision）/往事廊（episode）/技法坊（skill），带上 room 参数只查该房间，更快更准；不确定房间时缺省全库检索。user 作用域存偏好与通用事实，project 作用域存项目约定与决策。结果行尾给出 id，供 engram_update/engram_forget 引用。",
 		parameters: {
 			query: {
 				type: "string",
@@ -3299,6 +4168,10 @@ function createEngramTools(deps) {
 				],
 				description: "作用域，默认 all"
 			},
+			room: {
+				type: "string",
+				description: "房间路由：只在指定房间内检索（如「决策堂」）。房间目录见 engram_stats 输出"
+			},
 			limit: {
 				type: "number",
 				description: "返回条数上限，默认 8"
@@ -3327,6 +4200,7 @@ function createEngramTools(deps) {
 		async execute(args, exec) {
 			const input = args;
 			const scopes = scopesOf(input.scope);
+			const rooms = typeof input.room === "string" && input.room.trim() !== "" ? [input.room.trim()] : void 0;
 			const limit = input.limit ?? 8;
 			const rewrite = await rewriteQueries(deps, exec, input.query);
 			const retrievals = await Promise.all(rewrite.queries.map(async (queryText) => {
@@ -3335,7 +4209,8 @@ function createEngramTools(deps) {
 					return (await deps.openStore(scope)).search({
 						text: queryText,
 						scopes: [scope],
-						limit
+						limit,
+						...rooms === void 0 ? {} : { rooms }
 					}, vector);
 				}));
 				return {
@@ -3346,17 +4221,20 @@ function createEngramTools(deps) {
 			const degraded = retrievals.some((retrieval) => retrieval.degraded);
 			const lines = enforceBudget(mergeQueryResults(retrievals, limit, 60, Math.floor(Math.max(0, limit) / Math.max(1, rewrite.queries.length))).map((hit, index) => {
 				const edge = hit.viaEdge === void 0 ? "" : `（经 ${hit.viaEdge.type} 关联自 ${hit.viaEdge.from}）`;
-				return `${index + 1}. [${hit.record.scope}/${hit.record.kind}] ${truncateItem(hit.record.content)}（id=${hit.record.id}）${edge}`;
+				const slot = hit.record.slot === void 0 ? "" : ` ${hit.record.slot.room}#${hit.record.slot.index}`;
+				const date = ` 刻于 ${new Date(hit.record.createdAt).toISOString().slice(0, 10)}`;
+				const cues = hit.cues === void 0 ? "" : ` 相邻桩位: ${hit.cues.neighbors.join(", ")}`;
+				return `${index + 1}. [${hit.record.scope}/${hit.record.kind}]${slot}${date} ${truncateItem(hit.record.content)}（id=${hit.record.id}）${edge}${cues}`;
 			}));
 			return {
 				degraded,
-				text: renderMemoryPacket(`${degraded && lines.length > 0 ? "（语义嵌入不可用，仅关键词检索）\n" : ""}${lines.join("\n") || "无命中"}`, "tool_search", input.query)
+				text: renderMemoryPacket(`${degraded && lines.length > 0 ? "（语义嵌入不可用，仅关键词检索）\n" : ""}${rooms === void 0 ? "" : `（房间路由：${rooms.join("、")}）\n`}${lines.join("\n") || "无命中"}`, "tool_search", input.query)
 			};
 		}
 	});
 	const timeline = defineTool({
 		name: "engram_timeline",
-		description: "按时间范围与主题浏览记忆（时间倒序，最近 20 条）。无参数直接列出最近记录。",
+		description: "按时间范围与主题浏览记忆（默认时间倒序，最近 20 条）。order=tour 时改按固定巡游路线的桩位顺序走（未上路线者排末尾），输出附宫殿坐标——适合按宫殿固定路线复述；多作用域按 user→project→shared 顺序拼接（桩位顺序只在各自库内有意义）。无参数直接列出最近记录。",
 		parameters: {
 			scope: {
 				type: "string",
@@ -3379,6 +4257,11 @@ function createEngramTools(deps) {
 			until: {
 				type: "string",
 				description: "结束时间"
+			},
+			order: {
+				type: "string",
+				enum: ["time", "tour"],
+				description: "排序：缺省 'time' 按创建时间倒序；'tour' 按固定巡游路线桩位顺序"
 			}
 		},
 		output: {
@@ -3398,6 +4281,7 @@ function createEngramTools(deps) {
 		async execute(args) {
 			const input = args;
 			const scopes = scopesOf(input.scope);
+			const order = input.order === "tour" ? "tour" : "time";
 			const parseTime = (raw, field) => {
 				if (raw === void 0) return void 0;
 				const ms = Date.parse(raw);
@@ -3406,15 +4290,22 @@ function createEngramTools(deps) {
 			};
 			const since = parseTime(input.since, "since");
 			const until = parseTime(input.until, "until");
-			return { text: renderMemoryPacket(enforceBudget((await Promise.all(scopes.map(async (scope) => {
+			const results = await Promise.all(scopes.map(async (scope) => {
 				return (await deps.openStore(scope)).timeline({
 					scopes: [scope],
 					...input.topic === void 0 ? {} : { topic: input.topic },
 					...since === void 0 ? {} : { since },
 					...until === void 0 ? {} : { until },
+					order,
 					limit: 20
 				});
-			}))).flat().sort((a, b) => b.createdAt - a.createdAt).slice(0, 20).map((record) => `${new Date(record.createdAt).toISOString()} [${record.scope}/${record.kind}] ${truncateItem(record.content)}（id=${record.id}）`)).join("\n") || "时间线为空", "tool_timeline", input.topic ?? "（对话继续）") };
+			}));
+			const body = enforceBudget((order === "tour" ? results.flat().slice(0, 20) : results.flat().sort((a, b) => b.createdAt - a.createdAt).slice(0, 20)).map((record) => {
+				const slot = order === "tour" && record.slot !== void 0 ? ` ${record.slot.room}#${record.slot.index}` : "";
+				return `${new Date(record.createdAt).toISOString()}${slot} [${record.scope}/${record.kind}] ${truncateItem(record.content)}（id=${record.id}）`;
+			}));
+			const tail = order === "tour" ? "\n（按固定巡游路线桩位顺序；未上路线者按创建时间排末尾）" : "";
+			return { text: renderMemoryPacket(`${body.join("\n") || "时间线为空"}${tail}`, "tool_timeline", input.topic ?? "（对话继续）") };
 		}
 	});
 	const update = defineTool({
@@ -3444,6 +4335,10 @@ function createEngramTools(deps) {
 				type: "string",
 				enum: [...KINDS],
 				description: "种类，默认继承旧条目"
+			},
+			placard: {
+				type: "string",
+				description: "门牌（可选）：4-30 字铭牌，替换旧条目门牌。宫殿纪律：唯一 · 差异化 · 带日期锚点"
 			}
 		},
 		output: {
@@ -3476,13 +4371,15 @@ function createEngramTools(deps) {
 			if (old === void 0) throw new Error(`engram_update: 条目 ${input.id} 不存在于 ${scope} 库（用 engram_search 确认 id 与 scope）`);
 			const embedder = await deps.embedder;
 			const embeddings = embedder === void 0 ? void 0 : await embedder.embed([content.trim()]);
+			const imagery = placardOf(input.placard);
 			return {
 				id: (await store.update({
 					id: input.id,
 					scope,
 					kind: input.kind ?? old.kind,
 					content,
-					...embeddings === void 0 ? {} : { embedding: embeddings[0] }
+					...embeddings === void 0 ? {} : { embedding: embeddings[0] },
+					...imagery === void 0 ? {} : { imagery }
 				})).id,
 				superseded: input.id
 			};
@@ -3533,7 +4430,7 @@ function createEngramTools(deps) {
 			},
 			render: (_args, value) => [{
 				type: "text",
-				text: `房间 ${value.id} 已闭馆（软删，可恢复），墓志铭已刻入操作日志。`
+				text: `记忆 ${value.id} 已闭馆（软删，可恢复），墓志铭已刻入操作日志。`
 			}]
 		},
 		async execute(args) {
@@ -3550,6 +4447,73 @@ function createEngramTools(deps) {
 			})).id };
 		}
 	});
+	/**
+	* 历史回填：把 dsh 历史会话逐轮提炼进宫殿（按会话 cwd 分库、已有幂等键的轮次跳过）。
+	* dryRun 默认 true——避免模型顺手触发成百次辅助调用；显式传 false 才真正写入。
+	*/
+	const ingestHistory = defineTool({
+		name: "engram_ingest_history",
+		description: "历史会话回填：把 dsh 的历史会话逐轮提炼进记忆宫殿（写进各会话自己 cwd 对应的项目库；此前已摄取的轮次自动跳过，中断后可重跑续做）。dryRun 缺省 true，只返回估算（候选会话数 / 规则内轮数 / 待处理轮数）而不调 LLM、不写库；确认后再传 dryRun=false 执行。大批量回填建议用设置页「历史回填」tab（有规则选择、进度与暂停）；本工具适合先估算或小批量执行。",
+		parameters: {
+			dryRun: {
+				type: "boolean",
+				description: "只估算不执行（默认 true；显式 false 才真正回填）"
+			},
+			days: {
+				type: "number",
+				description: "时间窗天数，0 = 不限；缺省用部署配置值"
+			},
+			maxTurnsPerSession: {
+				type: "number",
+				description: "单个会话最多摄取轮数；缺省用部署配置值"
+			},
+			maxTotalTurns: {
+				type: "number",
+				description: "本次最多处理的总轮数（只能调低配置硬上限）"
+			},
+			includeSubagents: {
+				type: "boolean",
+				description: "是否包含子代理会话（默认 false）"
+			},
+			includeSeeded: {
+				type: "boolean",
+				description: "是否包含种子会话（默认 false）"
+			},
+			includeNoCwd: {
+				type: "boolean",
+				description: "是否包含无 cwd 会话（默认 false；这类会话只能写进 user 库）"
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: { text: {
+					type: "string",
+					required: true
+				} }
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: value.text
+			}]
+		},
+		async execute(args, exec) {
+			const input = args;
+			const history = deps.historyBackfill;
+			if (history === void 0) return { text: "历史回填不可用：当前组合未挂载会话持久化服务（会话日志不可读，例如 headless profile）。" };
+			const rules = {
+				...typeof input.days === "number" ? { days: input.days } : {},
+				...typeof input.maxTurnsPerSession === "number" ? { maxTurnsPerSession: input.maxTurnsPerSession } : {},
+				...typeof input.maxTotalTurns === "number" ? { maxTotalTurns: input.maxTotalTurns } : {},
+				...typeof input.includeSubagents === "boolean" ? { includeSubagents: input.includeSubagents } : {},
+				...typeof input.includeSeeded === "boolean" ? { includeSeeded: input.includeSeeded } : {},
+				...typeof input.includeNoCwd === "boolean" ? { includeNoCwd: input.includeNoCwd } : {}
+			};
+			if (input.dryRun !== false) return { text: renderHistoryEstimate(await history.estimate(rules)) };
+			return { text: renderHistoryRun(await history.run(rules, exec.signal)) };
+		}
+	});
 	/** P0-3 闭馆考古：返回最近 N 条 forgotten 条目 + 墓志铭。 */
 	const auditForgotten = defineTool({
 		name: "engram_audit_forgotten",
@@ -3600,6 +4564,61 @@ function createEngramTools(deps) {
 			return { text: `闭馆考古（共 ${sliced.length} 条）：\n${lines.join("\n")}` };
 		}
 	});
+	const reviewQueue = defineTool({
+		name: "engram_review_queue",
+		description: "今日待回忆队列：列出已到期间隔重复的记忆，每条只给宫殿坐标与门牌线索（不给正文）。用法：对每条先尝试回忆内容，然后 engram_review 揭示核对，再 engram_report 传 grade（0-5）自评——主动回忆比重复阅读的记忆强化效果强得多。会话开始注入会提示今日是否有待回忆。",
+		parameters: {
+			scope: {
+				type: "string",
+				enum: [
+					"user",
+					"project",
+					"shared",
+					"all"
+				],
+				description: "作用域，默认 all"
+			},
+			limit: {
+				type: "integer",
+				description: "返回条数上限，默认 10（最逾期在前）"
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: { text: {
+					type: "string",
+					required: true
+				} }
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: value.text
+			}]
+		},
+		async execute(args) {
+			const input = args;
+			const scopes = scopesOf(input.scope);
+			const limit = Number.isInteger(input.limit) ? Math.min(Math.max(1, input.limit), 50) : 10;
+			const now = Date.now();
+			const groups = await Promise.all(scopes.map(async (scope) => ({
+				scope,
+				due: await (await deps.openStore(scope)).dueReviews(now, limit)
+			})));
+			const total = groups.reduce((sum, group) => sum + group.due.length, 0);
+			if (total === 0) return { text: "今日无待回忆条目（队列空）。新记忆保存后次日首次到期。" };
+			const lines = [`今日待回忆 ${total} 段（最逾期在前）。对每段：先回忆 → engram_review 核对 → engram_report 传 grade 自评。`];
+			for (const { scope, due } of groups) for (const [index, record] of due.entries()) {
+				const slot = record.slot === void 0 ? "（未排桩）" : `${record.slot.room} #${record.slot.index}`;
+				const placard = record.imagery?.caption ?? "（无门牌）";
+				const overdueDays = record.review?.nextReviewAt === null || record.review?.nextReviewAt === void 0 ? 0 : Math.max(0, Math.floor((now - record.review.nextReviewAt) / 864e5));
+				const overdue = overdueDays === 0 ? "今日到期" : `逾期 ${overdueDays} 天`;
+				lines.push(`${index + 1}. [${scope}] ${slot} · 门牌「${placard}」 · ${overdue} · id=${record.id}`);
+			}
+			return { text: lines.join("\n") };
+		}
+	});
 	return [
 		save,
 		search,
@@ -3608,7 +4627,7 @@ function createEngramTools(deps) {
 		forget,
 		defineTool({
 			name: "engram_report",
-			description: "回报一条记忆（尤其 skill 类）使用后的实际效果：success（有效，提权）或 failure（无效，降权）。id 与 scope 来自 engram_search 结果。效果影响后续召回排序，长期无效的记忆将被衰减归档。",
+			description: "回报一条记忆（尤其 skill 类）使用后的实际效果：success（有效，提权）或 failure（无效，降权）。id 与 scope 来自 engram_search 结果。也可作为复习自评入口：传 grade（0 完全遗忘 … 5 完美回忆）显式报告回忆质量。效果影响后续召回排序与复习排期，长期无效的记忆会被衰减归档。",
 			parameters: {
 				id: {
 					type: "string",
@@ -3618,8 +4637,11 @@ function createEngramTools(deps) {
 				outcome: {
 					type: "string",
 					enum: ["success", "failure"],
-					required: true,
-					description: "使用效果"
+					description: "使用效果（与 grade 二选一；同传时 grade 优先）"
+				},
+				grade: {
+					type: "integer",
+					description: "回忆质量自评 0-5（复习答题用；0/1 完全遗忘，3 勉强，5 完美）"
 				},
 				scope: {
 					type: "string",
@@ -3647,27 +4669,36 @@ function createEngramTools(deps) {
 						confidence: {
 							type: "number",
 							required: true
-						}
+						},
+						nextReviewAt: { type: "number" }
 					}
 				},
 				render: (_args, value) => [{
 					type: "text",
-					text: value.outcome === "success" ? `已记录：记忆 ${value.id} 使用有效（confidence=${value.confidence}）。该记忆后续召回排序将提升。` : `已记录：记忆 ${value.id} 使用无效（confidence=${value.confidence}）。该记忆后续召回排序将下降，持续无效会被衰减归档。`
+					text: (value.outcome === "success" ? `已记录：记忆 ${value.id} 使用有效（confidence=${value.confidence}）。该记忆后续召回排序将提升。` : `已记录：记忆 ${value.id} 标记为无效/遗忘（confidence=${value.confidence}）。排序将下降，持续无效会被衰减归档。`) + (value.nextReviewAt === void 0 ? "" : ` 下次复习：${new Date(value.nextReviewAt).toISOString().slice(0, 10)}。`)
 				}]
 			},
 			async execute(args) {
 				const input = args;
-				if (input.outcome !== "success" && input.outcome !== "failure") throw new Error("engram_report: outcome 必须是 success 或 failure");
+				const hasGrade = Number.isInteger(input.grade) && input.grade >= 0 && input.grade <= 5;
+				if (input.grade !== void 0 && !hasGrade) throw new Error("engram_report: grade 必须是 0-5 的整数");
+				if (input.outcome !== "success" && input.outcome !== "failure" && !hasGrade) throw new Error("engram_report: 需要 outcome（success/failure）或 grade（0-5）参数");
+				const outcome = input.outcome === "success" || input.outcome === "failure" ? input.outcome : input.grade >= 3 ? "success" : "failure";
+				const grade = hasGrade ? input.grade : outcome === "success" ? 5 : 1;
 				const scope = scopeOf(input.scope, "project");
-				const record = await (await deps.openStore(scope)).reportOutcome(input.id, input.outcome);
+				const store = await deps.openStore(scope);
+				const record = await store.reportOutcome(input.id, outcome);
 				if (record === void 0) throw new Error(`engram_report: 条目 ${input.id} 不存在（scope=${scope}）`);
+				const scheduled = await store.scheduleReview(input.id, grade);
 				return {
 					id: record.id,
-					outcome: input.outcome,
-					confidence: record.confidence
+					outcome,
+					confidence: record.confidence,
+					...scheduled?.review?.nextReviewAt === null || scheduled?.review?.nextReviewAt === void 0 ? {} : { nextReviewAt: scheduled.review.nextReviewAt }
 				};
 			}
 		}),
+		reviewQueue,
 		defineTool({
 			name: "engram_review",
 			description: "审计一条记忆：查看内容、来源（会话/轮次/事件）、取代链、矛盾与关联，以及最近操作日志。",
@@ -3723,7 +4754,7 @@ function createEngramTools(deps) {
 		}),
 		defineTool({
 			name: "engram_stats",
-			description: "记忆库统计：各状态与种类数量、关系边数、信噪比、操作日志量。scope=all 时合并两库。",
+			description: "记忆库统计：各状态与种类数量、关系边数、信噪比、操作日志量，以及房间目录（房名/桩位数/最新门牌——检索前先看目录决定进哪个房间，配 engram_search 的 room 参数）。scope=all 时合并两库。",
 			parameters: { scope: {
 				type: "string",
 				enum: [
@@ -3750,19 +4781,38 @@ function createEngramTools(deps) {
 			},
 			async execute(args) {
 				const scopes = scopesOf(args.scope);
-				return { text: (await Promise.all(scopes.map(async (scope) => ({
-					scope,
-					stats: await (await deps.openStore(scope)).stats()
-				})))).map(({ scope, stats }) => [
-					`[${scope}] 总数 ${stats.total}（active ${stats.active} / archived ${stats.archived} / forgotten ${stats.forgotten}）`,
-					`种类分布: ${Object.entries(stats.byKind).map(([kind, count]) => `${kind}=${count}`).join(", ") || "空"}`,
-					`关系边 ${stats.edges} 条 · 信噪比 ${(stats.signalRatio * 100).toFixed(1)}% · 操作日志 ${stats.opLogCount} 条`
-				].join("\n")).join("\n\n") };
+				return { text: (await Promise.all(scopes.map(async (scope) => {
+					const store = await deps.openStore(scope);
+					const [storeStats, rooms, placards] = await Promise.all([
+						store.stats(),
+						store.slotCountsByRoom(),
+						store.listPlacards()
+					]);
+					return {
+						scope,
+						stats: storeStats,
+						rooms,
+						placards
+					};
+				}))).map(({ scope, stats, rooms, placards }) => {
+					const latestPlacardByRoom = /* @__PURE__ */ new Map();
+					for (const row of placards) if (row.room !== null) latestPlacardByRoom.set(row.room, row.caption);
+					const roomLines = Object.entries(rooms).sort(([a], [b]) => a.localeCompare(b, "zh-Hans-CN")).map(([room, state]) => {
+						const placard = latestPlacardByRoom.get(room);
+						return `  ${room}: ${state.count}/${state.maxIndex} 桩${placard === void 0 ? "" : ` · 最新门牌「${placard}」`}`;
+					});
+					return [
+						`[${scope}] 总数 ${stats.total}（active ${stats.active} / archived ${stats.archived} / forgotten ${stats.forgotten}）`,
+						`种类分布: ${Object.entries(stats.byKind).map(([kind, count]) => `${kind}=${count}`).join(", ") || "空"}`,
+						`关系边 ${stats.edges} 条 · 信噪比 ${(stats.signalRatio * 100).toFixed(1)}% · 操作日志 ${stats.opLogCount} 条`,
+						roomLines.length === 0 ? "房间目录: （尚未排桩）" : `房间目录（engram_search 用 room 参数直进）:\n${roomLines.join("\n")}`
+					].join("\n");
+				}).join("\n\n") };
 			}
 		}),
 		defineTool({
 			name: "engram_export",
-			description: "把记忆库导出为文件（Markdown / JSON / 镜像目录），返回文件路径。redactedView=true 时输出脱敏视图（内容二次清洗并截断为 40 字预览，可安全分享）。format=markdown-mirror 时每个房间一个 .md + frontmatter，附楼层清单 _meta.json 与全宫殿入口 _index.md，可直接用 Obsidian / git 漫游。",
+			description: "把记忆库导出为文件（Markdown / JSON / 镜像目录），返回文件路径。redactedView=true 时输出脱敏视图（内容二次清洗并截断为 40 字预览，可安全分享）。format=markdown-mirror 时按房间（kind）分目录、每条记忆一个 .md + frontmatter，附房间清单 _meta.json 与全宫殿入口 _index.md，可直接用 Obsidian / git 漫游。",
 			parameters: {
 				format: {
 					type: "string",
@@ -3771,7 +4821,7 @@ function createEngramTools(deps) {
 						"json",
 						"markdown-mirror"
 					],
-					description: "导出格式：markdown 单文件、json 单文件、markdown-mirror 每房间一文件（默认 markdown）"
+					description: "导出格式：markdown 单文件、json 单文件、markdown-mirror 每条记忆一文件（按房间分目录，默认 markdown）"
 				},
 				scope: {
 					type: "string",
@@ -3822,7 +4872,7 @@ function createEngramTools(deps) {
 						const stamp = (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-").slice(0, 19);
 						const mirrorRoot = join(deps.exportDir, `mirror-${scope}-${stamp}`);
 						const report = await writeMirror(mirrorRoot, data);
-						written.push(`${mirrorRoot}（${report.fileCount} 个文件，${data.records.length} 间房间，${report.floors.length} 个楼层）`);
+						written.push(`${mirrorRoot}（${report.fileCount} 个文件，${data.records.length} 条记忆，${report.rooms.length} 个房间）`);
 						continue;
 					}
 					const payload = redactedView ? {
@@ -3905,11 +4955,11 @@ function createEngramTools(deps) {
 		}),
 		defineTool({
 			name: "engram_examine",
-			description: "渐进式披露：按 id 批量拉取房间完整铭牌（content + 楼层 + 状态 + 边关系）。仅在已通过 engram_search/timeline/neighbors 拿到候选 id 后调用，避免一次性吞全文。建议 ≤16 个 id，超出会按入参顺序保留前 N 条。",
+			description: "渐进式披露：按 id 批量拉取记忆完整铭牌（content + 房间 + 状态 + 边关系）。仅在已通过 engram_search/timeline/neighbors 拿到候选 id 后调用，避免一次性吞全文。建议 ≤16 个 id，超出会按入参顺序保留前 N 条。",
 			parameters: { ids: {
 				type: "array",
 				items: { type: "string" },
-				description: "房间 id 列表"
+				description: "记忆 id 列表"
 			} },
 			output: {
 				schema: {
@@ -3944,11 +4994,11 @@ function createEngramTools(deps) {
 		}),
 		defineTool({
 			name: "engram_neighbors",
-			description: "走廊漫步：从某间出发走 1-3 跳内的 related/supersedes/contradicts 边，返回邻居房间简表（仅 id + scope + kind + status + content），便于判断下一站。",
+			description: "走廊漫步：从某条记忆出发走 1-3 跳内的 related/supersedes/contradicts 边，返回邻居记忆简表（仅 id + scope + kind + status + content），便于判断下一站。",
 			parameters: {
 				id: {
 					type: "string",
-					description: "起点房间 id"
+					description: "起点记忆 id"
 				},
 				depth: {
 					type: "integer",
@@ -3980,19 +5030,23 @@ function createEngramTools(deps) {
 				if (seedRow === void 0) throw new Error(`engram_neighbors: 起点 ${seed} 不存在`);
 				const seedScope = seedRow.scope;
 				const neighbors = await (seedScope === "user" ? userStore : projectStore).neighbors(seed, depth);
-				if (neighbors.length === 0) return { text: `从 ${seed}（${seedScope}）出发，${depth} 跳内无邻居房间。` };
+				if (neighbors.length === 0) return { text: `从 ${seed}（${seedScope}）出发，${depth} 跳内无邻居记忆。` };
 				const lines = neighbors.map((record, index) => `${index + 1}. [${record.scope}/${record.kind}/${record.status}] ${record.content.slice(0, 80)}${record.content.length > 80 ? "…" : ""}（id=${record.id}）`);
-				return { text: `起点 ${seed}（${seedScope}）→ ${depth} 跳走廊共访 ${neighbors.length} 间：\n${lines.join("\n")}` };
+				return { text: `起点 ${seed}（${seedScope}）→ ${depth} 跳走廊共访 ${neighbors.length} 条：\n${lines.join("\n")}` };
 			}
 		}),
 		defineTool({
 			name: "engram_tour",
-			description: "巡游路由：按「同类巩固 → 走廊相邻 → 反差补位」顺序组织 3-7 间房间，每站附入选理由 + 意象铭牌回声。适合在用户问起某主题时直接给出一条可走的导览路线，而不是无序结果集。",
+			description: "巡游路由。mode=fixed：按固定巡游路线走全宫（桩位顺序恒定，骨架长期复用——宫殿的路线永远不变，靠顺序提取）；mode=thematic（默认）：按主题动态规划 3-7 站（同类巩固 → 走廊相邻 → 反差补位），适合用户问起某主题时给出一条可走的导览路线。",
 			parameters: {
 				query: {
 					type: "string",
-					required: true,
-					description: "巡游主题（与 engram_search 同义）"
+					description: "巡游主题（thematic 模式必填，与 engram_search 同义）"
+				},
+				mode: {
+					type: "string",
+					enum: ["fixed", "thematic"],
+					description: "fixed 固定路线全宫巡游 / thematic 主题动态路线（默认 thematic）"
 				},
 				scope: {
 					type: "string",
@@ -4006,7 +5060,7 @@ function createEngramTools(deps) {
 				},
 				maxStops: {
 					type: "integer",
-					description: "最多站数（默认 6，3-7 之间）"
+					description: "最多站数（默认 6，3-7 之间；fixed 模式默认 20）"
 				}
 			},
 			output: {
@@ -4026,9 +5080,41 @@ function createEngramTools(deps) {
 			async execute(args, exec) {
 				const input = args;
 				const scopes = scopesOf(input.scope);
+				if ((input.mode === "fixed" ? "fixed" : "thematic") === "fixed") {
+					const maxStops = Number.isInteger(input.maxStops) ? Math.max(1, input.maxStops) : 20;
+					const sections = [];
+					let shown = 0;
+					let skipped = 0;
+					for (const scope of scopes) {
+						const store = await deps.openStore(scope);
+						const route = await store.routeList();
+						if (route.length === 0) continue;
+						const records = await store.getMany(route.map((stop) => stop.id));
+						const byId = new Map(records.map((record) => [String(record.id), record]));
+						const lines = [];
+						for (const stop of route) {
+							if (shown >= maxStops) break;
+							const record = byId.get(String(stop.id));
+							if (record === void 0 || record.status !== "active") {
+								skipped += 1;
+								continue;
+							}
+							shown += 1;
+							const slot = record.slot === void 0 ? "" : `${record.slot.room} #${record.slot.index} · `;
+							const placard = record.imagery?.caption;
+							lines.push(`第 ${stop.position + 1} 站 · ${slot}[${record.kind}] ${truncateItem(record.content)}（id=${record.id}）${placard === null || placard === void 0 ? "" : ` · 门牌「${placard}」`}`);
+						}
+						if (lines.length > 0) sections.push(`【${scope} 宫殿 · 固定巡游】\n${lines.join("\n")}`);
+					}
+					if (shown === 0) return { text: "巡游路线为空：尚无排桩记忆（保存记忆后自动登记路线）。" };
+					const tail = skipped > 0 ? `\n（另有 ${skipped} 个空桩：原记忆已闭馆或归档，桩位保留不回收）` : "";
+					return { text: `${sections.join("\n\n")}${tail}` };
+				}
+				if (typeof input.query !== "string" || input.query.trim() === "") throw new Error("engram_tour: thematic 模式需要 query 参数（巡游主题）");
+				const tourQuery = input.query;
 				const limit = 12;
 				const maxStops = Number.isInteger(input.maxStops) ? Math.min(Math.max(3, input.maxStops), 7) : 6;
-				const rewrite = await rewriteQueries(deps, exec, input.query);
+				const rewrite = await rewriteQueries(deps, exec, tourQuery);
 				const retrievals = await Promise.all(rewrite.queries.map(async (queryText) => {
 					const vector = await queryVectorOf(deps, queryText);
 					const results = await Promise.all(scopes.map(async (scope) => {
@@ -4048,17 +5134,18 @@ function createEngramTools(deps) {
 				const userStore = await deps.openStore("user");
 				const projectStore = await deps.openStore("project");
 				const poolLookup = async (id) => await userStore.get(id) ?? await projectStore.get(id);
-				const route = await planTour(merged, poolLookup, input.query, maxStops);
+				const route = await planTour(merged, poolLookup, tourQuery, maxStops);
 				return { text: `${degraded ? "（语义嵌入不可用，仅关键词检索）\n" : ""}${route.narrative}` };
 			}
 		}),
-		auditForgotten
+		auditForgotten,
+		ingestHistory
 	];
 }
 /**
 * 构造巡游路径：在 search 命中的基础上按路径策略重排。
 * 1) 起点簇：取命中中 kind 出现频次最高的前 N 个同 kind 节点（同类巩固）。
-* 2) 走廊扩展：从起点簇每个节点的 1-跳 neighbors 中挑 active 且 score > 0 的房间。
+* 2) 走廊扩展：从起点簇每个节点的 1-跳 neighbors 中挑 active 且 score > 0 的记忆。
 * 3) 反差收束：从剩余命中挑一个 emotionalValence ≥ 0.7 的做收束（强反差唤醒）。
 * 命中不足时按可用性回退；命中为 0 时返回空 stops。
 */
@@ -4141,13 +5228,13 @@ function renderTourNarrative(stops, query) {
 }
 //#endregion
 //#region src/selection-rationale.ts
-/** 给定一组入选房间，返回归因 XML 字符串；空 rooms 返回空串。 */
+/** 给定一组入选记忆，返回归因 XML 字符串；空 rooms 返回空串。 */
 function buildSelectionRationale(records) {
 	if (records.length === 0) return "";
 	const now = Date.now();
 	const lines = [
 		"<engram_selection_rationale>",
-		`本轮画像共 ${String(records.length)} 间房间，挑选理由如下：`,
+		`本轮画像共 ${String(records.length)} 条记忆，挑选理由如下：`,
 		""
 	];
 	for (const record of records) {
@@ -4193,7 +5280,7 @@ function reasonsLabel(reasons) {
 /** Cordis 插件名（loader 诊断与注入 source 使用）。 */
 const name = "dsh-engram";
 /** 插件版本（与 package.json 同步，写进备份 _meta.json）。 */
-const VERSION = "0.7.0";
+const VERSION = "0.7.2";
 /** 必需服务：工具注册表与 LLM 流式端点（摄取/蒸馏的辅助调用）。 */
 const inject = ["tools", "llm"];
 /**
@@ -4206,13 +5293,14 @@ const inject = ["tools", "llm"];
 */
 function renderProfileDetailed(records, tokenBudget) {
 	const estimate = (text) => Math.ceil(text.length / 4);
-	const header = "User memory profile (dsh-engram, cross-session):";
-	const footer = "Use engram_search to recall details; use engram_save to persist new facts.";
+	const header = "User memory profile (dsh-engram, cross-session) — Grand Hall (always present):";
+	const footer = "Use engram_search to recall details (pass room to search inside one room); use engram_save to persist new facts.";
 	let remaining = Math.max(0, tokenBudget - estimate(header) - estimate(footer));
 	const lines = [];
 	const overflow = [];
 	for (const record of records) {
-		const line = `- [${record.kind}] ${record.content}`;
+		const slot = record.slot === void 0 ? "" : ` ${record.slot.room}#${record.slot.index}`;
+		const line = `- [${record.kind}]${slot} ${record.content}`;
 		const cost = estimate(line);
 		if (cost <= remaining) {
 			lines.push(line);
@@ -4303,6 +5391,10 @@ async function compressProfileOverflow(ctx, agent, routeOverride, overflow, sign
 async function preStep(ctx, openStore, resolved, embedder, state, logRequest, { agent, step, turn, signal }, next) {
 	const decision = await next();
 	if (decision.kind === "reject") return decision;
+	if (step === 1) {
+		const currentRoute = resolved.routeOverride ?? routeFromEvents(agent.session.snapshotEvents());
+		if (currentRoute !== void 0) state.route = currentRoute;
+	}
 	const mode = resolved.ingest;
 	if (step === 1 && mode !== "off") {
 		if (!state.pendingReplayed) {
@@ -4344,6 +5436,7 @@ async function preStep(ctx, openStore, resolved, embedder, state, logRequest, {
 	if (step !== 1) return decision;
 	const top = await (await openStore("user")).topActive("user", resolved.profileTopN);
 	if (top.length === 0) return decision;
+	const dueTotal = resolved.reviewScheduling ? (await Promise.all(["user", "project"].map(async (scope) => (await openStore(scope)).dueReviews(Date.now(), 50)))).reduce((sum, rows) => sum + rows.length, 0) : 0;
 	const detailed = renderProfileDetailed(top, resolved.injectTokenBudget);
 	let text = detailed.text;
 	if (detailed.overflow.length > 0) {
@@ -4359,7 +5452,8 @@ async function preStep(ctx, openStore, resolved, embedder, state, logRequest, {
 			}), resolved.injectTokenBudget).text;
 		}
 	}
-	const textWithRationale = wrapWithRationale(text, top);
+	const dueLine = dueTotal === 0 ? "" : `\nPalace review due today: ${dueTotal}${dueTotal >= 50 ? "+" : ""} memories. Use engram_review_queue for active recall (recall beats re-reading).`;
+	const textWithRationale = wrapWithRationale(text, top) + dueLine;
 	const hash = createHash("sha256").update(textWithRationale).digest("hex");
 	if (state.lastProfileAgent === String(agent.id) && hash === state.lastProfileHash) return decision;
 	state.lastProfileAgent = String(agent.id);
@@ -4422,16 +5516,183 @@ function apply(ctx, config = {}) {
 		decayAfterDays: resolved.decayAfterDays
 	};
 	const stores = /* @__PURE__ */ new Map();
-	const openStore = (scope) => {
-		const existing = stores.get(scope);
+	/** 打开（或复用）一个分库文件；首次打开时幂等补齐存量排桩。 */
+	const openDb = (dbName) => {
+		const existing = stores.get(dbName);
 		if (existing !== void 0) return existing;
-		const created = openEngramStore(scope === "user" ? join(resolved.dbDir, "user.db") : scope === "shared" ? join(resolved.dbDir, "shared.db") : join(resolved.dbDir, identity.dbName), rankBoost);
-		stores.set(scope, created);
+		const path = join(resolved.dbDir, dbName);
+		const created = openEngramStore(path, rankBoost, {
+			autoSlot: resolved.autoSlot,
+			reviewScheduling: resolved.reviewScheduling
+		}).then(async (store) => {
+			const assigned = await store.backfillSlots((room) => {
+				console.warn(`[dsh-engram] 房间已满，自动开新房「${room}」（可在管理面板翻新清单中人工拆分/命名）`);
+			});
+			if (assigned > 0) console.warn(`[dsh-engram] 存量记忆排桩完成：${assigned} 条已钉入宫殿（${path}）`);
+			return store;
+		});
+		stores.set(dbName, created);
 		return created;
 	};
+	const openStore = (scope) => openDb(scope === "user" ? "user.db" : scope === "shared" ? "shared.db" : identity.dbName);
+	/** cwd → 分库文件名（历史回填会对每个历史 cwd 解析一次，避免重复读 git 元数据）。 */
+	const cwdDbNames = /* @__PURE__ */ new Map();
+	/**
+	* 按任意 cwd 的项目标识打开分库（历史回填专用）：历史会话写进它自己项目的库，
+	* 而不是当前工作目录的库——否则跨项目内容会串库。
+	* @param cwd - 历史会话 header 里记录的 cwd。
+	* @returns 该 cwd 对应项目分库的连接。
+	*/
+	/** cwd → 分库文件名（缓存，避免重复读 git 元数据与重复迁移检查）。 */
+	const dbNameForCwd = (cwd) => {
+		const cached = cwdDbNames.get(cwd);
+		if (cached !== void 0) return cached;
+		const projectIdentity = resolveProjectIdentity(cwd);
+		if (migrateProjectDb(resolved.dbDir, projectIdentity) === "renamed") console.warn(`[dsh-engram] 历史项目库已迁移为 origin 命名（${cwd}）`);
+		cwdDbNames.set(cwd, projectIdentity.dbName);
+		return projectIdentity.dbName;
+	};
+	const openStoreForProjectCwd = (cwd) => openDb(dbNameForCwd(cwd));
 	const embedder = createLocalEmbedder(resolved.modelCacheDir, resolved.hfEndpoint).catch((error) => {
 		console.warn("[dsh-engram] 嵌入器不可用，检索降级为纯关键词模式：", error);
 	});
+	const logIngestRequest = (data) => {
+		openStore("user").then((store) => store.audit("ingest-request", "AUX", JSON.stringify(data))).catch(() => {});
+	};
+	const preStepState = {
+		pendingReplayed: false,
+		lastProfileAgent: null,
+		lastProfileHash: null,
+		route: void 0
+	};
+	/** 会话持久化服务（可选；缺席时历史回填不可用）。 */
+	const persistenceService = () => {
+		const persistence = ctx.get("sessionPersistence");
+		if (persistence === void 0) return void 0;
+		return {
+			list: (signal) => persistence.list(signal),
+			load: (id) => persistence.load(id)
+		};
+	};
+	/** user 分库若已存在则打开（估算用：不因估算产生空库文件）。 */
+	const openUserStoreIfExists = () => existsSync(join(resolved.dbDir, "user.db")) ? openStore("user") : Promise.resolve(void 0);
+	/** 指定 cwd 的项目库若已存在则打开（估算用：不因估算产生空库文件）。 */
+	const openProjectStoreIfExists = (cwd) => {
+		const dbName = dbNameForCwd(cwd);
+		return existsSync(join(resolved.dbDir, dbName)) ? openDb(dbName) : Promise.resolve(void 0);
+	};
+	/** 组装历史回填依赖；source 每次现取，兼容持久化服务在插件之后挂载的组合。 */
+	const buildHistoryDeps = () => ({
+		source: persistenceService(),
+		resolveStore: openStoreForProjectCwd,
+		resolveExistingStore: openProjectStoreIfExists,
+		openUserStore: () => openStore("user"),
+		resolveExistingUserStore: openUserStoreIfExists,
+		embedder,
+		mode: resolved.ingest === "off" ? "light" : resolved.ingest,
+		routeOverride: resolved.routeOverride ?? preStepState.route,
+		call: (callParams) => streamText(ctx, {
+			...callParams,
+			sessionId: ""
+		}),
+		logRequest: logIngestRequest
+	});
+	/** 回填任务（进程内单例；面板轮询它的进度，工具同步等待自己的那一次运行）。 */
+	let backfillJob;
+	/** 历史回填对外接口：面板路由（异步 job）与工具（同步运行）共用。 */
+	const historyApi = {
+		/** 已注册的 provider 与模型清单（面板「辅助模型」下拉的数据源）。 */
+		models: async () => {
+			const llm = ctx.get("llm");
+			if (llm === void 0) return {
+				providers: [],
+				failures: []
+			};
+			const failures = [];
+			return {
+				providers: await Promise.all(llm.listProviders().map(async (provider) => {
+					try {
+						const models = await llm.listModels(provider.id);
+						return {
+							id: provider.id,
+							name: provider.name,
+							models: models.map((model) => ({
+								id: model.id,
+								name: model.name
+							}))
+						};
+					} catch (error) {
+						failures.push(`${provider.id}: ${error instanceof Error ? error.message : String(error)}`);
+						return {
+							id: provider.id,
+							name: provider.name,
+							models: []
+						};
+					}
+				})),
+				failures
+			};
+		},
+		estimate: (rules) => estimateHistoryBackfill(buildHistoryDeps(), resolved.historyBackfill, rules),
+		run: (rules, signal) => runHistoryBackfill(buildHistoryDeps(), resolved.historyBackfill, rules, () => {}, signal),
+		/** 启动后台回填；已有任务在跑时拒绝（面板按钮据此禁用）。 */
+		start: (rules) => {
+			if (backfillJob !== void 0 && backfillJob.progress.state === "running") return {
+				ok: false,
+				reason: "已有回填任务正在运行，请先暂停或等待完成"
+			};
+			const controller = new AbortController();
+			const job = {
+				controller,
+				failures: [],
+				progress: {
+					state: "running",
+					sessionsTotal: 0,
+					sessionsDone: 0,
+					turnsPlanned: 0,
+					turnsDone: 0,
+					memoriesWritten: 0,
+					turnsSkipped: 0,
+					turnsFailed: 0,
+					skipReasons: {}
+				}
+			};
+			backfillJob = job;
+			runHistoryBackfill(buildHistoryDeps(), resolved.historyBackfill, rules, (progress) => {
+				job.progress = progress;
+			}, controller.signal).then((result) => {
+				job.progress = result;
+				job.failures = result.failures;
+			}).catch((error) => {
+				console.warn("[dsh-engram] 历史回填失败：", error);
+				job.progress = {
+					...job.progress,
+					state: "failed"
+				};
+				job.error = error instanceof Error ? error.message : String(error);
+			});
+			return { ok: true };
+		},
+		cancel: () => {
+			backfillJob?.controller.abort();
+		},
+		/** 当前任务快照；从未跑过时返回 idle 占位。 */
+		status: () => ({
+			progress: backfillJob?.progress ?? {
+				state: "done",
+				sessionsTotal: 0,
+				sessionsDone: 0,
+				turnsPlanned: 0,
+				turnsDone: 0,
+				memoriesWritten: 0,
+				turnsSkipped: 0,
+				turnsFailed: 0,
+				skipReasons: {}
+			},
+			failures: backfillJob?.failures ?? [],
+			...backfillJob?.error === void 0 ? {} : { error: backfillJob.error }
+		})
+	};
 	for (const tool of createEngramTools({
 		openStore,
 		embedder,
@@ -4441,7 +5702,11 @@ function apply(ctx, config = {}) {
 		}),
 		routeOverride: resolved.routeOverride,
 		queryRewrite: resolved.queryRewrite,
-		exportDir: `${resolved.dbDir}/exports`
+		exportDir: `${resolved.dbDir}/exports`,
+		historyBackfill: {
+			estimate: historyApi.estimate,
+			run: historyApi.run
+		}
 	})) ctx.tools.register(tool);
 	ctx.inject(["webServer"], (webCtx) => {
 		registerEngramRoutes(webCtx, {
@@ -4450,20 +5715,18 @@ function apply(ctx, config = {}) {
 			mirrorDir: `${resolved.dbDir}/palaces`,
 			dbDir: resolved.dbDir,
 			pluginVersion: VERSION,
-			embedder
+			embedder,
+			history: {
+				estimate: historyApi.estimate,
+				start: historyApi.start,
+				cancel: historyApi.cancel,
+				status: historyApi.status,
+				models: historyApi.models,
+				defaults: resolved.historyBackfill
+			}
 		});
 	});
-	const logIngestRequest = (data) => {
-		openStore("user").then((store) => store.audit("ingest-request", "AUX", JSON.stringify(data))).catch(() => {});
-	};
-	if (resolved.injectProfile || resolved.ingest !== "off") {
-		const state = {
-			pendingReplayed: false,
-			lastProfileAgent: null,
-			lastProfileHash: null
-		};
-		ctx.on("agent/pre-step", (payload, next) => preStep(ctx, openStore, resolved, embedder, state, logIngestRequest, payload, next), { prepend: true });
-	}
+	if (resolved.injectProfile || resolved.ingest !== "off") ctx.on("agent/pre-step", (payload, next) => preStep(ctx, openStore, resolved, embedder, preStepState, logIngestRequest, payload, next), { prepend: true });
 	if (resolved.ingest !== "off") ctx.on("session/disposed", (session) => {
 		const mode = resolved.ingest;
 		if (mode === "off") return;
@@ -4482,6 +5745,8 @@ function apply(ctx, config = {}) {
 			}),
 			logRequest: logIngestRequest,
 			signal: AbortSignal.timeout(FINAL_INGEST_TIMEOUT_MS)
+		}).catch((error) => {
+			console.warn("[dsh-engram] 会话结束的末轮摄取异常（不影响对话）：", error);
 		});
 	});
 	const runDecay = async () => {