dsh-prime-memory 0.21.0 → 0.22.2

package/dist/metadata-validators.js

@@ -10,6 +10,7 @@
  * 历史上 Wing 侧零校验,非法值先入库、再由下游剥离,形成无谓的写入-剥离循环。
  */
 import { WING_CATALOG, WING_FALLBACK } from './types.js';
+import { isCognitiveHall, COG_HALL_METADATA_KEY } from './cognitive-hall.js';
 /** Wing 词表(8 域 + general 兜底):与 relabel 机械校验、提示词候选集同源。 */
 const WING_ID_SET = new Set([
     ...WING_CATALOG.map((w) => w.id),
@@ -66,3 +67,47 @@ export function normTags(v, max = 3) {
     return out;
 }
 export { isCognitiveHall, COGNITIVE_HALLS } from './cognitive-hall.js';
+/** usageScenario 单条最大长度(“何时该浮现”的短语，非 slug，故不校 isTag 字符集)。 */
+const USAGE_SCENARIO_MAX_CHARS = 60;
+/**
+ * usageScenario 归一 + 去重 + 上限。**所有写回点必须过这里**。
+ *
+ * 与 normTags 的区别：usageScenario 是自然语言短语（如“修改 profile 配置时”），
+ * 不是 slug，所以不做字符集校验，只做 trim/去重/长度钳制/上限。
+ * 非数组或空→ `[]`（缺字段中性，不抛——防单条抽取失败波及整切片重试）。
+ */
+export function normUsageScenario(v, max = 3) {
+    if (!Array.isArray(v) || max <= 0)
+        return [];
+    const out = [];
+    for (const raw of v) {
+        if (typeof raw !== 'string')
+            continue;
+        const t = raw.trim();
+        if (!t || out.includes(t))
+            continue;
+        out.push(t.slice(0, USAGE_SCENARIO_MAX_CHARS));
+        if (out.length >= max)
+            break;
+    }
+    return out;
+}
+/**
+ * 读 **Wing（生活域）**。⚠️ 磁盘键是 `metadata.hall`——历史别名，存的其实是 **wing 值**。
+ * 只认词表内的合法 wing（8 角 + general），否则 undefined。
+ *
+ * 用它取代裸读 `metadata.hall`：从入口上把“wing 轴”与“认知 hall 轴”分开，
+ * 防止把认知 hall 值（facts/events/…）误当 wing 读——两轴不串。
+ */
+export function readWing(metadata) {
+    const v = metadata?.hall;
+    return typeof v === 'string' && isWingId(v) ? v : undefined;
+}
+/**
+ * 读 **认知 hall（大类）**。磁盘键 `metadata.cogHall`，与 wing 的磁盘键 `hall` 正交。
+ * 只认五个枚举值，否则 undefined（wing 值不当认知 hall 读）。
+ */
+export function readCognitiveHall(metadata) {
+    const v = metadata?.[COG_HALL_METADATA_KEY];
+    return isCognitiveHall(v) ? v : undefined;
+}

package/dist/pipeline/l1.js

@@ -12,6 +12,7 @@ import { callLLM, parseJsonLogged, resolveLayerTokens } from '../llm.js';
 import { buildReceipts, newRunId, persistReceiptsSafely } from '../store/receipts.js';
 import { buildConflictPair, conflictRejectId, DEFER_MAX, normalizeClaimKey, normalizeConflictType, occupiesConflictQuota, pendingHardTotal, validateConflictPair, } from '../store/conflicts.js';
 import { formatExtractionPrompt, getExtractMemoriesSystemPrompt } from '../prompts/l1-extraction.js';
+import { normUsageScenario } from '../metadata-validators.js';
 import { formatBatchConflictPrompt, getConflictDetectionSystemPrompt } from '../prompts/l1-dedup.js';
 import { resolveSourceAnchors, withSourceAnchors } from './anchors.js';
 import { familyForType, normPersistence, normScope, resolveRecordFamily, resolveRecordScope, WING_FALLBACK } from '../types.js';
@@ -58,6 +59,19 @@ function mergeTemporal(self, targets) {
  * 第 4 个参数是 R7 的锚点映射(`L0 消息 id → 会话坐标`)。**传 undefined 时
  * 行为与改动前逐字一致**——老调用方与没有锚点的会话走这条分支。
  */
+/**
+ * 把抽取侧的 `metadata.usageScenario` 归一到命名空间保留键 `dsh_usage_scenario`
+ *（与 dsh_source_anchors 同范式）。**无该键时原样返回**——功能关时 LLM 不产出该键，
+ * 记录 metadata 与改动前逐字一致（零漂移）。只随新蒸馏写，不回填存量。
+ */
+function withUsageScenario(meta) {
+    if (!meta || !('usageScenario' in meta))
+        return meta;
+    const out = { ...meta };
+    out.dsh_usage_scenario = normUsageScenario(out.usageScenario);
+    delete out.usageScenario;
+    return out;
+}
 function toStoreRecord(m, now, ts, anchorMap) {
     return {
         id: m.record_id,
@@ -72,7 +86,7 @@ function toStoreRecord(m, now, ts, anchorMap) {
         source_message_ids: m.source_message_ids ?? [],
         // R7:锚点与 source_message_ids 同源解析;解析不到就**不写键**(不是空数组),
         // 使无锚点记录与改动前的 metadata 逐字一致。
-        metadata: withSourceAnchors(m.metadata, anchorMap === undefined ? undefined : resolveSourceAnchors(m.source_message_ids, anchorMap)),
+        metadata: withSourceAnchors(withUsageScenario(m.metadata), anchorMap === undefined ? undefined : resolveSourceAnchors(m.source_message_ids, anchorMap)),
         family: m.family,
         scope: m.scope,
         workspaceId: m.workspaceId,
@@ -195,7 +209,7 @@ anchorMap) {
             halls,
         });
         const raw = await callLLM(ctx, cfg, {
-            system: getExtractMemoriesSystemPrompt(mode),
+            system: getExtractMemoriesSystemPrompt(mode, { usageScenario: cfg.usageScenario?.enabled === true, narrative: cfg.narrativeTemplates?.enabled === true }),
             user: userPrompt,
             maxTokens: resolveLayerTokens(cfg, 'extract'),
             layer: 'l1-extract',

package/dist/pipeline/ruminate.d.ts

@@ -21,6 +21,7 @@ import type { SceneStore } from '../store/scenes.js';
 import type { StateStore } from '../store/state.js';
 import type { LiveSettingsHandle } from '../settings.js';
 import type { MemoryFamily, MemoryLogger } from '../types.js';
+import { type SlotMigrateStoreFace } from './slot-migrate.js';
 import { type RelabelStats } from './relabel.js';
 import type { MemoryRunner } from './runner.js';
 export interface RuminateStatus {
@@ -77,6 +78,8 @@ export declare class RuminateController {
         scenes: Record<MemoryFamily, SceneStore>;
         persona: Record<MemoryFamily, PersonaStore>;
         state: StateStore;
+        /** 常驻槽位面（仅 cfg.slots.migrateLegacy 开启时读/写，缺省不碰）。 */
+        slots?: SlotMigrateStoreFace;
     }, logger: MemoryLogger, live: LiveSettingsHandle, pendingFile: string, 
     /** Room 注册表(可选;孤儿候选预标记的合并词表来源)。 */
     roomRegistry?: {

package/dist/pipeline/ruminate.js

@@ -2,6 +2,7 @@ import { InProcMemoryBackend } from '../store/memory-backend.js';
 import { groupPendingBySession, loadPending, } from '../store/pending.js';
 import { errDetail } from '../util/filelog.js';
 import { runSceneConsolidation } from './l2.js';
+import { migrateLegacySlots } from './slot-migrate.js';
 import { relabelPass } from './relabel.js';
 import { processSceneReclusterJobs } from './recluster.js';
 import { annotateOrphanCandidates } from '../room-review.js';
@@ -148,7 +149,11 @@ export class RuminateController {
         // 原先 setImmediate 连发会把全部会话一次性塞进 runner 队列(无界堆积),
         // LLM e2e 延迟波动时既拖慢 live 任务也让取消语义变钝;链式入队后
         // 进度(done)真实逐会话推进,取消即刻停止入队。
-        this.runner.enqueue(session.sessionId, session.messages, session.mode, {
+        // 传空消息（与 enqueueSessionSlices 同一语义）：让 runTurn 不回灌缓冲，
+        // 由 distillSession 直接处理该会话在内存缓冲里的既有切片。
+        // （旧代码传 session.messages——那是从 pending.json 读出的、已在缓冲中的消息，
+        //   经 runTurn 的 `bucket.push(...messages)` 会重复入桶 → 反刍后待处理计数“还原/变多”。）
+        this.runner.enqueue(session.sessionId, [], session.mode, {
             force: true,
             onTurnDone: (records) => {
                 this.totalL1 += records;
@@ -199,7 +204,18 @@ export class RuminateController {
                         if (scenes.length === 0)
                             continue;
                         const fstate = this.runner.states?.[family];
+                        // 强制 L3：runPersona 自带触发判定(memoriesSinceL3>=interval 才跑)，反刍是用户
+                        // 显式整理动作，需绕过阈值真跑——置 personaRequestedReason 走“主动请求”分支。
+                        if (fstate)
+                            fstate.personaRequestedReason = '反刍收尾';
                         await runPersona(this.ctx, this.cfg, this.stores.scenes[family], this.stores.persona[family], fstate || undefined, this.logger, family);
+                        // 与 L2 块对称：无论 runPersona 是否因“无变化场景”早退，反刍收尾都清零 L3 计数，
+                        // 否则“待 L3 新记忆”会永远卡在阈值下(本 bug 根因)。runPersona 成功时已自清，这里幂等兜底。
+                        if (fstate) {
+                            fstate.memoriesSinceL3 = 0;
+                            fstate.lastL3At = Date.now();
+                            fstate.personaRequestedReason = undefined;
+                        }
                         this.logger.info(`[memory] 反刍 L3 完成(family=${family})`);
                     }
                     catch (err) {
@@ -207,6 +223,15 @@ export class RuminateController {
                     }
                 }
             }
+            // 反刍收尾改了 L2/L3 计数（runner.states 是 StateStore 的活引用，内存态）——
+            // 必须显式落盘，否则重启从 state.json 读回旧值，表现为“待处理计数反复”。
+            // （正常蒸馏路径由 runTurn 末尾 save；反刍 finalize 是独立路径，需自己 save。）
+            await this.stores.state.save();
+            // 旧 slot 语义迁移（cfg.slots.migrateLegacy 默认关 → 直接 0 动作）：
+            // 把“钉成常驻、内容已由活 L1 记忆承载”的 rule 槽位软退场。
+            if (this.stores.slots !== undefined) {
+                await migrateLegacySlots(this.stores.slots, this.stores.l1, this.cfg.slots.migrateLegacy === true, this.logger);
+            }
             // 标注校验/重标定:Wing 合法性 + 认知 hall 映射 + 未打标补标 + 涌现标签
             // 批次进度经 onProgress 写入 detail + sub 子进度(非会话阶段的进度由重标批次决定)
             this.status.phase = 'relabeling';
@@ -333,7 +358,18 @@ export class RuminateController {
             this.status.detail = `L3 画像更新(${family})`;
             const fstate = this.runner.states?.[family];
             try {
+                // 强制 L3：runPersona 自带触发判定(memoriesSinceL3>=interval 才跑)，反刍是显式整理动作，
+                // 需绕过阈值真跑——置 personaRequestedReason 走“主动请求”分支。
+                if (fstate)
+                    fstate.personaRequestedReason = '反刍轻量刷新';
                 await runPersona(this.ctx, this.cfg, this.stores.scenes[family], this.stores.persona[family], fstate, this.logger, family);
+                // 与 L2 循环对称：无论 runPersona 是否因“无变化场景”早退，都清零 L3 计数，
+                // 否则“待 L3 新记忆”永远卡在阈值下。runPersona 成功时已自清，这里幂等兜底。
+                if (fstate) {
+                    fstate.memoriesSinceL3 = 0;
+                    fstate.lastL3At = Date.now();
+                    fstate.personaRequestedReason = undefined;
+                }
             }
             catch (err) {
                 this.logger.warn(`[memory] 反刍轻量刷新 L3 失败(family=${family}): ${errDetail(err)}`);
@@ -361,6 +397,19 @@ export class RuminateController {
             this.status.sub = null;
             this.status.done++;
         }
+        // 轻量刷新改了 L2/L3 计数（runner.states 是 StateStore 活引用）——必须显式落盘，
+        // 否则重启从 state.json 读回旧值，表现为“待 L2/L3 计数反复”。
+        try {
+            await this.stores.state.save();
+        }
+        catch (err) {
+            this.logger.warn(`[memory] 反刍轻量刷新 state 落盘失败(计数可能不持久): ${errDetail(err)}`);
+        }
+        // 旧 slot 语义迁移：无 pending 缓冲时走的是本路径（“待 L3 12/20”那类场景），
+        // 与 finalize 同一动作、同样默认关；两处幂等（退场后不再命中 open）。
+        if (this.stores.slots !== undefined) {
+            await migrateLegacySlots(this.stores.slots, this.stores.l1, this.cfg.slots.migrateLegacy === true, this.logger);
+        }
         this.status.running = false;
         this.status.detail = null;
         this.status.phase = this.cancelRequested ? 'cancelled' : 'done';

package/dist/pipeline/slot-migrate.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 旧 slot 语义迁移（`cfg.slots.migrateLegacy`，默认关）。
+ *
+ * 背景：常驻槽位是"每轮硬注入"的 opt-in 约定。早期用法里有一类槽位其实是
+ * **把一条已经存在的 L1 记忆钉成常驻**（`refs` 直指那条记录）——内容载体还在，
+ * 却占了固定 token 预算、还在概要里显示成常驻清单。新取向是"记忆按相关性隐式
+ * 浮现，除非手动提醒激活"，所以这类槽位应当退场，让那条记忆回到召回。
+ *
+ * 判据（四条同时满足，宁缺勿滥）：
+ *  1. 开关显式开启（动的是用户手动建的约定，不自动生效）；
+ *  2. `status='open'` 且 `pinned=true` 且 `kind='rule'`（todo/anchor/pointer 各有语义，一律不碰）；
+ *  3. `refs` 至少一条解析到**未退场**的 L1 记录（退场不丢信息：正文仍在记忆里）；
+ *  4. 记录本身可被召回（未退场即可检索，不再另设条件）。
+ *
+ * 动作：`close(id, 'dropped')` —— **软退场**，不删数据；记忆仍在，需要时可
+ * 重新 `memory_slot_write`。逐条 info 日志，便于事后核对。
+ */
+import type { Slot } from '../store/slots.js';
+import type { MemoryLogger } from '../types.js';
+/** 迁移需要的槽位面。 */
+export interface SlotMigrateStoreFace {
+    list(): Slot[];
+    close(id: string, status: 'done' | 'dropped'): Promise<boolean>;
+}
+/** 迁移需要的 L1 只读面（validTo 非空 = 已退场（epoch ms），不作为信息载体）。 */
+export interface SlotMigrateL1Face {
+    getByIds(ids: string[]): Array<{
+        id: string;
+        validTo?: number | null;
+    }>;
+}
+/** 一条可迁移槽位（预览用，执行前即可展示）。 */
+export interface MigrateCandidate {
+    id: string;
+    title: string;
+    /** 承载内容的活记录 id。 */
+    carrier: string;
+}
+/** 判定 + 挑选可迁移槽位（纯读，无副作用；面板预览与反刍执行共用）。 */
+export declare function pickMigratableSlots(slots: readonly Slot[], l1: SlotMigrateL1Face | undefined): MigrateCandidate[];
+/**
+ * 执行迁移：软退场命中的槽位。
+ * @returns 实际退场条数（close 返回 false 的不计）。
+ */
+export declare function migrateLegacySlots(slots: SlotMigrateStoreFace, l1: SlotMigrateL1Face | undefined, enabled: boolean, logger?: MemoryLogger): Promise<number>;

package/dist/pipeline/slot-migrate.js

@@ -0,0 +1,45 @@
+import { errDetail } from '../util/filelog.js';
+/** 判定 + 挑选可迁移槽位（纯读，无副作用；面板预览与反刍执行共用）。 */
+export function pickMigratableSlots(slots, l1) {
+    if (l1 === undefined)
+        return [];
+    const open = slots.filter((s) => s.status === 'open' && s.pinned === true && s.kind === 'rule');
+    if (open.length === 0)
+        return [];
+    // 一次批量取全部 refs，避免 N 次查询。
+    const allRefs = [...new Set(open.flatMap((s) => s.refs ?? []))];
+    const alive = new Set(l1.getByIds(allRefs).filter((r) => r.validTo === undefined || r.validTo === null).map((r) => r.id));
+    const out = [];
+    for (const s of open) {
+        const carrier = (s.refs ?? []).find((r) => alive.has(r));
+        if (carrier !== undefined)
+            out.push({ id: s.id, title: s.title, carrier });
+    }
+    return out;
+}
+/**
+ * 执行迁移：软退场命中的槽位。
+ * @returns 实际退场条数（close 返回 false 的不计）。
+ */
+export async function migrateLegacySlots(slots, l1, enabled, logger) {
+    if (enabled !== true)
+        return 0;
+    const candidates = pickMigratableSlots(slots.list(), l1);
+    if (candidates.length === 0)
+        return 0;
+    let done = 0;
+    for (const c of candidates) {
+        try {
+            if (await slots.close(c.id, 'dropped')) {
+                done++;
+                logger?.info(`[memory] 旧槽位迁移:「${c.title}」常驻退场，内容改由召回承载(${c.carrier})`);
+            }
+        }
+        catch (err) {
+            logger?.warn(`[memory] 旧槽位迁移失败(${c.id}): ${errDetail(err)}`);
+        }
+    }
+    if (done > 0)
+        logger?.info(`[memory] 旧槽位迁移完成: 常驻约定退场 ${done} 条`);
+    return done;
+}

package/dist/projection/recall.d.ts

@@ -0,0 +1,74 @@
+/**
+ * 会话「活召回集」服务端投影(memoryRecall)。
+ *
+ * 语义：本会话**已注入、且目前仍在上下文里**的记忆（= 模型此刻真正看到的几条）。
+ * 上下文被压缩/清空时注入内容离开模型，集合随之清空——数据源是
+ * `SessionRecalledStore`（sessionKey 键、写穿持久化），所以**旧会话重开也读得到**。
+ *
+ * 与 memorySlots 的分工（两条轴，互不替代）：
+ * - `memorySlots` = 用户手动 pin 的**常驻约定**（每轮硬注入，注册表语义）；
+ * - `memoryRecall` = 按相关性**隐式浮现**的召回结果（非常驻，本投影）。
+ * 召回记录绝不灌进 memorySlots：那会把"非常驻"伪装成槽位注册表。
+ *
+ * 会话感知靠 `init(header)`：宿主在 `session/created` 与冷加载 restore 两处都传
+ * `session.header`（`dsh-session/lib/index.js` 实证形状 `{ version, id, createdAt, … }`），
+ * `header.id` 即会话 id，与召回记账的 sessionKey（`agent.session?.id ?? agent.id`）同源。
+ * state 里带上 sessionId，apply 无 session 参数也能按本会话重读 store。
+ *
+ * 消费方是 dsh-brief-sidebar 的「本会话召回」分区（`useProjectionValue(ctx, sessionId, key)`）。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { SessionRecalledStore } from '../store/session-recalled.js';
+export declare const MEMORY_RECALL_KEY = "memoryRecall";
+/** view 最多透出条数（最近在上；超出部分只计入 count，防 wire 体量失控）。 */
+export declare const RECALL_VIEW_CAP = 20;
+/** 一条召回记录在 wire view 上的呈现。 */
+export interface RecallItemView {
+    id: string;
+    type: string;
+    /** 正文首行（截断至 TITLE_MAX）；全文由消费方按需走面板读。 */
+    title: string;
+    priority: number;
+    /** 使用场景（metadata.dsh_usage_scenario）；无则缺席（附加字段，旧帧没有也整条通过）。 */
+    scenario?: string[];
+}
+/** 持久态：本会话的活召回 id 集 + 判脏序号。 */
+export interface RecallProjectionState {
+    rev: number;
+    sessionId: string;
+    /** 注入序（旧→新），由 store 保证。 */
+    ids: string[];
+}
+/** wire view：count 是总数，items 是**最近在上**的截断视图。 */
+export interface RecallView {
+    rev: number;
+    sessionId: string;
+    count: number;
+    items: RecallItemView[];
+}
+/** 零依赖 schema（同 slots 投影的理由：registry 只调 `parse`，且按 Object.is 比较引用）。 */
+interface SchemaLike<T> {
+    parse(value: unknown): T;
+}
+/** state 校验（registry 用它挡掉损坏/过期的 checkpoint 行）。 */
+export declare const stateSchema: SchemaLike<RecallProjectionState>;
+/** view 校验（出网前调用；未知键容忍，同 slots 投影的语义边界）。 */
+export declare const viewSchema: SchemaLike<RecallView>;
+/** 投影需要的 L1 只读面（结构化声明，避免跨模块类型耦合）。 */
+export interface RecallL1Face {
+    getByIds(ids: string[]): Array<{
+        id: string;
+        type: string;
+        content: string;
+        priority: number;
+        metadata?: Record<string, unknown>;
+    }>;
+}
+/**
+ * 注册 memoryRecall 投影。
+ *
+ * 缺席降级同 slots 投影：`ctx.inject` 在服务未提供时不回调；形状不符静默不注册。
+ * apply 是 O(1) 判脏（store.revision() 比对），任意已提交事件都会带进来看一眼。
+ */
+export declare function registerRecallProjection(ctx: Context, store: SessionRecalledStore, l1?: RecallL1Face): void;
+export {};

package/dist/projection/recall.js

@@ -0,0 +1,148 @@
+export const MEMORY_RECALL_KEY = 'memoryRecall';
+/** view 最多透出条数（最近在上；超出部分只计入 count，防 wire 体量失控）。 */
+export const RECALL_VIEW_CAP = 20;
+/** 单条标题（正文首行）最大长度。 */
+const TITLE_MAX = 160;
+function invalid(what, detail) {
+    throw new Error(`${what}: ${detail}`);
+}
+function requireRecord(value, what) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        invalid(what, '期望普通对象');
+    }
+    return value;
+}
+function requireCounter(value, what, field) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
+        invalid(what, `${field} 必须是非负整数`);
+    }
+}
+function requireString(value, what, field) {
+    if (typeof value !== 'string')
+        invalid(what, `${field} 必须是字符串`);
+}
+/** state 校验（registry 用它挡掉损坏/过期的 checkpoint 行）。 */
+export const stateSchema = {
+    parse: (value) => {
+        const what = 'memoryRecall.state';
+        const root = requireRecord(value, what);
+        requireCounter(root.rev, what, 'rev');
+        requireString(root.sessionId, what, 'sessionId');
+        if (!Array.isArray(root.ids))
+            invalid(what, 'ids 必须是字符串数组');
+        root.ids.forEach((id, i) => requireString(id, `${what}.ids[${i}]`, 'id'));
+        return value;
+    },
+};
+/** view 校验（出网前调用；未知键容忍，同 slots 投影的语义边界）。 */
+export const viewSchema = {
+    parse: (value) => {
+        const what = 'memoryRecall.view';
+        const root = requireRecord(value, what);
+        requireCounter(root.rev, what, 'rev');
+        requireString(root.sessionId, what, 'sessionId');
+        requireCounter(root.count, what, 'count');
+        if (!Array.isArray(root.items))
+            invalid(what, 'items 必须是数组');
+        root.items.forEach((raw, i) => {
+            const at = `${what}.items[${i}]`;
+            const item = requireRecord(raw, at);
+            requireString(item.id, at, 'id');
+            requireString(item.type, at, 'type');
+            requireString(item.title, at, 'title');
+            requireCounter(item.priority, at, 'priority');
+            if (item.scenario !== undefined) {
+                if (!Array.isArray(item.scenario))
+                    invalid(at, 'scenario 必须是字符串数组');
+                item.scenario.forEach((s, j) => requireString(s, `${at}.scenario[${j}]`, 'scenario'));
+            }
+        });
+        return value;
+    },
+};
+/** 正文首行 → 标题（投影内不引 client 的 format 工具，保持服务端自足）。 */
+function firstLine(content) {
+    const line = content.split('\n').find((l) => l.trim().length > 0) ?? content;
+    const trimmed = line.trim();
+    return trimmed.length > TITLE_MAX ? trimmed.slice(0, TITLE_MAX) : trimmed;
+}
+/** 读 store 建态；ids 与旧态一致时返回旧引用（避免无谓 republish）。 */
+function buildState(sessionId, store, prev) {
+    const ids = store.list(sessionId);
+    if (prev !== undefined && prev.rev === store.revision() && sameIds(prev.ids, ids))
+        return prev;
+    const next = { rev: store.revision(), sessionId, ids };
+    // rev 变了但本会话集合没变（别的会话写了）→ 仍复用旧引用，防跨会话 thrash。
+    if (prev !== undefined && prev.sessionId === sessionId && sameIds(prev.ids, ids))
+        return prev;
+    return next;
+}
+function sameIds(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (a[i] !== b[i])
+            return false;
+    return true;
+}
+/** view 引用稳定：同一 state 恒返回同一对象（registry 按 Object.is 判发布）。 */
+const viewMemo = new WeakMap();
+function makeView(state, l1) {
+    const memoized = viewMemo.get(state);
+    if (memoized !== undefined)
+        return memoized;
+    const recentFirst = [...state.ids].reverse();
+    const picked = recentFirst.slice(0, RECALL_VIEW_CAP);
+    const byId = new Map((l1?.getByIds(picked) ?? []).map((r) => [r.id, r]));
+    const items = [];
+    for (const id of picked) {
+        const r = byId.get(id);
+        if (r === undefined)
+            continue; // 记录已退场/被删：诚实跳过，不编造条目
+        const scenario = Array.isArray(r.metadata?.dsh_usage_scenario)
+            ? r.metadata?.dsh_usage_scenario
+            : undefined;
+        items.push({
+            id: r.id,
+            type: r.type,
+            title: firstLine(r.content),
+            priority: r.priority,
+            ...(scenario !== undefined && scenario.length > 0 ? { scenario } : {}),
+        });
+    }
+    const next = { rev: state.rev, sessionId: state.sessionId, count: state.ids.length, items };
+    viewMemo.set(state, next);
+    return next;
+}
+/** 从宿主 header 取会话 id；形状不符 → 空串（读不到任何桶，view 自然为空，不抛）。 */
+function sessionIdOf(header) {
+    if (typeof header !== 'object' || header === null)
+        return '';
+    const id = header.id;
+    return typeof id === 'string' ? id : '';
+}
+/**
+ * 注册 memoryRecall 投影。
+ *
+ * 缺席降级同 slots 投影：`ctx.inject` 在服务未提供时不回调；形状不符静默不注册。
+ * apply 是 O(1) 判脏（store.revision() 比对），任意已提交事件都会带进来看一眼。
+ */
+export function registerRecallProjection(ctx, store, l1) {
+    ctx.inject(['sessionProjections'], (injected) => {
+        const registry = injected.sessionProjections;
+        if (registry === undefined || typeof registry.register !== 'function')
+            return;
+        // 双代平面（同 slots 投影）：0.1.0-rc.8 的 registry 走平面 schema/view，0.1.1+ 走 wire。
+        const definition = {
+            key: MEMORY_RECALL_KEY,
+            stateSchema,
+            init: (header) => buildState(sessionIdOf(header), store),
+            apply: (state) => buildState(state.sessionId, store, state),
+            wire: { viewSchema, view: (state) => makeView(state, l1) },
+            schema: viewSchema,
+            view: (state) => makeView(state, l1),
+            stateVersion: 0,
+        };
+        registry.register(definition);
+    });
+}

package/dist/projection/slots.d.ts

@@ -1,6 +1,11 @@
 /**
  * 激活槽位服务端投影(memorySlots)。
  *
+ * 展示契约：本 key 由 **dsh-brief-sidebar** 消费（「记忆槽位分区」）。宿主契约说明
+ * 不注册时 key 会从快照消失、客户端读作 capability absence（降级优雅，不致加载失败），
+ * 所以摘注册不会弄坏会话，但会让旧版消费方默默丢分区——要隐藏那张卡请走它的开关。
+ * 另：会话召回的展示走 `memoryRecall` 投影与 client 浮层（SessionRecalledArea），不得灌进本投影。
+ *
  * 只注册服务端单元,绝不做 client——前端展示由未来 brief-sidebar 消费(下一轮)。
  * 注册经 ctx.inject(['sessionProjections'], …):服务缺席时静默不注册、不抛错
  * (注册表里没有 key 时客户端读 faceOf(key) 恒为 undefined,侧边栏栏位自然隐藏)。

package/dist/projection/slots.js

@@ -156,13 +156,20 @@ export function registerSlotsProjection(ctx, store, l1) {
             .sessionProjections;
         if (registry === undefined || typeof registry.register !== 'function')
             return;
-        registry.register({
+        // 双代平面（TL beta.29 同款判别式）：0.1.0-rc.8 的 registry 是唯一的平面契约
+        // （def.schema.parse(def.view(state))），0.1.1+ 消费 wire:{viewSchema,view}。
+        // wire 形状镜像成平面键挂上，两代 registry 各取所需；一个缺 schema 的注册
+        // 单元会毒化旧 registry 的全部冷会话历史加载。
+        const definition = {
             key: MEMORY_SLOTS_KEY,
             stateSchema,
             init: () => buildState(store, l1),
             apply: (state, event) => applySlotsEvent(state, event, store, l1),
             wire: { viewSchema, view },
+            schema: viewSchema,
+            view,
             stateVersion: 0,
-        });
+        };
+        registry.register(definition);
     });
 }

package/dist/prompts/graph-projection.js

@@ -82,6 +82,9 @@ ${GRAPH_NODE_TYPES.join(' | ')}
 
 ${GRAPH_RELATION_WORDS.join('、')}(也可用其他贴切的中文动词短语,≤${GRAPH_CAP.relation} 字)
 
+当记录**显式陈述了因果**时,优先用因果边表达(如「X 导致 Y」「X 修复了 Y」「X 因为 Y」「A 取代 B」),
+这能让前因后果跨记录成链。因果边只写在**记录里有明确依据**的关系上,不做常识推断(见铁律)。
+
 ## 字段上限
 
 - name ≤${GRAPH_CAP.name} 字;aliases ≤${GRAPH_CAP.aliases} 条;tags ≤${GRAPH_CAP.tags} 个