@kenz1117/dsh-engram 0.7.4 → 0.7.6

package/lib/index.js

@@ -7,6 +7,7 @@ import z from "@deepseek-ai/schemastery";
 import { mkdir, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { createGzip, gunzip } from "node:zlib";
 import { promisify } from "node:util";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 //#region src/config.ts
 /**
@@ -519,10 +520,31 @@ function decodeTurnKey(detail) {
 }
 const INGEST_SYSTEM = [
 	"从对话记录中提取值得跨会话长期记住的用户信息（事实/偏好/决策/经历/做事方法）。",
-	"只输出一个 JSON 数组，每项形如 {\"content\": \"一句话完整表述\", \"kind\": \"fact|preference|decision|episode|skill\", \"importance\": 0到1的小数}。",
+	"只输出一个 JSON 数组，每项形如 {\"content\": \"一句话完整表述\", \"kind\": \"fact|preference|decision|episode|skill\", \"scope\": \"project|user\", \"importance\": 0到1的小数}。",
+	"scope 决定这条记忆进哪座宫殿：只跟当前项目/仓库有关的（技术选型、项目约定、架构决策、该项目自身的事实）用 project；与具体项目无关、跨项目通用的（个人偏好、习惯、用户本人的经历、通用事实）用 user。拿不准用 project。",
 	"只提取明确、可复用的信息；寒暄、临时上下文、你自己的回答不要提取。没有值得记的就输出 []。",
 	"不要输出 JSON 以外的任何内容。"
 ].join("\n");
+/**
+* 组装一次摄取的写入路由：会话有 cwd（可归属项目）时默认进项目宫殿且采纳模型的逐条判定，
+* 明显跨项目的个人偏好可被标成 user 落私人宫殿；无 cwd 的会话只能进私人宫殿，
+* 故关掉逐条判定（否则 project 标记落进 user 库后检索不可见）。
+* @param cwd - 会话工作目录；空串/undefined = 无法归属项目。
+* @param openProjectStore - 按 cwd 打开项目分库。
+* @param openScopeStore - 按作用域打开分库（user / shared）。
+* @returns 可直接展开进 IngestDeps / ReplayIngestDeps 的路由字段。
+*/
+function ingestWriteRouting(cwd, openProjectStore, openScopeStore) {
+	if (cwd === void 0 || cwd === "") return {
+		writeScope: "user",
+		perCandidateScope: false
+	};
+	return {
+		writeScope: "project",
+		perCandidateScope: true,
+		resolveStore: (scope) => scope === "project" ? openProjectStore(cwd) : openScopeStore(scope)
+	};
+}
 /** 从事件里按类型收集文本块，跳过插件注入的 user 快照（它们不是用户说的话）。 */
 function collectTexts(events, includeAssistant) {
 	const texts = [];
@@ -672,8 +694,9 @@ async function ingestPreviousTurn(deps) {
 		skipped: typeof sliceMode === "number" ? "no-such-turn" : "no-previous-turn"
 	};
 	const store = await deps.openStore();
+	const auditStore = deps.openAuditStore === void 0 ? store : await deps.openAuditStore();
 	const doneKey = encodeTurnKey(deps.sessionId, round);
-	if (await store.hasAudit("ingest-done", doneKey)) return {
+	if (await auditStore.hasAudit("ingest-done", doneKey)) return {
 		scannedEvents: slice.length,
 		candidates: 0,
 		written: 0,
@@ -742,14 +765,17 @@ async function ingestPreviousTurn(deps) {
 			"episode",
 			"skill"
 		].includes(candidate.kind) ? candidate.kind : "fact";
+		const modelScope = candidate.scope === "user" || candidate.scope === "project" ? candidate.scope : void 0;
+		const scope = deps.perCandidateScope === true && modelScope !== void 0 ? modelScope : deps.writeScope ?? "user";
+		const target = deps.resolveStore === void 0 ? store : await deps.resolveStore(scope);
 		const importance = typeof candidate.importance === "number" && Number.isFinite(candidate.importance) ? Math.min(1, Math.max(0, candidate.importance)) : .5;
 		if (embedder !== void 0) {
 			const vector = (await embedder.embed([content]))[0];
-			if (vector !== void 0 && (await store.findContradictions(vector, 1)).length > 0) continue;
+			if (vector !== void 0 && (await target.findContradictions(vector, 1)).length > 0) continue;
 		}
 		if (writtenContents.includes(content)) continue;
-		await store.write({
-			scope: deps.writeScope ?? "user",
+		await target.write({
+			scope,
 			kind,
 			content,
 			importance,
@@ -763,7 +789,7 @@ async function ingestPreviousTurn(deps) {
 		writtenContents.push(content);
 		written += 1;
 	}
-	await store.audit(INGEST_DONE_OP, deps.sessionId, doneKey);
+	await auditStore.audit(INGEST_DONE_OP, deps.sessionId, doneKey);
 	return {
 		scannedEvents: slice.length,
 		candidates: parsed.length,
@@ -800,7 +826,7 @@ async function ingestFinalTurn(deps) {
 		});
 	} catch (error) {
 		if (round !== void 0) try {
-			await markPendingIngest(await deps.openStore(), deps.sessionId, round);
+			await markPendingIngest(await (deps.openAuditStore ?? deps.openStore)(), deps.sessionId, round);
 		} catch {}
 		console.warn("[dsh-engram] 会话结束的末轮摄取失败（已记入待补做队列，不影响对话）：", error);
 		return null;
@@ -809,6 +835,7 @@ async function ingestFinalTurn(deps) {
 /**
 * 重放待补做的末轮摄取（下次会话首次 pre-step 调用）。已有 done 标记或键损坏的
 * pending 直接出队；事件源不可得的保留到下次。单个键失败抛出，剩余键留待下次。
+* 每条 pending 按它自己会话的 cwd 组装写入路由（补做时同样逐条判宫殿）。
 */
 async function replayPendingIngests(deps) {
 	const store = await deps.openStore();
@@ -821,17 +848,19 @@ async function replayPendingIngests(deps) {
 			await store.clearAudit(INGEST_PENDING_OP, detail);
 			continue;
 		}
-		const events = await deps.resolveEvents(key.sessionId);
-		if (events === void 0) {
+		const session = await deps.resolveSession(key.sessionId);
+		if (session === void 0) {
 			kept += 1;
 			continue;
 		}
 		await ingestPreviousTurn({
-			events,
+			events: session.events,
 			sessionId: key.sessionId,
 			turn: key.turn,
 			slice: key.turn,
 			openStore: deps.openStore,
+			openAuditStore: deps.openStore,
+			...ingestWriteRouting(session.cwd, deps.resolveStore, deps.openStore),
 			embedder: deps.embedder,
 			mode: deps.mode,
 			routeOverride: deps.routeOverride,
@@ -956,20 +985,23 @@ async function selectSessions(deps, rules) {
 			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 === "" ? {
+			if (cwd === void 0 || cwd === "") return {
 				header,
 				events,
 				turns,
 				openStore: deps.openUserStore,
-				writeScope: "user",
-				storeKey: "user"
-			} : {
+				routing: {
+					writeScope: "user",
+					perCandidateScope: false
+				}
+			};
+			const projectCwd = cwd;
+			return {
 				header,
 				events,
 				turns,
-				openStore: () => deps.resolveStore(cwd),
-				writeScope: "project",
-				storeKey: cwd
+				openStore: () => deps.resolveStore(projectCwd),
+				routing: ingestWriteRouting(projectCwd, deps.resolveStore, deps.openUserStore)
 			};
 		}));
 		loaded.push(...settled);
@@ -1026,13 +1058,13 @@ async function estimateHistoryBackfill(deps, defaults, overrides = {}) {
 		unavailable: UNAVAILABLE_REASON
 	};
 	const { candidates, skipped, truncated } = await selectSessions(deps, rules);
+	const auditStore = await deps.resolveExistingUserStore();
 	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;
+		if (auditStore === void 0) continue;
+		for (const turn of candidate.turns) if (await auditStore.hasAudit("ingest-done", encodeTurnKey(candidate.header.id, turn))) alreadyIngested += 1;
 	}
 	return {
 		rules,
@@ -1085,6 +1117,8 @@ async function runHistoryBackfill(deps, defaults, overrides, onProgress, signal)
 					turn,
 					slice: turn,
 					openStore: () => candidate.openStore(),
+					openAuditStore: deps.openUserStore,
+					...candidate.routing,
 					embedder: deps.embedder,
 					mode: deps.mode,
 					routeOverride,
@@ -1092,8 +1126,7 @@ async function runHistoryBackfill(deps, defaults, overrides, onProgress, signal)
 					logRequest: deps.logRequest,
 					signal,
 					throttle: true,
-					history: true,
-					writeScope: candidate.writeScope
+					history: true
 				});
 				progress.memoriesWritten += outcome.written;
 				if (outcome.skipped !== null) {
@@ -1955,6 +1988,13 @@ function historyRulesOf(raw) {
 		...includeNoCwd === void 0 ? {} : { includeNoCwd }
 	};
 }
+/** 未知项目选择器（路由统一映射为 404）。 */
+var UnknownProjectError = class extends Error {
+	constructor(selector) {
+		super(`unknown project: ${selector}`);
+		this.name = "UnknownProjectError";
+	}
+};
 /**
 * 注册 /engram 页面与 /api/engram/* 接口（effect 由调用方持有，disposer 可逆）。
 * @param ctx - 携带 webServer 服务的宿主上下文。
@@ -1967,11 +2007,37 @@ function registerEngramRoutes(ctx, deps) {
 			if (!guardLoopback(req, res)) return;
 			const url = new URL(req.url ?? "/", "http://127.0.0.1");
 			const route = url.pathname.slice(12);
+			const selectorRef = { value: url.searchParams.get("project") ?? void 0 };
+			/** 按作用域取分库：project 走选择器解析，未知选择器抛错 → catch 统一 404。 */
+			const storeFor = async (scope) => {
+				if (scope !== "project") return deps.openStore(scope);
+				const opened = await deps.projects.open(selectorRef.value);
+				if (opened === void 0) throw new UnknownProjectError(selectorRef.value ?? "");
+				return opened.store;
+			};
+			/** POST body 里的项目选择器（面板所有写操作都会带）。 */
+			const adoptBodySelector = (body) => {
+				const raw = body?.["project"];
+				if (typeof raw === "string" && raw !== "") selectorRef.value = raw;
+			};
 			try {
+				if (req.method === "GET" && route === "workspaces") {
+					const items = await deps.projects.list();
+					const processDefault = items.find((item) => item.kind === "process");
+					json(res, 200, {
+						items,
+						processDefault: processDefault === void 0 ? null : {
+							dbName: processDefault.dbName,
+							path: processDefault.path,
+							title: processDefault.title
+						}
+					});
+					return;
+				}
 				if (req.method === "GET" && route === "stats") {
 					json(res, 200, { parts: await Promise.all(["user", "project"].map(async (scope) => ({
 						scope,
-						stats: await (await deps.openStore(scope)).stats()
+						stats: await (await storeFor(scope)).stats()
 					}))) });
 					return;
 				}
@@ -1993,7 +2059,7 @@ function registerEngramRoutes(ctx, deps) {
 						limit,
 						offset
 					};
-					json(res, 200, await (await deps.openStore(scope)).list(filter));
+					json(res, 200, await (await storeFor(scope)).list(filter));
 					return;
 				}
 				if (req.method === "GET" && route === "search-test") {
@@ -2009,7 +2075,7 @@ function registerEngramRoutes(ctx, deps) {
 					const embedder = deps.embedder === void 0 ? void 0 : await deps.embedder;
 					const vector = embedder === void 0 ? void 0 : (await embedder.embed([q.trim()]))[0];
 					const results = await Promise.all(scopes.map(async (scope) => {
-						return (await deps.openStore(scope)).search({
+						return (await storeFor(scope)).search({
 							text: q,
 							scopes: [scope],
 							limit
@@ -2037,7 +2103,7 @@ function registerEngramRoutes(ctx, deps) {
 				if (req.method === "GET" && route === "activity") {
 					const limit = Math.min(50, Math.max(1, Number(url.searchParams.get("limit") ?? 20) || 20));
 					json(res, 200, { operations: (await Promise.all(["user", "project"].map(async (scope) => {
-						return (await (await deps.openStore(scope)).recentOps(limit)).map((op) => ({
+						return (await (await storeFor(scope)).recentOps(limit)).map((op) => ({
 							...op,
 							scope
 						}));
@@ -2050,7 +2116,7 @@ function registerEngramRoutes(ctx, deps) {
 					const now = Date.now();
 					json(res, 200, {
 						scope,
-						items: (await (await deps.openStore(scope)).dueReviews(now, limit)).map((record) => ({
+						items: (await (await storeFor(scope)).dueReviews(now, limit)).map((record) => ({
 							id: record.id,
 							kind: record.kind,
 							...record.slot === void 0 ? {} : { slot: record.slot },
@@ -2074,8 +2140,8 @@ function registerEngramRoutes(ctx, deps) {
 						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);
+					adoptBodySelector(body);
+					const record = await (await storeFor(scopeOf$1(typeof body.scope === "string" ? body.scope : null, "user"))).scheduleReview(body.id, grade);
 					if (record === void 0) {
 						json(res, 404, { error: `未找到条目 ${body.id}` });
 						return;
@@ -2093,7 +2159,7 @@ function registerEngramRoutes(ctx, deps) {
 						json(res, 400, { error: "id required" });
 						return;
 					}
-					const view = await (await deps.openStore(scope)).review(id);
+					const view = await (await storeFor(scope)).review(id);
 					if (view === void 0) {
 						json(res, 404, { error: `未找到条目 ${id}` });
 						return;
@@ -2105,7 +2171,7 @@ function registerEngramRoutes(ctx, deps) {
 					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);
+					const due = await (await storeFor(scope)).dueReviews(now, limit);
 					json(res, 200, {
 						scope,
 						count: due.length,
@@ -2139,8 +2205,8 @@ function registerEngramRoutes(ctx, deps) {
 						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);
+					adoptBodySelector(body);
+					const record = await (await storeFor(scopeOf$1(typeof body.scope === "string" ? body.scope : null, "user"))).scheduleReview(body.id, grade);
 					if (record === void 0) {
 						json(res, 404, { error: `未找到条目 ${body.id}` });
 						return;
@@ -2151,7 +2217,7 @@ function registerEngramRoutes(ctx, deps) {
 				if (req.method === "GET" && route === "export") {
 					const scope = scopeOf$1(url.searchParams.get("scope"), "user");
 					const format = url.searchParams.get("format") === "json" ? "json" : "markdown";
-					const data = await (await deps.openStore(scope)).exportAll();
+					const data = await (await storeFor(scope)).exportAll();
 					const stamp = (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-");
 					const body = format === "json" ? JSON.stringify(data, null, 2) : [
 						`# dsh-engram 导出（${scope}）`,
@@ -2171,7 +2237,7 @@ function registerEngramRoutes(ctx, deps) {
 				}
 				if (req.method === "GET" && route === "mirror") {
 					const scope = scopeOf$1(url.searchParams.get("scope"), "user");
-					const data = await (await deps.openStore(scope)).exportAll();
+					const data = await (await storeFor(scope)).exportAll();
 					const stamp = (/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-").slice(0, 19);
 					json(res, 200, {
 						...await writeMirror(join(deps.mirrorDir, scope, stamp), data),
@@ -2185,7 +2251,7 @@ function registerEngramRoutes(ctx, deps) {
 					const rawScope = url.searchParams.get("scope");
 					const scopes = rawScope === "user" || rawScope === "project" || rawScope === "shared" ? [rawScope] : ["user", "project"];
 					const parts = await Promise.all(scopes.map(async (scope) => {
-						const store = await deps.openStore(scope);
+						const store = await storeFor(scope);
 						const s = await store.stats();
 						const edgeCount = (await store.exportAll()).edges.length;
 						const total = Math.max(s.total, 1);
@@ -2225,7 +2291,7 @@ function registerEngramRoutes(ctx, deps) {
 					if (rawStatus !== null && rawStatus !== "" && rawStatus !== "all") {
 						for (const s of rawStatus.split(",")) if (s === "active" || s === "archived" || s === "forgotten") includeStatuses.add(s);
 					}
-					const data = await (await deps.openStore(scope)).exportAll();
+					const data = await (await storeFor(scope)).exportAll();
 					const nodes = data.records.filter((r) => includeStatuses.has(r.status)).map((r) => ({
 						id: r.id,
 						scope: r.scope,
@@ -2252,14 +2318,13 @@ function registerEngramRoutes(ctx, deps) {
 				if (req.method === "GET" && route === "telemetry") {
 					const windowDays = Math.min(90, Math.max(1, Number(url.searchParams.get("days") ?? 7) || 7));
 					const rawScope = url.searchParams.get("scope");
-					const scopeFilter = rawScope === "user" ? "user" : rawScope === "project" ? "project" : rawScope === "shared" ? "shared" : void 0;
-					json(res, 200, await aggregateTelemetry(deps.openStore, windowDays, scopeFilter));
+					json(res, 200, await aggregateTelemetry((scope) => storeFor(scope), windowDays, rawScope === "user" ? "user" : rawScope === "project" ? "project" : rawScope === "shared" ? "shared" : void 0));
 					return;
 				}
 				if (req.method === "GET" && route === "tour-proposal") {
 					const rawScope = url.searchParams.get("scope");
 					const scope = rawScope === "project" ? "project" : rawScope === "shared" ? "shared" : "user";
-					const filter = await (await deps.openStore(scope)).list({
+					const filter = await (await storeFor(scope)).list({
 						scope,
 						status: "active",
 						limit: 200,
@@ -2285,7 +2350,7 @@ function registerEngramRoutes(ctx, deps) {
 				if (req.method === "GET" && route === "refurb") {
 					const rawScope = url.searchParams.get("scope");
 					const scope = rawScope === "project" ? "project" : rawScope === "shared" ? "shared" : "user";
-					const suggestions = gatherRefurbSuggestions((await (await deps.openStore(scope)).list({
+					const suggestions = gatherRefurbSuggestions((await (await storeFor(scope)).list({
 						scope,
 						status: "active",
 						limit: 500,
@@ -2349,10 +2414,11 @@ function registerEngramRoutes(ctx, deps) {
 				if (req.method === "POST" && route === "consolidate") {
 					if (!guardWrite(req, res)) return;
 					const body = await readJsonBody(req);
+					adoptBodySelector(body);
 					const rawScope = typeof body?.scope === "string" ? body.scope : "user";
 					const scope = rawScope === "project" ? "project" : rawScope === "shared" ? "shared" : "user";
 					const candidates = Array.isArray(body?.candidates) ? body.candidates.filter((value) => typeof value === "string") : void 0;
-					json(res, 200, await runConsolidation(await deps.openStore(scope), deps.embedder, candidates === void 0 ? { scope } : {
+					json(res, 200, await runConsolidation(await storeFor(scope), deps.embedder, candidates === void 0 ? { scope } : {
 						scope,
 						mergeCandidateIds: candidates
 					}));
@@ -2399,8 +2465,9 @@ function registerEngramRoutes(ctx, deps) {
 						json(res, 400, { error: "id required" });
 						return;
 					}
+					adoptBodySelector(body);
 					const scope = scopeOf$1(typeof body.scope === "string" ? body.scope : null, "user");
-					const store = await deps.openStore(scope);
+					const store = await storeFor(scope);
 					if (route === "update") {
 						if (typeof body.content !== "string" || body.content.trim() === "") {
 							json(res, 400, { error: "content required" });
@@ -2431,6 +2498,10 @@ function registerEngramRoutes(ctx, deps) {
 				}
 				json(res, 404, { error: "unknown route" });
 			} catch (error) {
+				if (error instanceof UnknownProjectError) {
+					json(res, 404, { error: "unknown project" });
+					return;
+				}
 				json(res, 500, { error: error instanceof Error ? error.message : String(error) });
 			}
 		}
@@ -2444,11 +2515,19 @@ function registerEngramRoutes(ctx, deps) {
 * 指针），不起子进程。启动时负责旧库文件向新标识的 rename 迁移。
 * @module @kenz1117/dsh-engram/project/identity
 */
-/** v0.4 旧命名：cwd 的 hex 编码前 24 位（无 git 时仍是兜底命名）。 */
+/** v0.4 旧命名：cwd 的 hex 编码前 24 位（只覆盖 cwd 前 12 字符，同前缀目录会撞库）。保留仅供迁移识别。 */
 function legacyProjectDbName(cwd) {
 	return `project-${Buffer.from(cwd).toString("hex").slice(0, 24)}.db`;
 }
 /**
+* 无 git 时的 cwd 命名：cwd 全量 sha256 前 24 位。
+* 旧算法只取 cwd 前 12 字符，`C:\Users\Adm…` 这类同前缀目录会共用同一个库；
+* 新算法对每个目录唯一，启动时把旧库 rename 迁移到新名（见 migrateProjectDb）。
+*/
+function cwdProjectDbName(cwd) {
+	return `project-${createHash("sha256").update(cwd).digest("hex").slice(0, 24)}.db`;
+}
+/**
 * 归一化 git origin URL：去协议与凭证、host 小写、去尾部 `.git` 与 `/`，
 * 使 `git@github.com:a/b.git` 与 `https://github.com/a/b` 等价。无法解析返回 undefined。
 */
@@ -2524,7 +2603,7 @@ function readOriginUrl(configPath) {
 }
 /**
 * 解析项目标识：origin URL 归一化后取 sha256 hex 前 24 位；无 git、无 origin
-* 或 URL 无法解析时回退 cwd 旧算法。
+* 或 URL 无法解析时回退 cwd 全量哈希命名。
 */
 function resolveProjectIdentity(cwd) {
 	const legacyDbName = legacyProjectDbName(cwd);
@@ -2532,7 +2611,7 @@ function resolveProjectIdentity(cwd) {
 	const origin = configPath === void 0 ? void 0 : readOriginUrl(configPath);
 	const normalized = origin === void 0 ? void 0 : normalizeOriginUrl(origin);
 	if (normalized === void 0) return {
-		dbName: legacyDbName,
+		dbName: cwdProjectDbName(cwd),
 		source: "cwd",
 		legacyDbName
 	};
@@ -2543,11 +2622,15 @@ function resolveProjectIdentity(cwd) {
 	};
 }
 /**
-* 旧库迁移：origin 库不存在而 cwd 旧库存在时同目录 rename（零数据搬运）；
-* 两者都存在时不合并、不动文件，返回 kept-both 由调用方告警。仅 origin 标识下有意义。
+* 旧库迁移：新名库不存在而旧名库存在时同目录 rename（零数据搬运）；两者都存在时
+* 不合并、不动文件，返回 kept-both 由调用方告警。origin 标识（v0.4 cwd 编码 → 仓库
+* 哈希）与 cwd 兜底（截断命名 → 全量哈希）两种升级都走这里。
+*
+* 注意旧 cwd 命名只覆盖前 12 字符：同一前缀下的多个目录可能共用过一个旧库，
+* 迁移只能把库判给先打开它的那个目录，调用方应对 kept-both 与本次迁移都告警。
 */
 function migrateProjectDb(dbDir, identity) {
-	if (identity.source !== "origin" || identity.dbName === identity.legacyDbName) return "none";
+	if (identity.dbName === identity.legacyDbName) return "none";
 	const next = join(dbDir, identity.dbName);
 	const legacy = join(dbDir, identity.legacyDbName);
 	const hasNext = existsSync(next);
@@ -2559,6 +2642,81 @@ function migrateProjectDb(dbDir, identity) {
 	}
 	return "none";
 }
+//#endregion
+//#region src/project/registry.ts
+/**
+* 项目宫殿清单：把 dsh 的工作区（`ctx.workspaceRegistry` 的注册表）与会话 cwd
+* 映射成记忆分库，供管理面板「切换/显示当前工作区」使用。
+*
+* 设计要点：
+* 1. **纯函数 + 注入式数据源**——不直接依赖宿主服务，index.ts 负责接
+*    `workspaceRegistry` 与 `sessionPersistence`，本模块只做映射与去重，便于单测；
+* 2. **零状态**——每次现算 `目录 → 分库名`（git origin 哈希 / cwd 全量哈希），
+*    不维护额外注册表文件：工作区改名/删除后清单自动跟上；
+* 3. **三级来源**——宿主注册表工作区 > 只从会话 header 见到的 cwd > 插件进程目录兜底；
+*    同一个分库只出现一次（同仓库的多个 worktree 共用一个项目宫殿）。
+* @module @kenz1117/dsh-engram/project/registry
+*/
+/** 路径末段作为标题（Windows 与 POSIX 分隔符都接受；根目录回退整串）。 */
+function pathTitle(path) {
+	const trimmed = path.replace(/[\\/]+$/, "");
+	const cut = Math.max(trimmed.lastIndexOf("\\"), trimmed.lastIndexOf("/"));
+	const tail = cut === -1 ? trimmed : trimmed.slice(cut + 1);
+	return tail === "" ? trimmed : tail;
+}
+/** 目录 → 项目宫殿（kind 由调用方给出）。 */
+function palaceFor(path, kind, title, workspaceId) {
+	const identity = resolveProjectIdentity(path);
+	return {
+		dbName: identity.dbName,
+		path,
+		title,
+		source: identity.source,
+		kind,
+		...workspaceId === void 0 ? {} : { workspaceId }
+	};
+}
+/**
+* 组装项目宫殿清单。
+*
+* **不变量**：清单必须恒定包含宿主注册表里的**每一个**工作区（即使它的分库文件还不存在）。
+* 面板的「跟随当前工作区」按 dbName / 路径在清单里匹配，缺行会静默降级为进程默认库。
+* @param input - 注册表工作区、会话 cwd 集合与插件进程目录。
+* @returns 按「注册表 → 会话 cwd → 进程目录」优先、按分库名去重的清单。
+*/
+function listProjectPalaces(input) {
+	const palaces = [];
+	const seen = /* @__PURE__ */ new Set();
+	const push = (palace) => {
+		if (seen.has(palace.dbName)) return;
+		seen.add(palace.dbName);
+		palaces.push(palace);
+	};
+	for (const workspace of input.workspaces) {
+		if (workspace.path === "") continue;
+		push(palaceFor(workspace.path, "workspace", workspace.title === "" ? pathTitle(workspace.path) : workspace.title, workspace.id));
+	}
+	for (const cwd of input.sessionCwds) {
+		if (cwd === "") continue;
+		push(palaceFor(cwd, "session", pathTitle(cwd)));
+	}
+	push(palaceFor(input.processCwd, "process", `${pathTitle(input.processCwd)}（进程目录）`));
+	return palaces;
+}
+/**
+* 按选择器找项目宫殿：`dbName` 优先，其次 `cwd`；都不给时返回进程目录兜底项。
+* @param palaces - 清单。
+* @param selector - 面板/API 传来的选择器。
+* @returns 命中的宫殿；未知选择器返回 undefined（调用方回 404）。
+*/
+function findProjectPalace(palaces, selector) {
+	if (selector.dbName !== void 0 && selector.dbName !== "") return palaces.find((palace) => palace.dbName === selector.dbName);
+	if (selector.cwd !== void 0 && selector.cwd !== "") {
+		const dbName = resolveProjectIdentity(selector.cwd).dbName;
+		return palaces.find((palace) => palace.dbName === dbName) ?? palaceFor(selector.cwd, "session", pathTitle(selector.cwd));
+	}
+	return palaces.find((palace) => palace.kind === "process") ?? palaces[0];
+}
 /** kind → 默认房间名。固定映射，保证同主题记忆总是聚在同一间（同类巩固）。 */
 const KIND_ROOMS = {
 	fact: "事实厅",
@@ -3708,31 +3866,156 @@ function truncateItem(text, maxChars = RECALL_PER_ITEM_CHARS) {
 	return text.length <= maxChars ? text : `${text.slice(0, maxChars)}…`;
 }
 /**
-* 总量预算内贪心装填行（保序；某行装不下时继续尝试更短的后续行），
-* 被跳过的行计数并在末尾追加提示行。
-* @param lines - 候选行（已按相关性排序）。
-* @param totalBudget - 总字符预算，默认 RECALL_TOTAL_CHARS。
-* @returns 装填后的行；有丢弃时末尾含「另有 N 条…」提示。
+* 预算内的贪心装填（保序）：按 cost 逐个判断，装不下的计入 dropped 并继续试后续更短的项。
+* @param items - 候选（已按相关性排序）。
+* @param cost - 单项占用预算（字符数等）。
+* @param totalBudget - 总预算。
+* @returns 保留项与丢弃数。
 */
-function enforceBudget(lines, totalBudget = RECALL_TOTAL_CHARS) {
+function fitWithinBudget(items, cost, totalBudget) {
 	const kept = [];
 	let used = 0;
 	let dropped = 0;
-	for (const line of lines) {
-		if (used + line.length > totalBudget) {
+	for (const item of items) {
+		const size = cost(item);
+		if (used + size > totalBudget) {
 			dropped += 1;
 			continue;
 		}
-		kept.push(line);
-		used += line.length;
+		kept.push(item);
+		used += size;
 	}
+	return {
+		kept,
+		dropped
+	};
+}
+/**
+* 总量预算内贪心装填行（保序；某行装不下时继续尝试更短的后续行），
+* 被跳过的行计数并在末尾追加提示行。
+* @param lines - 候选行（已按相关性排序）。
+* @param totalBudget - 总字符预算，默认 RECALL_TOTAL_CHARS。
+* @returns 装填后的行；有丢弃时末尾含「另有 N 条…」提示。
+*/
+function enforceBudget(lines, totalBudget = RECALL_TOTAL_CHARS) {
+	const { kept, dropped } = fitWithinBudget(lines, (line) => line.length, totalBudget);
 	if (dropped > 0) kept.push(`（另有 ${dropped} 条未展示：缩小查询范围或降低 limit 后重试）`);
 	return kept;
 }
+/** 判定后可选的下一步策略。 */
+const NEXT_STRATEGIES = [
+	"answer",
+	"search_keyword",
+	"search_room",
+	"search_timeline",
+	"ask_user",
+	"stop"
+];
+/**
+* 判断字符串是否为合法策略。
+* @param value - 待判定字符串。
+*/
+function isNextStrategy(value) {
+	return NEXT_STRATEGIES.includes(value);
+}
+/**
+* 构造批次内唯一的证据 ref：已排桩时用「scope/房间#桩位」（与检索行里的宫殿坐标一致），
+* 未排桩时用「scope/#id 前 8 位」。带 scope 前缀，跨作用域的同名房间不会撞号。
+* @param scope - 条目所在作用域。
+* @param id - 条目 id。
+* @param slot - 宫殿坐标；未排桩传 undefined。
+*/
+function evidenceRefOf(scope, id, slot) {
+	return slot === void 0 ? `${scope}/#${id.slice(0, 8)}` : `${scope}/${slot.room}#${slot.index}`;
+}
+/** 批次注册表：按会话隔离，超出上限丢最旧的批次。 */
+var EvidenceBatches = class {
+	bySession = /* @__PURE__ */ new Map();
+	counter = 0;
+	/**
+	* 注册一个批次。
+	* @param sessionId - 会话标识。
+	* @param refs - 本次输出中可引用的证据 ref（重复项只留一次）。
+	* @param now - 当前时间（测试注入）。
+	* @returns 新批次。
+	*/
+	register(sessionId, refs, now = Date.now()) {
+		this.counter += 1;
+		const batch = {
+			batchId: `batch-${String(this.counter)}`,
+			refs: new Set(refs),
+			createdAt: now
+		};
+		const batches = this.bySession.get(sessionId) ?? /* @__PURE__ */ new Map();
+		batches.set(batch.batchId, batch);
+		while (batches.size > 20) {
+			const oldest = batches.keys().next().value;
+			if (oldest === void 0) break;
+			batches.delete(oldest);
+		}
+		this.bySession.set(sessionId, batches);
+		return batch;
+	}
+	/**
+	* 取会话内指定批次。
+	* @param sessionId - 会话标识。
+	* @param batchId - 批次 id。
+	* @returns 批次；不存在或已被上限淘汰时返回 undefined。
+	*/
+	get(sessionId, batchId) {
+		return this.bySession.get(sessionId)?.get(batchId);
+	}
+	/**
+	* 清理会话的全部批次（会话销毁时调用，避免长驻进程累积）。
+	* @param sessionId - 会话标识。
+	*/
+	clear(sessionId) {
+		this.bySession.delete(sessionId);
+	}
+};
+/** 进程内批次注册表：插件为单实例，会话销毁时调用 clear 释放该会话的批次。 */
+const evidenceBatches = new EvidenceBatches();
+/**
+* 校验判定：ref 必须属于批次，sufficient 由代码强制。
+* 强制规则：sufficient 需同时满足「模型声称充足」「至少一条本批次有效证据」「策略为 answer」；
+* 三者缺一即判为不充足，并把策略改写为继续检索（模型声称充足时）或尊重其非作答策略。
+* @param batch - 被引用的批次。
+* @param request - 模型提交的判定。
+* @returns 校验后的判定结果（含被拒绝与超限的 ref 明细）。
+*/
+function assessEvidence(batch, request) {
+	const submitted = request.evidenceRefs.filter((ref) => typeof ref === "string").map((ref) => ref.trim()).filter((ref) => ref !== "");
+	const unique = [...new Set(submitted)];
+	const limited = unique.slice(0, 8);
+	const droppedRefs = unique.slice(8);
+	const accepted = [];
+	const rejectedRefs = [];
+	for (const ref of limited) if (batch.refs.has(ref)) accepted.push(ref);
+	else rejectedRefs.push(ref);
+	const rawMissing = typeof request.missing === "string" ? request.missing.trim() : "";
+	const missingTruncated = rawMissing.length > 160;
+	const missing = missingTruncated ? `${rawMissing.slice(0, 160)}…` : rawMissing;
+	const requestedStrategy = typeof request.nextStrategy === "string" ? request.nextStrategy.trim() : "";
+	const strategy = isNextStrategy(requestedStrategy) ? requestedStrategy : "search_keyword";
+	const claimed = request.sufficient === true;
+	const sufficient = claimed && accepted.length > 0 && strategy === "answer";
+	const nextStrategy = sufficient || strategy !== "answer" ? strategy : "search_keyword";
+	return {
+		sufficient,
+		evidenceRefs: accepted,
+		rejectedRefs,
+		droppedRefs,
+		missing,
+		missingTruncated,
+		nextStrategy,
+		requestedStrategy,
+		forced: claimed !== sufficient || strategy !== requestedStrategy || nextStrategy !== strategy
+	};
+}
 //#endregion
 //#region src/tools/create.ts
 /**
-* 15 个 engram_ 工具的定义与执行器。工具 schema 保持窄参数；
+* 17 个 engram_ 工具的定义与执行器。工具 schema 保持窄参数；
 * scope 决定读写哪个分库；嵌入缺失时检索结果显式标记降级。
 * @module @kenz1117/dsh-engram/tools/create
 */
@@ -3743,6 +4026,17 @@ const KINDS = [
 	"episode",
 	"skill"
 ];
+/**
+* 工具执行期的会话 cwd：project scope 的读写据此解析项目宫殿。
+* 用 AsyncLocalStorage 而不是模块级变量：同一进程里多个会话的工具调用可能交错，
+* 模块级可变状态会把 A 会话的 cwd 泄漏给 B 会话。
+*/
+const execSessionCwd = new AsyncLocalStorage();
+/** 从工具运行上下文取会话 cwd（缺省 = 无会话信息，调用方回退插件进程目录）。 */
+function sessionCwdOf(exec) {
+	const cwd = exec.agent?.session?.header?.cwd;
+	return cwd === void 0 || cwd === "" ? void 0 : cwd;
+}
 /** 历史回填估算的模型可读文本（零成本，先看数再决定跑不跑）。 */
 function renderHistoryEstimate(estimate) {
 	if (estimate.unavailable !== void 0) return `历史回填不可用：${estimate.unavailable}`;
@@ -3770,6 +4064,26 @@ function renderHistoryRun(result) {
 	lines.push("同一批可重复执行：已完成的轮次按幂等键跳过，只补未完成的部分。");
 	return lines.join("\n");
 }
+/** 证据门策略的可读提示。 */
+const STRATEGY_HINT = {
+	answer: "可以据此作答",
+	search_keyword: "换关键词再检索（engram_search）",
+	search_room: "收窄到具体房间再检索（engram_search 带 room）",
+	search_timeline: "按时间线找（engram_timeline）",
+	ask_user: "向用户澄清缺失的信息",
+	stop: "不回答，并向用户说明缺少什么"
+};
+/** 证据门判定的模型可读文本（含被拒绝的 ref 与强制改写说明）。 */
+function renderAssessText(verdict, batchId) {
+	const lines = [verdict.sufficient ? `证据判定：充足（批次 ${batchId}，${String(verdict.evidenceRefs.length)} 条有效证据）——可以据此作答。` : `证据判定：不足（批次 ${batchId}）。`];
+	if (verdict.evidenceRefs.length > 0) lines.push(`有效证据：${verdict.evidenceRefs.join("、")}`);
+	if (verdict.rejectedRefs.length > 0) lines.push(`无效 ref（不属于该批次，已忽略）：${verdict.rejectedRefs.join("、")}`);
+	if (verdict.droppedRefs.length > 0) lines.push(`超出上限被丢弃（单次最多 ${String(8)} 条）：${verdict.droppedRefs.join("、")}`);
+	lines.push(`缺口：${verdict.missing === "" ? "（未填写）" : verdict.missing}${verdict.missingTruncated ? "（已截断）" : ""}`);
+	lines.push(`下一步：${verdict.nextStrategy} —— ${STRATEGY_HINT[verdict.nextStrategy]}`);
+	if (verdict.forced) lines.push("注意：判定由代码修正——sufficient 需同时满足「你声称充足」「至少一条属于本批次的有效证据」「nextStrategy=answer」。");
+	return lines.join("\n");
+}
 /** 从模型参数收敛 scope（非法值或缺失回退 fallback）。 */
 function scopeOf(raw, fallback) {
 	if (raw === "user" || raw === "project" || raw === "shared") return raw;
@@ -3839,12 +4153,20 @@ async function rewriteQueries(deps, exec, query) {
 	}
 }
 /**
-* 构造 16 个工具定义（engram_save/search/timeline/update/forget/report/review/review_queue/
+* 构造 17 个工具定义（engram_save/search/assess/timeline/update/forget/report/review/review_queue/
 * stats/export/distill/examine/neighbors/audit_forgotten/tour/ingest_history）。
-* @param deps - 分库打开器、嵌入器、辅助 LLM、导出目录。
-* @returns 可直接 register 的工具定义数组。
+* @param baseDeps - 分库打开器、嵌入器、辅助 LLM、导出目录。
+* @returns 可直接 register 的工具定义数组（execute 已绑定会话 cwd 的项目宫殿路由）。
 */
-function createEngramTools(deps) {
+function createEngramTools(baseDeps) {
+	/**
+	* 分库门面：project scope 一律走 `resolveProjectStore(执行期会话 cwd)`，
+	* 其余 scope 原样透传。所有 handler 都用这个 `deps`，无需逐处改调用点。
+	*/
+	const deps = {
+		...baseDeps,
+		openStore: (scope) => scope === "project" ? baseDeps.resolveProjectStore(execSessionCwd.getStore()) : baseDeps.openStore(scope)
+	};
 	/** 批量保存上限（协议内常量：与单轮摄取候选量级对齐，防一次灌入过多）。 */
 	const MAX_SAVE_BATCH = 10;
 	/** engram_save 呈现文本：矛盾警告 text 优先；批量输出汇总成功与失败。 */
@@ -4219,16 +4541,106 @@ 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 { kept, dropped } = fitWithinBudget(mergeQueryResults(retrievals, limit, 60, Math.floor(Math.max(0, limit) / Math.max(1, rewrite.queries.length))).map((hit, index) => {
+				const ref = evidenceRefOf(hit.record.scope, hit.record.id, hit.record.slot);
 				const edge = hit.viaEdge === void 0 ? "" : `（经 ${hit.viaEdge.type} 关联自 ${hit.viaEdge.from}）`;
 				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 {
+					ref,
+					line: `${index + 1}. [${hit.record.scope}/${hit.record.kind}]${slot}${date} ${truncateItem(hit.record.content)}（id=${hit.record.id}, ref=${ref}）${edge}${cues}`
+				};
+			}), (entry) => entry.line.length, RECALL_TOTAL_CHARS);
+			const lines = kept.map((entry) => entry.line);
+			if (dropped > 0) lines.push(`（另有 ${dropped} 条未展示：缩小查询范围或降低 limit 后重试）`);
+			const sessionId = exec.agent === void 0 ? void 0 : String(exec.agent.session.id);
+			const batch = sessionId === void 0 || kept.length === 0 ? void 0 : evidenceBatches.register(sessionId, kept.map((entry) => entry.ref));
+			const prefix = degraded && lines.length > 0 ? "（语义嵌入不可用，仅关键词检索）\n" : "";
+			const roomNote = rooms === void 0 ? "" : `（房间路由：${rooms.join("、")}）\n`;
+			const batchNote = batch === void 0 ? "" : `\n批次 ${batch.batchId}（${String(batch.refs.size)} 条可引用证据）：作答前用 engram_assess 判定证据是否充分，evidenceRefs 只能引用上面的 ref。`;
 			return {
 				degraded,
-				text: renderMemoryPacket(`${degraded && lines.length > 0 ? "（语义嵌入不可用，仅关键词检索）\n" : ""}${rooms === void 0 ? "" : `（房间路由：${rooms.join("、")}）\n`}${lines.join("\n") || "无命中"}`, "tool_search", input.query)
+				text: renderMemoryPacket(`${prefix}${roomNote}${lines.join("\n") || "无命中"}${batchNote}`, "tool_search", input.query)
+			};
+		}
+	});
+	const assess = defineTool({
+		name: "engram_assess",
+		description: "证据门：检索（engram_search）之后、作答之前，判定「检索到的内容是否足以回答当前问题」。提交 batchId、sufficient、最多 8 条 evidenceRefs（只能引用该批次输出里的 ref=…）、缺口说明 missing（≤160 字符）与下一步 nextStrategy。代码强制校验：sufficient 需同时满足「你声称充足」「至少一条属于本批次的有效证据」「nextStrategy=answer」，否则判为不足并把策略改回继续检索；不属于该批次的 ref 会被拒绝并列出。判词与拒绝明细写入审计日志。",
+		parameters: {
+			batchId: {
+				type: "string",
+				required: true,
+				description: "engram_search 输出末尾给出的批次 id（如 batch-3）"
+			},
+			sufficient: {
+				type: "boolean",
+				required: true,
+				description: "证据是否足以回答当前问题（true 时 nextStrategy 必须为 answer）"
+			},
+			evidenceRefs: {
+				type: "array",
+				items: { type: "string" },
+				description: "引用的证据 ref（最多 8 条，只能取该批次输出里的 ref=…）"
+			},
+			missing: {
+				type: "string",
+				description: "缺少什么维度的信息（≤160 字符）"
+			},
+			nextStrategy: {
+				type: "string",
+				enum: [...NEXT_STRATEGIES],
+				description: "下一步：answer 作答 / search_keyword 换关键词 / search_room 换房间 / search_timeline 查时间线 / ask_user 问用户 / stop 不回答"
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					sufficient: {
+						type: "boolean",
+						required: true
+					},
+					nextStrategy: {
+						type: "string",
+						required: true
+					},
+					text: {
+						type: "string",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: value.text
+			}]
+		},
+		async execute(args, exec) {
+			const input = args;
+			if (typeof input.batchId !== "string" || input.batchId.trim() === "") throw new Error("engram_assess: batchId 必填（取自 engram_search 输出末尾）");
+			const sessionId = exec.agent === void 0 ? void 0 : String(exec.agent.session.id);
+			const batch = sessionId === void 0 ? void 0 : evidenceBatches.get(sessionId, input.batchId.trim());
+			if (batch === void 0) throw new Error(`engram_assess: 批次 ${input.batchId} 不存在或已过期（每个会话保留最近 ${String(20)} 个批次）——请重新 engram_search 取新批次`);
+			const verdict = assessEvidence(batch, {
+				sufficient: input.sufficient === true,
+				evidenceRefs: Array.isArray(input.evidenceRefs) ? input.evidenceRefs.filter((ref) => typeof ref === "string") : [],
+				missing: typeof input.missing === "string" ? input.missing : "",
+				nextStrategy: typeof input.nextStrategy === "string" ? input.nextStrategy : ""
+			});
+			await (await deps.openStore("user")).audit("assess", batch.batchId, JSON.stringify({
+				batchId: batch.batchId,
+				sufficient: verdict.sufficient,
+				refs: verdict.evidenceRefs,
+				rejected: verdict.rejectedRefs,
+				strategy: verdict.nextStrategy
+			}));
+			return {
+				sufficient: verdict.sufficient,
+				nextStrategy: verdict.nextStrategy,
+				text: renderAssessText(verdict, batch.batchId)
 			};
 		}
 	});
@@ -4622,6 +5034,7 @@ function createEngramTools(deps) {
 	return [
 		save,
 		search,
+		assess,
 		timeline,
 		update,
 		forget,
@@ -5140,7 +5553,10 @@ function createEngramTools(deps) {
 		}),
 		auditForgotten,
 		ingestHistory
-	];
+	].map((tool) => ({
+		...tool,
+		execute: (args, exec) => execSessionCwd.run(sessionCwdOf(exec), () => tool.execute(args, exec))
+	}));
 }
 /**
 * 构造巡游路径：在 search 命中的基础上按路径策略重排。
@@ -5270,6 +5686,38 @@ function reasonsLabel(reasons) {
 	return reasons.map((r) => LABELS[r]).join(" / ");
 }
 //#endregion
+//#region src/token.ts
+/**
+* token 估算：CJK 感知的上下文预算口径。
+*
+* 汉字、假名、韩文与全角标点按 1.5 token/字计，其余字符按 4 字符/token 计。
+* 统一的 `长度 / 4` 会把中文低估四倍以上，使按 token 计的注入预算与实际占用脱钩
+* （中文 1024 token 预算实际会注入四千余 token）。
+* @module @kenz1117/dsh-engram/token
+*/
+/** 单个 CJK 字符的 token 成本。 */
+const WIDE_TOKENS_PER_CHAR = 1.5;
+/**
+* 判断码点是否属于 CJK 文字与全角符号区间（含扩展平面）。
+* @param codePoint - Unicode 码点。
+*/
+function isWideCodePoint(codePoint) {
+	return codePoint >= 12288 && codePoint <= 12351 || codePoint >= 12352 && codePoint <= 12543 || codePoint >= 13312 && codePoint <= 19903 || codePoint >= 19968 && codePoint <= 40959 || codePoint >= 43360 && codePoint <= 43391 || codePoint >= 44032 && codePoint <= 55295 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 131072 && codePoint <= 262143;
+}
+/**
+* 估算文本占用的 token 数（向上取整）。
+* @param text - 待估算文本。
+* @returns token 估算值；空串为 0。
+*/
+function estimateTokens(text) {
+	if (text === "") return 0;
+	let wide = 0;
+	let narrow = 0;
+	for (const char of text) if (isWideCodePoint(char.codePointAt(0))) wide += 1;
+	else narrow += 1;
+	return Math.ceil(wide * WIDE_TOKENS_PER_CHAR + narrow / 4);
+}
+//#endregion
 //#region src/index.ts
 /**
 * dsh-engram：DeepSeek Harness 跨会话长期记忆插件（host 半）。
@@ -5280,19 +5728,20 @@ function reasonsLabel(reasons) {
 /** Cordis 插件名（loader 诊断与注入 source 使用）。 */
 const name = "dsh-engram";
 /** 插件版本（与 package.json 同步，写进备份 _meta.json）。 */
-const VERSION = "0.7.2";
+const VERSION = "0.7.6";
 /** 必需服务：工具注册表与 LLM 流式端点（摄取/蒸馏的辅助调用）。 */
 const inject = ["tools", "llm"];
 /**
-* 会话开始注入的画像渲染：按重要性降序在 token 预算内整行装填（估算 ceil(len/4)，
-* 超预算的行跳过不截断、继续试更短行）；装不下的条目降级为索引行（#id + 前 40 字），
-* 索引行也装不下的折成末尾 `+N more; use engram_search` 计数行。
+* 会话开始注入的画像渲染：按重要性降序在 token 预算内整行装填（估算见
+* estimateTokens：中文按 1.5 token/字、其余按 4 字符/token，超预算的行跳过不截断、
+* 继续试更短行）；装不下的条目降级为索引行（#id + 前 40 字），
+* 索引行也装不下的折成末尾 `+N more; use engram_search` 计数行；计数行同样占用预算。
 * @param records - 候选条目（调用方已按重要性排序、按条数截断）。
 * @param tokenBudget - 整段画像的 token 预算（含首尾固定行）。
 * @returns 渲染文本与溢出条目（调用方可用辅助 LLM 压缩后重渲染）。
 */
 function renderProfileDetailed(records, tokenBudget) {
-	const estimate = (text) => Math.ceil(text.length / 4);
+	const estimate = estimateTokens;
 	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));
@@ -5308,6 +5757,7 @@ function renderProfileDetailed(records, tokenBudget) {
 		} else overflow.push(record);
 	}
 	let more = 0;
+	remaining -= overflow.length === 0 ? 0 : estimate(`+${overflow.length} more; use engram_search`);
 	for (const record of overflow) {
 		const line = `- [${record.kind}] #${record.id} ${record.content.slice(0, 40)}…`;
 		const cost = estimate(line);
@@ -5316,7 +5766,7 @@ function renderProfileDetailed(records, tokenBudget) {
 			remaining -= cost;
 		} else more += 1;
 	}
-	if (more > 0) lines.push(`+${more} more; use engram_search`);
+	if (more > 0 && remaining >= 0) lines.push(`+${more} more; use engram_search`);
 	return {
 		text: [
 			header,
@@ -5388,7 +5838,7 @@ async function compressProfileOverflow(ctx, agent, routeOverride, overflow, sign
 * 重放待补做的末轮摄取。必须调用 next() 委托链路；reject 决策原样透传，
 * 记忆库为空或非首轮时不追加消息。
 */
-async function preStep(ctx, openStore, resolved, embedder, state, logRequest, { agent, step, turn, signal }, next) {
+async function preStep(ctx, openStore, openStoreForProjectCwd, resolved, embedder, state, logRequest, { agent, step, turn, signal }, next) {
 	const decision = await next();
 	if (decision.kind === "reject") return decision;
 	if (step === 1) {
@@ -5396,12 +5846,14 @@ async function preStep(ctx, openStore, resolved, embedder, state, logRequest, {
 		if (currentRoute !== void 0) state.route = currentRoute;
 	}
 	const mode = resolved.ingest;
+	const routing = ingestWriteRouting(sessionCwd(agent.session), openStoreForProjectCwd, openStore);
 	if (step === 1 && mode !== "off") {
 		if (!state.pendingReplayed) {
 			state.pendingReplayed = true;
 			replayPendingIngests({
 				openStore: () => openStore("user"),
-				resolveEvents: makeEventResolver(ctx, agent),
+				resolveSession: makeSessionResolver(ctx, agent),
+				resolveStore: openStoreForProjectCwd,
 				embedder,
 				mode,
 				routeOverride: resolved.routeOverride,
@@ -5420,6 +5872,8 @@ async function preStep(ctx, openStore, resolved, embedder, state, logRequest, {
 			sessionId: String(agent.id),
 			turn,
 			openStore: () => openStore("user"),
+			openAuditStore: () => openStore("user"),
+			...routing,
 			embedder,
 			mode,
 			routeOverride: resolved.routeOverride,
@@ -5479,17 +5933,49 @@ async function preStep(ctx, openStore, resolved, embedder, state, logRequest, {
 	};
 }
 /**
-* pending 重放的事件源解析器：pending 属于当前会话时直接用其事件快照；
-* 其余会话经可选的 sessionPersistence 服务读持久化日志（服务缺席或读取失败
-* 返回 undefined，pending 保留到下次，不报错）。
+* 会话工作目录（决定它的记忆进哪座项目宫殿）。
+* 真实 `Session.header` 恒在；测试替身可能省略 header，故按可选形状读取。
+* @param session - 会话（或替身）对象。
+* @returns cwd；取不到时 undefined（该会话的回退口径是私人宫殿）。
+*/
+function sessionCwd(session) {
+	const cwd = session?.header?.cwd;
+	return cwd === void 0 || cwd === "" ? void 0 : cwd;
+}
+/**
+* 只读打开会话日志 → 交给调用方读取 → 必关闭句柄。
+* close 失败不掩盖读取结果（读取成功而 close 失败时仍返回成功值）。
+* @param persistence - 持久化服务视图。
+* @param sessionId - 目标会话 id。
+* @param use - 句柄使用回调。
+* @returns 回调结果。
 */
-function makeEventResolver(ctx, agent) {
+async function withReadHandle(persistence, sessionId, use) {
+	const handle = await persistence.open(sessionId, "read");
+	try {
+		return await use(handle);
+	} finally {
+		await handle.close().catch(() => {});
+	}
+}
+/**
+* pending 重放的会话解析器：pending 属于当前会话时直接用其事件快照与 cwd；
+* 其余会话经可选的 sessionPersistence 服务（只读句柄）读持久化日志与 header.cwd
+* （服务缺席或读取失败返回 undefined，pending 保留到下次，不报错）。
+*/
+function makeSessionResolver(ctx, agent) {
 	return async (sessionId) => {
-		if (sessionId === String(agent.id)) return agent.session.snapshotEvents();
+		if (sessionId === String(agent.id)) return {
+			events: agent.session.snapshotEvents(),
+			cwd: sessionCwd(agent.session)
+		};
 		const persistence = ctx.get("sessionPersistence");
 		if (persistence === void 0) return void 0;
 		try {
-			return (await persistence.load(sessionId)).events;
+			return await withReadHandle(persistence, sessionId, async (handle) => ({
+				events: (await handle.read()).events,
+				cwd: sessionCwd(handle)
+			}));
 		} catch {
 			return;
 		}
@@ -5535,6 +6021,11 @@ function apply(ctx, config = {}) {
 		return created;
 	};
 	const openStore = (scope) => openDb(scope === "user" ? "user.db" : scope === "shared" ? "shared.db" : identity.dbName);
+	ctx.effect(() => () => Promise.allSettled([...stores.values()].map(async (pending) => {
+		try {
+			await (await pending).close();
+		} catch {}
+	})), "dsh-engram: close stores");
 	/** cwd → 分库文件名（历史回填会对每个历史 cwd 解析一次，避免重复读 git 元数据）。 */
 	const cwdDbNames = /* @__PURE__ */ new Map();
 	/**
@@ -5548,11 +6039,18 @@ function apply(ctx, config = {}) {
 		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}）`);
+		const migration = migrateProjectDb(resolved.dbDir, projectIdentity);
+		if (migration === "renamed") console.warn(`[dsh-engram] 项目记忆库已迁移到新标识命名（${cwd} → ${projectIdentity.dbName}）`);
+		else if (migration === "kept-both") console.warn(`[dsh-engram] 检测到新旧项目库并存，未合并（保留新库 ${projectIdentity.dbName}；旧库 ${projectIdentity.legacyDbName} 请人工处理后删除）`);
 		cwdDbNames.set(cwd, projectIdentity.dbName);
 		return projectIdentity.dbName;
 	};
 	const openStoreForProjectCwd = (cwd) => openDb(dbNameForCwd(cwd));
+	/**
+	* 工具调用期的项目分库解析：按会话 cwd 归属（缺省回退插件进程目录）。
+	* 面板「项目」scope、工具读写与自动摄取的 project 落点因此同一口径。
+	*/
+	const resolveProjectStore = (cwd) => cwd === void 0 ? openStore("project") : openStoreForProjectCwd(cwd);
 	const embedder = createLocalEmbedder(resolved.modelCacheDir, resolved.hfEndpoint).catch((error) => {
 		console.warn("[dsh-engram] 嵌入器不可用，检索降级为纯关键词模式：", error);
 	});
@@ -5570,22 +6068,93 @@ function apply(ctx, config = {}) {
 		const persistence = ctx.get("sessionPersistence");
 		if (persistence === void 0) return void 0;
 		return {
-			list: (signal) => persistence.list(signal),
-			load: (id) => persistence.load(id)
+			list: async (signal) => (await persistence.list(signal === void 0 ? void 0 : { signal })).map((snapshot) => snapshot.header),
+			load: (id) => withReadHandle(persistence, id, async (handle) => ({ events: (await handle.read()).events }))
 		};
 	};
 	/** 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);
+	/** 宿主机工作区注册表（可选服务：缺席时降级为「会话 cwd + 进程目录」两级清单）。 */
+	const workspaceRefs = () => {
+		const registry = ctx.get("workspaceRegistry");
+		if (registry === void 0) return [];
+		try {
+			return registry.list().filter((workspace) => typeof workspace.path === "string" && workspace.path !== "").map((workspace) => ({
+				id: String(workspace.id),
+				path: workspace.path,
+				title: typeof workspace.title === "string" ? workspace.title : ""
+			}));
+		} catch {
+			return [];
+		}
+	};
+	/** 只按会话 cwd 认领的分库上限（按会话新旧取最近的若干，避免历史 cwd 把清单撑爆）。 */
+	const SESSION_CWD_PALACE_LIMIT = 30;
+	/**
+	* 会话 header 里出现过的 cwd：历史回填建的库也能在面板里被认领。
+	* 按会话创建时间倒序取最近的 N 个（新的在前，去重后截断）。
+	*/
+	const sessionCwds = async () => {
+		const source = persistenceService();
+		if (source === void 0) return [];
+		try {
+			const ordered = [...await source.list()].sort((a, b) => b.createdAt - a.createdAt);
+			const cwds = [];
+			const seen = /* @__PURE__ */ new Set();
+			for (const header of ordered) {
+				const cwd = header.cwd;
+				if (cwd === void 0 || cwd === "" || seen.has(cwd)) continue;
+				seen.add(cwd);
+				cwds.push(cwd);
+				if (cwds.length >= SESSION_CWD_PALACE_LIMIT) break;
+			}
+			return cwds;
+		} catch {
+			return [];
+		}
+	};
+	/** 项目宫殿清单（现算、零状态）：注册表工作区 → 会话 cwd → 进程目录兜底，按分库名去重。 */
+	const projectPalaces = async () => listProjectPalaces({
+		workspaces: workspaceRefs(),
+		sessionCwds: await sessionCwds(),
+		processCwd: process.cwd()
+	});
+	/** 面板视图：补 exists 与 active 计数（库文件不存在时不打开，避免为工作区建空库）。 */
+	const palaceView = async (palace) => {
+		const exists = existsSync(join(resolved.dbDir, palace.dbName));
+		let memories = null;
+		if (exists) try {
+			memories = (await (await openDb(palace.dbName)).stats()).active;
+		} catch {
+			memories = null;
+		}
+		return {
+			dbName: palace.dbName,
+			title: palace.title,
+			path: palace.path ?? null,
+			kind: palace.kind,
+			source: palace.source,
+			workspaceId: palace.workspaceId ?? null,
+			exists,
+			memories
+		};
+	};
+	const projectsDeps = {
+		list: async () => Promise.all((await projectPalaces()).map(async (palace) => palaceView(palace))),
+		open: async (selector) => {
+			const palaces = await projectPalaces();
+			const palace = selector === void 0 ? findProjectPalace(palaces, {}) : palaces.find((candidate) => candidate.dbName === selector);
+			if (palace === void 0) return void 0;
+			return {
+				store: await openDb(palace.dbName),
+				project: await palaceView(palace)
+			};
+		}
 	};
 	/** 组装历史回填依赖；source 每次现取，兼容持久化服务在插件之后挂载的组合。 */
 	const buildHistoryDeps = () => ({
 		source: persistenceService(),
 		resolveStore: openStoreForProjectCwd,
-		resolveExistingStore: openProjectStoreIfExists,
 		openUserStore: () => openStore("user"),
 		resolveExistingUserStore: openUserStoreIfExists,
 		embedder,
@@ -5695,6 +6264,7 @@ function apply(ctx, config = {}) {
 	};
 	for (const tool of createEngramTools({
 		openStore,
+		resolveProjectStore,
 		embedder,
 		call: (callParams) => streamText(ctx, {
 			...callParams,
@@ -5711,6 +6281,7 @@ function apply(ctx, config = {}) {
 	ctx.inject(["webServer"], (webCtx) => {
 		registerEngramRoutes(webCtx, {
 			openStore,
+			projects: projectsDeps,
 			exportDir: `${resolved.dbDir}/exports`,
 			mirrorDir: `${resolved.dbDir}/palaces`,
 			dbDir: resolved.dbDir,
@@ -5726,7 +6297,10 @@ function apply(ctx, config = {}) {
 			}
 		});
 	});
-	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.injectProfile || resolved.ingest !== "off") ctx.on("agent/pre-step", (payload, next) => preStep(ctx, openStore, openStoreForProjectCwd, resolved, embedder, preStepState, logIngestRequest, payload, next), { prepend: true });
+	ctx.on("session/disposed", (session) => {
+		evidenceBatches.clear(String(session.id));
+	});
 	if (resolved.ingest !== "off") ctx.on("session/disposed", (session) => {
 		const mode = resolved.ingest;
 		if (mode === "off") return;
@@ -5736,6 +6310,8 @@ function apply(ctx, config = {}) {
 			turn: 0,
 			slice: "last",
 			openStore: () => openStore("user"),
+			openAuditStore: () => openStore("user"),
+			...ingestWriteRouting(sessionCwd(session), openStoreForProjectCwd, openStore),
 			embedder,
 			mode,
 			routeOverride: resolved.routeOverride,
@@ -5750,12 +6326,23 @@ function apply(ctx, config = {}) {
 		});
 	});
 	const runDecay = async () => {
-		for (const scope of ["user", "project"]) {
-			const archived = await (await openStore(scope)).decay({
+		const targets = [{
+			label: "user",
+			open: () => openStore("user")
+		}];
+		for (const palace of await projectPalaces()) {
+			if (!existsSync(join(resolved.dbDir, palace.dbName))) continue;
+			targets.push({
+				label: `project「${palace.title}」`,
+				open: () => openDb(palace.dbName)
+			});
+		}
+		for (const target of targets) {
+			const archived = await (await target.open()).decay({
 				importanceBelow: resolved.decayImportanceBelow,
 				olderThanDays: resolved.decayAfterDays
 			});
-			if (archived > 0) console.warn(`[dsh-engram] 衰减调度：${scope} 库归档 ${archived} 条低价值记忆（可在 engram_review 查证）`);
+			if (archived > 0) console.warn(`[dsh-engram] 衰减调度：${target.label} 库归档 ${archived} 条低价值记忆（可在 engram_review 查证）`);
 		}
 	};
 	runDecay().catch((error) => {