@kenz1117/dsh-engram 0.7.13 → 0.7.14

package/lib/index.js

@@ -23,6 +23,7 @@ const CONFIG_KEYS = /* @__PURE__ */ new Set([
 	"modelCacheDir",
 	"hfEndpoint",
 	"ingest",
+	"reflect",
 	"provider",
 	"model",
 	"decayAfterDays",
@@ -50,6 +51,11 @@ const INGEST_MODES = /* @__PURE__ */ new Set([
 	"light",
 	"eager"
 ]);
+const REFLECT_MODES = /* @__PURE__ */ new Set([
+	"off",
+	"suggest",
+	"auto"
+]);
 /** Schemastery 校验面（cordis.yml 读取时校验）。 */
 const Config = z.object({
 	dbDir: z.string(),
@@ -59,6 +65,7 @@ const Config = z.object({
 	modelCacheDir: z.string(),
 	hfEndpoint: z.string(),
 	ingest: z.string(),
+	reflect: z.string(),
 	provider: z.string(),
 	model: z.string(),
 	decayAfterDays: z.number().step(1).min(1).max(3650),
@@ -100,6 +107,7 @@ function resolveConfig(config = {}) {
 	for (const key of Object.keys(config)) if (!CONFIG_KEYS.has(key)) throw new Error(`dsh-engram: unknown config key "${key}"`);
 	if (config.legacyMigration !== void 0 && config.legacyMigration !== "eager" && config.legacyMigration !== "conservative") throw new Error("dsh-engram: legacyMigration must be one of eager|conservative");
 	if (config.ingest !== void 0 && !INGEST_MODES.has(config.ingest)) throw new Error(`dsh-engram: ingest must be one of off|light|eager, got "${String(config.ingest)}"`);
+	if (config.reflect !== void 0 && !REFLECT_MODES.has(config.reflect)) throw new Error(`dsh-engram: reflect must be one of off|suggest|auto, got "${String(config.reflect)}"`);
 	if (config.profileTopN !== void 0 && (!Number.isInteger(config.profileTopN) || config.profileTopN < 1 || config.profileTopN > 64)) throw new Error("dsh-engram: profileTopN must be an integer in [1, 64]");
 	const hasProvider = config.provider !== void 0;
 	const hasModel = config.model !== void 0;
@@ -136,6 +144,7 @@ function resolveConfig(config = {}) {
 		modelCacheDir: config.modelCacheDir ?? join(dbDir, "models"),
 		hfEndpoint: config.hfEndpoint,
 		ingest: config.ingest ?? "off",
+		reflect: config.reflect ?? "off",
 		routeOverride: hasProvider && hasModel ? {
 			provider: config.provider,
 			model: config.model
@@ -186,6 +195,10 @@ function asEntityId(raw) {
 function asFactId(raw) {
 	return raw;
 }
+/** 从任意字符串铸造品牌化信念 id（存储层入库前调用）。 */
+function asObservationId(raw) {
+	return raw;
+}
 /** 归一化比较键：trim + 合并连续空白 + 小写（消解第一版只做精确归一匹配，不做相似合并）。 */
 function normalizeEntityName(raw) {
 	return raw.trim().replace(/\s+/g, " ").toLowerCase();
@@ -1709,6 +1722,241 @@ function cosine$1(a, b) {
 	return denom === 0 ? 0 : dot / denom;
 }
 //#endregion
+//#region src/consolidation/reflect.ts
+/**
+* 信念巩固（Reflect）：把尚未成为任何信念证据的原始记忆交辅助 LLM 巩固为一句话信念
+* （observation），并对被新证据波及的 stale 信念做新鲜度复核。
+*
+* 与 flywheel/distill 的区别：蒸馏是「合并归档」（旧记忆进 supersedes 链后消失于 active），
+* 巩固是「抽象叠加」（原始记忆全部保留，信念是带证据引用的额外一层；同一主题经向量近邻
+* 归并持续细化同一条，而非反复新增）。
+*
+* 四个动作：
+* - form   ：从新证据形成信念；向量近邻达到阈值时并入既有信念（refine），否则新建
+* - refine ：重写 stale 信念的表述并并入新证据（status 回 active）
+* - still  ：stale 信念经证据复核仍成立（仅刷新复核时间）
+* - refute ：stale 信念被证据否定（status 置 refuted，保留证据链供审计）
+* @module @kenz1117/dsh-engram/consolidation/reflect
+*/
+/** 取材池大小：从 active 记忆按 importance/confidence 倒序扫描的上限。 */
+const REFLECT_POOL = 300;
+/** 单次巩固喂给 LLM 的新证据条数上限（协议内常量：单次辅助调用的可控上下文）。 */
+const REFLECT_MAX_INPUT = 30;
+/** 单次喂给 LLM 的待复核 stale 信念上限。 */
+const REFLECT_MAX_STALE = 5;
+/** 单条 stale 信念附带的证据原文条数上限。 */
+const REFLECT_STALE_EVIDENCE_LIMIT = 6;
+/** stale 证据原文截断字符数（控制总上下文）。 */
+const REFLECT_EVIDENCE_SLICE = 120;
+/** 巩固输出 token 上限。 */
+const REFLECT_MAX_TOKENS = 900;
+/** 信念向量近邻归并阈值：新信念与既有信念余弦达到该值则并入同一条（持续细化）。 */
+const REFLECT_MERGE_THRESHOLD = .9;
+/** 新鲜度阈值：新证据与既有信念余弦达到该值（低于归并阈值，语义更宽）则把信念标 stale 待复核。 */
+const REFLECT_STALE_THRESHOLD = .86;
+const REFLECT_SYSTEM = [
+	"下面给出两部分材料：【待巩固记忆】是新近写入的原始记忆；【待复核信念】是此前巩固出、但可能受新证据影响的信念（附原始证据）。",
+	"请对材料做巩固与复核，只输出一个 JSON 数组，每项为以下四种动作之一：",
+	"1. {\"action\":\"form\",\"belief\":\"巩固出的一句话信念（结论/规律/稳定偏好）\",\"sourceIds\":[\"证据记忆id\"]} —— sourceIds 至少 1 个且必须全部来自【待巩固记忆】的 id；多条记忆支撑同一信念时合并成一条，不要为单条琐碎记忆立信念。",
+	"2. {\"action\":\"refine\",\"observationId\":\"待复核信念id\",\"belief\":\"结合新证据后的新表述\",\"sourceIds\":[\"新增证据记忆id\"]} —— 新证据补充或限定了该信念时使用；sourceIds 必须来自【待巩固记忆】，可为空数组（仅表述更准确）。",
+	"3. {\"action\":\"still\",\"observationId\":\"待复核信念id\"} —— 新证据不影响该信念，原表述仍成立。",
+	"4. {\"action\":\"refute\",\"observationId\":\"待复核信念id\",\"reason\":\"被否定的原因（引用证据）\"} —— 新证据与信念矛盾且原信念不再成立。",
+	"observationId 必须取自【待复核信念】给出的 id。材料中没有值得巩固或复核的内容时输出 []。不要输出 JSON 以外的任何内容。"
+].join("\n");
+/**
+* 执行一次信念巩固。纯异步：LLM/解析失败抛错（调用层决定是否落 pending），
+* 单条动作的写入失败计入 skipped 不中断整批。
+*/
+async function reflectObservations(deps) {
+	const outcome = {
+		pool: 0,
+		candidates: 0,
+		staleReviewed: 0,
+		formed: 0,
+		refined: 0,
+		confirmed: 0,
+		refuted: 0,
+		skipped: 0
+	};
+	const pool = await deps.store.topActive(deps.scope, REFLECT_POOL);
+	outcome.pool = pool.length;
+	const known = await deps.store.listObservations({ limit: 1e3 });
+	const evidenced = /* @__PURE__ */ new Set();
+	for (const observation of known) {
+		if (observation.status === "refuted") continue;
+		for (const sourceId of observation.sourceIds) evidenced.add(String(sourceId));
+	}
+	const candidates = pool.filter((record) => !evidenced.has(String(record.id))).slice(0, REFLECT_MAX_INPUT);
+	if (deps.embedder !== void 0 && candidates.length > 0) {
+		const vectors = await deps.embedder.embed(candidates.map((record) => record.content));
+		const staleMarks = /* @__PURE__ */ new Set();
+		for (const vector of vectors) {
+			if (vector === void 0) continue;
+			const nearest = await deps.store.nearestObservation(vector);
+			if (nearest !== void 0 && nearest.record.status === "active" && nearest.similarity >= REFLECT_STALE_THRESHOLD) staleMarks.add(String(nearest.record.id));
+		}
+		for (const id of staleMarks) try {
+			await deps.store.markObservationStale(asObservationId(id));
+		} catch {}
+	}
+	const stale = await deps.store.listObservations({
+		status: "stale",
+		limit: REFLECT_MAX_STALE
+	});
+	outcome.candidates = candidates.length;
+	outcome.staleReviewed = stale.length;
+	if (candidates.length === 0 && stale.length === 0) return outcome;
+	const candidateIds = new Set(candidates.map((record) => String(record.id)));
+	const staleIds = new Set(stale.map((observation) => String(observation.id)));
+	const sections = [];
+	if (candidates.length > 0) {
+		const lines = candidates.map((record) => `[${String(record.id)}] (${record.kind}, importance ${record.importance.toFixed(2)}) ${record.content}`);
+		sections.push(`【待巩固记忆】\n${lines.join("\n")}`);
+	}
+	if (stale.length > 0) {
+		const blocks = [];
+		for (const observation of stale) {
+			const evidence = (await deps.store.getMany(observation.sourceIds.slice(0, REFLECT_STALE_EVIDENCE_LIMIT))).map((record) => `  - ${record.content.slice(0, REFLECT_EVIDENCE_SLICE)}`).join("\n");
+			blocks.push(`[${String(observation.id)}] 证据 ${String(observation.proofCount)} 条：${observation.belief}\n${evidence}`);
+		}
+		sections.push(`【待复核信念】\n${blocks.join("\n")}`);
+	}
+	const userText = sections.join("\n\n");
+	deps.logRequest({
+		route: deps.route,
+		scope: deps.scope,
+		candidateCount: candidates.length,
+		staleCount: stale.length,
+		maxTokens: REFLECT_MAX_TOKENS
+	});
+	const parsed = parseJsonArray(await deps.call({
+		route: deps.route,
+		system: REFLECT_SYSTEM,
+		userText,
+		maxTokens: REFLECT_MAX_TOKENS,
+		purpose: "engram-reflect",
+		signal: deps.signal
+	}));
+	if (parsed === void 0 || parsed.length === 0) return outcome;
+	for (const item of parsed) {
+		const action = item;
+		try {
+			if (action.action === "form") {
+				if (await applyForm(deps, action, candidateIds) === "refined") outcome.refined += 1;
+				else outcome.formed += 1;
+			} else if (action.action === "refine") {
+				const observationId = requireObservationId(action.observationId, staleIds);
+				if (observationId === void 0) {
+					outcome.skipped += 1;
+					continue;
+				}
+				if (typeof action.belief !== "string" || action.belief.trim() === "") {
+					outcome.skipped += 1;
+					continue;
+				}
+				const sourceIds = requireCandidateIds(action.sourceIds, candidateIds);
+				if (sourceIds === void 0) {
+					outcome.skipped += 1;
+					continue;
+				}
+				await refineWithEmbedding(deps, observationId, action.belief.trim(), sourceIds);
+				outcome.refined += 1;
+			} else if (action.action === "still") {
+				const observationId = requireObservationId(action.observationId, staleIds);
+				if (observationId === void 0) {
+					outcome.skipped += 1;
+					continue;
+				}
+				await deps.store.confirmObservation(observationId);
+				outcome.confirmed += 1;
+			} else if (action.action === "refute") {
+				const observationId = requireObservationId(action.observationId, staleIds);
+				if (observationId === void 0) {
+					outcome.skipped += 1;
+					continue;
+				}
+				await deps.store.refuteObservation(observationId);
+				outcome.refuted += 1;
+			} else outcome.skipped += 1;
+		} catch {
+			outcome.skipped += 1;
+		}
+	}
+	try {
+		await deps.store.audit("reflect", "AUX", JSON.stringify({
+			scope: deps.scope,
+			pool: outcome.pool,
+			candidates: outcome.candidates,
+			staleReviewed: outcome.staleReviewed,
+			formed: outcome.formed,
+			refined: outcome.refined,
+			confirmed: outcome.confirmed,
+			refuted: outcome.refuted,
+			skipped: outcome.skipped
+		}));
+	} catch {}
+	return outcome;
+}
+/** 处理 form：校验信念与证据，算向量并决定近邻归并或新建。@returns 落库形态。 */
+async function applyForm(deps, action, candidateIds) {
+	if (typeof action.belief !== "string" || action.belief.trim() === "") throw new Error("form: belief 缺失");
+	const sourceIds = requireCandidateIds(action.sourceIds, candidateIds);
+	if (sourceIds === void 0 || sourceIds.length === 0) throw new Error("form: sourceIds 越界或为空");
+	const belief = action.belief.trim();
+	if (deps.embedder !== void 0) {
+		const vector = (await deps.embedder.embed([belief]))[0];
+		if (vector !== void 0) {
+			const nearest = await deps.store.nearestObservation(vector);
+			if (nearest !== void 0 && nearest.similarity >= REFLECT_MERGE_THRESHOLD) {
+				await deps.store.refineObservation(nearest.record.id, belief, sourceIds, vector);
+				return "refined";
+			}
+			await deps.store.createObservation({
+				scope: deps.scope,
+				belief,
+				sourceIds,
+				embedding: vector
+			});
+			return "formed";
+		}
+	}
+	await deps.store.createObservation({
+		scope: deps.scope,
+		belief,
+		sourceIds
+	});
+	return "formed";
+}
+/** refine 时同样尝试为新表述算向量（失败则只改文本与证据，保留旧向量）。 */
+async function refineWithEmbedding(deps, observationId, belief, sourceIds) {
+	if (deps.embedder !== void 0) {
+		const vector = (await deps.embedder.embed([belief]))[0];
+		if (vector !== void 0) {
+			await deps.store.refineObservation(observationId, belief, sourceIds, vector);
+			return;
+		}
+	}
+	await deps.store.refineObservation(observationId, belief, sourceIds);
+}
+/** 校验 observationId 是本次喂入的 stale 信念；非法返回 undefined（跳过该动作）。 */
+function requireObservationId(raw, staleIds) {
+	if (typeof raw !== "string" || !staleIds.has(raw)) return void 0;
+	return asObservationId(raw);
+}
+/**
+* 校验 sourceIds：必须为数组、每个 id 都来自本次候选集；返回品牌化 id 列表。
+* 非数组或含越界 id 返回 undefined（动作跳过）；空数组合法（refine 仅改表述时使用）。
+*/
+function requireCandidateIds(raw, candidateIds) {
+	if (!Array.isArray(raw)) return void 0;
+	const ids = [];
+	for (const item of raw) {
+		if (typeof item !== "string" || !candidateIds.has(item)) return void 0;
+		ids.push(asMemoryId(item));
+	}
+	return ids;
+}
+//#endregion
 //#region src/jev/client.ts
 /**
 * 调用 Jev /v1/systemone 端点并行回答 Noul 问题。
@@ -3642,7 +3890,7 @@ function placardImprovementHint(score) {
 * @module @kenz1117/dsh-engram/store/sqlite
 */
 /** 当前 schema 版本；结构性变更必须 +1。可空列与伴随表走增量迁移（见 openEngramStore 的迁移段）。 */
-const SCHEMA_VERSION = 11;
+const SCHEMA_VERSION = 12;
 /** 增量迁移表：key 为起始版本，value 为升到下一版本的 SQL（可多语句）。
 *  v2 → v3：nodes 补可空列 outcome（使用效果回报）。
 *  v3 → v4：新增 nodes_revisions 修订表（update 归档旧条目时的内容快照）。
@@ -3662,7 +3910,11 @@ const SCHEMA_VERSION = 11;
 *  v10 → v11：facts 事实表——摄取/工具期抽取的一句话事实，挂在实体上（entity_id
 *   引用同库 entities.id，无外键）。valid_at/invalid_at 时间窗 + replaced_by 软失效
 *   链：新事实可声明取代旧事实（旧事实置 invalid_at 并回指 replaced_by），历史链
-*   保留可审计；asOf 查询按时间窗过滤（见 factsOfEntity）。 */
+*   保留可审计；asOf 查询按时间窗过滤（见 factsOfEntity）。
+*  v11 → v12：observations 巩固信念表——辅助 LLM 从多条原始记忆巩固出的一句话信念，
+*   sources_json 证据 id 列表 + proof_count 证据数（去重并集持续累积），status 三态
+*   active/stale/refuted 支持新鲜度复核；embedding 支持近邻归并（同主题并入同一条而非
+*   重复新增）。与 nodes 无外键（源记忆可被归档/遗忘，证据链只保留 id 引用）。 */
 const MIGRATIONS = {
 	"2": "ALTER TABLE nodes ADD COLUMN outcome TEXT",
 	"3": `CREATE TABLE IF NOT EXISTS nodes_revisions (
@@ -3703,7 +3955,12 @@ const MIGRATIONS = {
     id TEXT PRIMARY KEY, entity_id TEXT NOT NULL, content TEXT NOT NULL,
     valid_at INTEGER NOT NULL, invalid_at INTEGER, replaced_by TEXT,
     source_node_id TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL);
-    CREATE INDEX IF NOT EXISTS facts_entity ON facts (entity_id);`
+    CREATE INDEX IF NOT EXISTS facts_entity ON facts (entity_id);`,
+	"11": `CREATE TABLE IF NOT EXISTS observations (
+    id TEXT PRIMARY KEY, scope TEXT NOT NULL, belief TEXT NOT NULL, status TEXT NOT NULL,
+    sources_json TEXT NOT NULL, proof_count INTEGER NOT NULL, embedding BLOB,
+    created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL, last_validated_at INTEGER NOT NULL);
+    CREATE INDEX IF NOT EXISTS observations_status ON observations (status, proof_count, updated_at);`
 };
 /** RRF 融合常数：score = Σ 1/(K + rank)。 */
 const RRF_K = 60;
@@ -3812,6 +4069,27 @@ function factRowToRecord(row) {
 function vecToBlob(vector) {
 	return new Uint8Array(vector.buffer, vector.byteOffset, vector.byteLength);
 }
+/** 行 → ObservationRecord；sources_json 由本插件自写，解析失败按空证据兜底（不炸读侧）。 */
+function observationRowToRecord(row) {
+	let sourceIds = [];
+	try {
+		const parsed = JSON.parse(row.sources_json);
+		if (Array.isArray(parsed)) sourceIds = parsed.filter((item) => typeof item === "string").map(asMemoryId);
+	} catch {
+		sourceIds = [];
+	}
+	return {
+		id: asObservationId(row.id),
+		scope: row.scope,
+		belief: row.belief,
+		status: row.status,
+		sourceIds,
+		proofCount: row.proof_count,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at,
+		lastValidatedAt: row.last_validated_at
+	};
+}
 /** 余弦相似度；任一向量零范数时返回 0。 */
 function cosine(a, b) {
 	let dot = 0;
@@ -3928,6 +4206,10 @@ async function openEngramStore(path, rankBoost = NO_BOOST, automation = DEFAULT_
       id TEXT PRIMARY KEY, entity_id TEXT NOT NULL, content TEXT NOT NULL,
       valid_at INTEGER NOT NULL, invalid_at INTEGER, replaced_by TEXT,
       source_node_id TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL);
+    CREATE TABLE IF NOT EXISTS observations (
+      id TEXT PRIMARY KEY, scope TEXT NOT NULL, belief TEXT NOT NULL, status TEXT NOT NULL,
+      sources_json TEXT NOT NULL, proof_count INTEGER NOT NULL, embedding BLOB,
+      created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL, last_validated_at INTEGER 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);
     CREATE INDEX IF NOT EXISTS nodes_kind_created ON nodes (kind, created_at);
@@ -3935,6 +4217,7 @@ async function openEngramStore(path, rankBoost = NO_BOOST, automation = DEFAULT_
     CREATE INDEX IF NOT EXISTS entities_name ON entities (name);
     CREATE INDEX IF NOT EXISTS node_entities_entity ON node_entities (entity_id);
     CREATE INDEX IF NOT EXISTS facts_entity ON facts (entity_id);
+    CREATE INDEX IF NOT EXISTS observations_status ON observations (status, proof_count, updated_at);
   `);
 	const versionRow = db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
 	if (versionRow === void 0) {
@@ -4070,6 +4353,18 @@ async function openEngramStore(path, rankBoost = NO_BOOST, automation = DEFAULT_
 	const sqlFactInvalidate = db.prepare("UPDATE facts SET invalid_at = ?, replaced_by = ?, updated_at = ? WHERE id = ?");
 	const sqlFactGet = db.prepare("SELECT * FROM facts WHERE id = ?");
 	const sqlPurgeFacts = db.prepare("DELETE FROM facts");
+	const sqlObservationInsert = db.prepare(`INSERT INTO observations
+    (id, scope, belief, status, sources_json, proof_count, embedding, created_at, updated_at, last_validated_at)
+    VALUES (?, ?, ?, 'active', ?, ?, ?, ?, ?, ?)`);
+	const sqlObservationGet = db.prepare("SELECT * FROM observations WHERE id = ?");
+	const sqlObservationUpdate = db.prepare(`UPDATE observations
+    SET belief = ?, status = ?, sources_json = ?, proof_count = ?,
+      embedding = COALESCE(?, embedding), updated_at = ?, last_validated_at = ? WHERE id = ?`);
+	const sqlObservationSetStatus = db.prepare("UPDATE observations SET status = ?, updated_at = ?, last_validated_at = ? WHERE id = ?");
+	const sqlObservationMarkStale = db.prepare("UPDATE observations SET status = 'stale' WHERE id = ?");
+	const sqlObservationRefute = db.prepare("UPDATE observations SET status = 'refuted', updated_at = ? WHERE id = ?");
+	const sqlObservationActiveVectors = db.prepare("SELECT * FROM observations WHERE status != 'refuted' AND embedding IS NOT NULL");
+	const sqlPurgeObservations = db.prepare("DELETE FROM observations");
 	/** FTS 道：按 scope 集合检索（占位符动态生成，scope 集合由调用方去重）；rooms 非空时只查指定房间。 */
 	const ftsSearch = (match, scopes, rooms) => {
 		const placeholders = scopes.map(() => "?").join(",");
@@ -4874,6 +5169,79 @@ async function openEngramStore(path, rankBoost = NO_BOOST, automation = DEFAULT_
 				total
 			};
 		},
+		async createObservation(input) {
+			const id = asObservationId(randomUUID());
+			const now = Date.now();
+			const sourceIds = [...new Set(input.sourceIds.map(String))].map(asMemoryId);
+			if (sourceIds.length === 0) throw new EngramError("BAD_INPUT", "createObservation 要求至少 1 条证据记忆");
+			const stored = input.embedding === void 0 ? null : vecToBlob(input.embedding);
+			withTransaction(() => {
+				sqlObservationInsert.run(id, input.scope, input.belief, JSON.stringify(sourceIds.map(String)), sourceIds.length, stored, now, now, now);
+			});
+			return {
+				id,
+				scope: input.scope,
+				belief: input.belief,
+				status: "active",
+				sourceIds,
+				proofCount: sourceIds.length,
+				createdAt: now,
+				updatedAt: now,
+				lastValidatedAt: now
+			};
+		},
+		async refineObservation(id, belief, addSourceIds, embedding) {
+			const existing = sqlObservationGet.get(String(id));
+			if (existing === void 0) return void 0;
+			const merged = [.../* @__PURE__ */ new Set([...observationRowToRecord(existing).sourceIds.map(String), ...addSourceIds.map(String)])].map(asMemoryId);
+			const now = Date.now();
+			const stored = embedding === void 0 ? null : vecToBlob(embedding);
+			withTransaction(() => {
+				sqlObservationUpdate.run(belief, "active", JSON.stringify(merged.map(String)), merged.length, stored, now, now, String(id));
+			});
+			return observationRowToRecord(sqlObservationGet.get(String(id)));
+		},
+		async markObservationStale(id) {
+			if (sqlObservationGet.get(String(id)) === void 0) return void 0;
+			sqlObservationMarkStale.run(String(id));
+			return observationRowToRecord(sqlObservationGet.get(String(id)));
+		},
+		async confirmObservation(id) {
+			if (sqlObservationGet.get(String(id)) === void 0) return void 0;
+			const now = Date.now();
+			sqlObservationSetStatus.run("active", now, now, String(id));
+			return observationRowToRecord(sqlObservationGet.get(String(id)));
+		},
+		async refuteObservation(id) {
+			if (sqlObservationGet.get(String(id)) === void 0) return void 0;
+			const now = Date.now();
+			withTransaction(() => {
+				sqlObservationRefute.run(now, String(id));
+			});
+			return observationRowToRecord(sqlObservationGet.get(String(id)));
+		},
+		async listObservations(filter) {
+			const offset = Math.max(0, filter.offset ?? 0);
+			if (filter.status === void 0) return db.prepare("SELECT * FROM observations ORDER BY proof_count DESC, updated_at DESC LIMIT ? OFFSET ?").all(filter.limit, offset).map(observationRowToRecord);
+			return db.prepare("SELECT * FROM observations WHERE status = ? ORDER BY proof_count DESC, updated_at DESC LIMIT ? OFFSET ?").all(filter.status, filter.limit, offset).map(observationRowToRecord);
+		},
+		async nearestObservation(embedding) {
+			const rows = sqlObservationActiveVectors.all();
+			let best;
+			let bestSim = 0;
+			for (const row of rows) {
+				if (row.embedding === null) continue;
+				const sim = cosine(embedding, blobToVec(row.embedding));
+				if (sim > bestSim) {
+					bestSim = sim;
+					best = row;
+				}
+			}
+			return best === void 0 ? void 0 : {
+				record: observationRowToRecord(best),
+				similarity: bestSim
+			};
+		},
 		async audit(op, targetId, detail) {
 			sqlLog.run(Date.now(), op, targetId, detail);
 		},
@@ -4899,6 +5267,7 @@ async function openEngramStore(path, rankBoost = NO_BOOST, automation = DEFAULT_
 				sqlPurgeNodeEntities.run();
 				sqlPurgeEntities.run();
 				sqlPurgeFacts.run();
+				sqlPurgeObservations.run();
 			});
 		},
 		async close() {
@@ -5277,7 +5646,7 @@ function assessEvidence(batch, request) {
 //#endregion
 //#region src/tools/create.ts
 /**
-* 20 个 engram_ 工具的定义与执行器。工具 schema 保持窄参数；
+* 21 个 engram_ 工具的定义与执行器。工具 schema 保持窄参数；
 * scope 决定读写哪个分库；嵌入缺失时检索结果显式标记降级。
 * @module @kenz1117/dsh-engram/tools/create
 */
@@ -7207,6 +7576,67 @@ function createEngramTools(baseDeps) {
 				return { text: `蒸馏完成：取材 ${outcome.input} 条，产出 ${outcome.distilled} 条高层规律，归档 ${outcome.superseded} 条旧记忆（supersedes 链已建立，可 engram_review 审计）。` };
 			}
 		}),
+		defineTool({
+			name: "engram_reflect",
+			description: "信念巩固：把多条原始记忆经辅助 LLM 巩固为带证据数的高层信念（form 新建/refine 细化/still 维持/refute 否定），同主题自动归并；原始记忆保留不归档。反复出现的模式或新增一批记忆后调用。",
+			parameters: { scope: {
+				type: "string",
+				enum: [
+					"user",
+					"project",
+					"shared"
+				],
+				description: "作用域，默认 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 scope = scopeOf(args.scope, "user");
+				if (deps.call === void 0) throw new Error("engram_reflect: 辅助 LLM 不可用（宿主未提供 llm 服务），无法巩固");
+				const call = deps.call;
+				const events = exec.agent?.session?.snapshotEvents() ?? [];
+				const route = deps.routeOverride ?? routeFromEvents(events);
+				if (route === void 0) throw new Error("engram_reflect: 无法确定模型路由（会话尚无模型请求），请在 cordis.yml 配置 provider/model");
+				const store = await deps.openStore(scope);
+				const outcome = await reflectObservations({
+					store,
+					embedder: await deps.embedder,
+					scope,
+					call: (params) => call({
+						...params,
+						sessionId: exec.agent === void 0 ? void 0 : String(exec.agent.session.id)
+					}),
+					logRequest: (data) => {
+						store.audit("reflect-request", "AUX", JSON.stringify(data)).catch(() => {});
+					},
+					route,
+					signal: exec.signal
+				});
+				const pending = await store.listAuditDetails("reflect-pending");
+				let consumed = 0;
+				for (const detail of pending) try {
+					if (JSON.parse(detail).scope === scope) {
+						await store.clearAudit("reflect-pending", detail);
+						consumed += 1;
+					}
+				} catch {}
+				const lines = [`信念巩固完成：取材池 ${String(outcome.pool)} 条，新证据 ${String(outcome.candidates)} 条、待复核信念 ${String(outcome.staleReviewed)} 条；新建 ${String(outcome.formed)}，细化 ${String(outcome.refined)}，维持 ${String(outcome.confirmed)}，否定 ${String(outcome.refuted)}，跳过 ${String(outcome.skipped)}。`, "信念是叠加在原始记忆之上的抽象层（证据 id 与证据数已留存，原始记忆未归档）。"];
+				if (consumed > 0) lines.push(`同时消费了 ${String(consumed)} 条会话结束时登记的待巩固任务。`);
+				return { text: lines.join("\n") };
+			}
+		}),
 		defineTool({
 			name: "engram_examine",
 			description: "渐进式披露：按 id 批量拉取记忆完整铭牌（content + 房间 + 状态 + 边关系）。仅在已通过 engram_search/timeline/neighbors 拿到候选 id 后调用，避免一次性吞全文。建议 ≤16 个 id，超出会按入参顺序保留前 N 条。",
@@ -7764,6 +8194,12 @@ function renderProfileWithCurated(curated, records, tokenBudget, itemBudget = DE
 const COMPRESS_MAX_TOKENS = 800;
 /** 压缩辅助调用超时：压缩在 pre-step 关键路径上，必须限时防阻塞首轮请求。 */
 const COMPRESS_TIMEOUT_MS = 8e3;
+/** turn_start 注入的巩固信念条数上限（按证据数、新近度倒序）。 */
+const OBSERVATION_INJECT_LIMIT = 3;
+/** 单条信念注入截断字符数。 */
+const OBSERVATION_INJECT_ITEM_CHARS = 120;
+/** 信念区块总字符上限（独立于画像 token 预算，避免与画像互相挤压）。 */
+const OBSERVATION_INJECT_BLOCK_CHARS = 480;
 const COMPRESS_SYSTEM = [
 	"把记忆条目压缩为更短的一句话表述（每条不超过 40 个字符），保留可跨会话复用的关键信息（事实、偏好、决策、方法）。",
 	"只输出一个 JSON 数组，每项形如 {\"id\": \"原样返回的id\", \"content\": \"压缩后表述\"}，条目数量与 id 必须与输入一一对应。",
@@ -7918,6 +8354,14 @@ async function preStep(ctx, openStore, openStoreForProjectCwd, resolved, embedde
 			}).text;
 		}
 	}
+	const observations = await store.listObservations({
+		status: "active",
+		limit: OBSERVATION_INJECT_LIMIT
+	});
+	if (observations.length > 0) {
+		const block = ["Consolidated beliefs (distilled from multiple stored memories; verify against sources before high-stakes use):", ...observations.map((observation) => `- ${observation.belief.slice(0, OBSERVATION_INJECT_ITEM_CHARS)} (${String(observation.proofCount)} sources)`)].join("\n").slice(0, OBSERVATION_INJECT_BLOCK_CHARS);
+		text = `${text}\n\n${block}`;
+	}
 	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");
@@ -8363,6 +8807,51 @@ function apply(ctx, config = {}) {
 			console.warn("[dsh-engram] 会话结束的收尾处理异常（不影响对话）：", error);
 		});
 	});
+	if (resolved.reflect !== "off") ctx.on("session/disposed", (session) => {
+		const events = session.snapshotEvents();
+		const sessionId = String(session.id);
+		const cwd = sessionCwd(session);
+		const route = resolved.routeOverride ?? routeFromEvents(events);
+		const targets = [{
+			scope: "user",
+			open: () => openStore("user")
+		}];
+		if (cwd !== void 0 && existsSync(join(resolved.dbDir, dbNameForCwd(cwd)))) targets.push({
+			scope: "project",
+			open: () => openStoreForProjectCwd(cwd)
+		});
+		(async () => {
+			for (const target of targets) try {
+				const store = await target.open();
+				if (resolved.reflect === "suggest") {
+					const detail = JSON.stringify({
+						scope: target.scope,
+						sessionId
+					});
+					if (!await store.hasAudit("reflect-pending", detail)) await store.audit("reflect-pending", "AUX", detail);
+					continue;
+				}
+				if (route === void 0) continue;
+				const outcome = await reflectObservations({
+					store,
+					embedder: await embedder,
+					scope: target.scope,
+					call: (params) => streamText(ctx, {
+						...params,
+						sessionId: session.id
+					}),
+					logRequest: (data) => {
+						store.audit("reflect-request", "AUX", JSON.stringify(data)).catch(() => {});
+					},
+					route,
+					signal: AbortSignal.timeout(FINAL_INGEST_TIMEOUT_MS)
+				});
+				if (outcome.formed + outcome.refined + outcome.confirmed + outcome.refuted > 0) console.log(`[dsh-engram] 信念巩固完成（${target.scope}）：新建 ${String(outcome.formed)}，细化 ${String(outcome.refined)}，维持 ${String(outcome.confirmed)}，否定 ${String(outcome.refuted)}`);
+			} catch (error) {
+				console.warn(`[dsh-engram] 会话结束的信念巩固异常（${target.scope}，不影响对话）：`, error);
+			}
+		})();
+	});
 	const runDecay = async () => {
 		const targets = [{
 			label: "user",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kenz1117/dsh-engram",
   "description": "Cross-session long-term memory for DeepSeek Harness (memory palace · AGI Architecture Exploration on dsh-market): dual-scope SQLite memory graph, hybrid retrieval, provenance audit, and a knowledge flywheel.",
-  "version": "0.7.13",
+  "version": "0.7.14",
   "icon": "icon.svg",
   "logo": "icon-256.svg",
   "publishConfig": {