dsh-lite-memory 0.16.4 → 0.18.1

package/test/anchor.test.mjs

@@ -524,3 +524,243 @@ test('R42 栏目只被提到、否定或搁置时都不算用户选中', () => {
   assert.equal(anchor.seriesChosenBy('日志里提到口播吗', '口播'), false);
   assert.equal(anchor.seriesChosenBy('先放着口播，改数据库', '口播'), false);
 });
+
+test('R43 任务类型判断：工程词优先于创作词，纯创作才归 content', () => {
+  assert.equal(anchor.taskKindOf('审阅口播插件的源码，修复上下文串扰问题'), 'code');
+  assert.equal(anchor.taskKindOf('日志里提到口播'), 'code');
+  assert.equal(anchor.taskKindOf('先不做口播，排查 PostgreSQL 连接池故障'), 'code');
+  assert.equal(anchor.taskKindOf('再做一期口播'), 'content');
+  assert.equal(anchor.taskKindOf('改成口播'), 'content');
+  assert.equal(anchor.taskKindOf('帮我看看这个'), '');
+  assert.equal(anchor.taskKindOf(''), '');
+});
+
+test('R44 栏目名后跟代码对象时只算读源码，不算选中栏目', () => {
+  assert.equal(anchor.seriesChosenBy('审阅口播插件的源码，修复上下文串扰问题', '口播'), false);
+  assert.equal(anchor.seriesChosenBy('检查口播插件代码', '口播'), false);
+  assert.equal(anchor.seriesChosenBy('口播源码里日志有问题', '口播'), false);
+  assert.equal(anchor.seriesChosenBy('再做一期口播', '口播'), true);
+  assert.equal(anchor.seriesChosenBy('改成口播', '口播'), true);
+});
+
+test('R45 明确撤销栏目：先不做口播优先于续作和旧栏目', () => {
+  const tasks = activeVideoSession();
+  const next = anchor.routeTask(tasks, {
+    sessionId: 'sess-switch',
+    batchKey: 'rb_revoke',
+    messageIds: ['m2'],
+    query: '先不做口播，排查 PostgreSQL 连接池故障',
+    registeredSeries: ['口播'],
+    now: 2000,
+  });
+  assert.equal(next.decision.kind, 'revoked');
+  assert.deepEqual(next.decision.revoked, ['口播']);
+  assert.equal(next.anchor.status, 'active');
+  assert.equal(next.anchor.seriesId, undefined);
+  assert.equal(next.anchor.taskKind, 'code');
+  assert.equal(next.episode.taskKind, 'code');
+  assert.equal(next.episode.previousEpisodeId, tasks.sessions['sess-switch'].episodeId);
+  assert.equal(anchor.revokeSeriesBy('不要按口播的规矩来', ['口播']).length, 0);
+  assert.deepEqual(anchor.revokeSeriesBy('先不做口播，排查故障', ['口播', 'Vlog']), ['口播']);
+});
+
+test('R46 读源码/提到栏目都不建内容绑定，项目默认值不能趁机补栏目', () => {
+  const tasks = anchor.emptyTasks();
+  tasks.defaults = { taskKind: 'video', seriesId: '口播' };
+  const reading = anchor.routeTask(tasks, {
+    sessionId: 'sess-reading', batchKey: 'rb_reading', messageIds: ['m1'],
+    query: '审阅口播插件的源码，修复上下文串扰问题', registeredSeries: ['口播'], now: 1000,
+  });
+  assert.equal(reading.anchor.seriesId, undefined);
+  assert.equal(reading.episode.taskKind, 'code');
+  assert.notEqual(reading.decision.kind, 'selected');
+  assert.notEqual(reading.decision.kind, 'default');
+
+  const mention = anchor.routeTask(tasks, {
+    sessionId: 'sess-mention', batchKey: 'rb_mention', messageIds: ['m1'],
+    query: '日志里提到口播', registeredSeries: ['口播'], now: 1000,
+  });
+  assert.equal(mention.anchor.seriesId, undefined);
+  assert.equal(mention.anchor.taskKind, 'code');
+});
+
+test('R47 项目默认值只补缺失字段，不覆盖显式任务类型和撤销', () => {
+  const tasks = anchor.emptyTasks();
+  tasks.defaults = { taskKind: 'video', seriesId: '口播' };
+  const filled = anchor.routeTask(tasks, {
+    sessionId: 'sess-default', batchKey: 'rb_default', messageIds: ['m1'],
+    query: '继续改上次那期的开头', registeredSeries: ['口播'], now: 1000,
+  });
+  assert.equal(filled.decision.kind, 'default');
+  assert.equal(filled.anchor.seriesId, '口播');
+  assert.equal(filled.anchor.taskKind, 'video');
+
+  const explicit = anchor.routeTask(tasks, {
+    sessionId: 'sess-explicit-kind', batchKey: 'rb_explicit_kind', messageIds: ['m1'],
+    query: '帮我看看 PostgreSQL 连接池', taskKind: 'code', registeredSeries: ['口播'], now: 1000,
+  });
+  assert.equal(explicit.anchor.taskKind, 'code');
+  assert.equal(explicit.anchor.seriesId, undefined);
+  assert.equal(explicit.decision.taskKind, 'code');
+  assert.notEqual(explicit.decision.kind, 'default');
+});
+
+test('R48 RuntimeContext 形状确定，任务字段来自锚点与本句判断', () => {
+  const routed = anchor.routeTask(anchor.emptyTasks(), {
+    sessionId: 'sess-ctx', batchKey: 'rb_ctx', messageIds: ['m1'],
+    query: '审阅口播插件的源码，修复上下文串扰问题', registeredSeries: ['口播'], now: 1000,
+  });
+  const ctx = anchor.buildRuntimeContext({
+    projectId: '/work/demo', sessionId: 'sess-ctx', batchKey: 'rb_ctx', messageIds: ['m1'],
+    controlEpoch: 7, query: '继续看这段代码', anchor: routed.anchor, episode: routed.episode,
+  });
+  assert.deepEqual(Object.keys(ctx).sort(), ['controlEpoch', 'projectId', 'requestId', 'sessionId', 'task']);
+  assert.deepEqual(Object.keys(ctx.task).sort(), ['action', 'actionEvidence', 'artifactKey', 'conflict', 'evidence', 'kind', 'phase', 'seriesEvidence', 'seriesId', 'topic', 'topicEvidence']);
+  assert.equal(ctx.projectId, '/work/demo');
+  assert.equal(ctx.sessionId, 'sess-ctx');
+  assert.equal(ctx.requestId, anchor.contextIdFor('/work/demo', 'rb_ctx', routed.episode.episodeId));
+  assert.equal(ctx.controlEpoch, '7');
+  assert.equal(ctx.task.kind, 'code');
+  assert.equal(ctx.task.seriesId, '');
+  assert.equal(ctx.task.phase, 'brief');
+  assert.equal(ctx.task.evidence, 'query');
+
+  const inferred = anchor.buildRuntimeContext({
+    projectId: '/work/demo', sessionId: 'sess-ctx', batchKey: 'rb_ctx', messageIds: ['m1'],
+    query: '审阅口播插件的源码',
+  });
+  assert.equal(inferred.task.kind, 'code');
+  assert.equal(inferred.task.evidence, 'query');
+});
+
+test('R49 动作/交付物/话题分开：代码 bug 不把「口播」绑成栏目', () => {
+  const query = '口播功能最近有 bug，请修复代码';
+  const facets = anchor.taskFacetsOf(query);
+  assert.equal(facets.action.kind, 'fix');
+  assert.equal(facets.deliverable.kind, 'code');
+  assert.equal(facets.topic.text, '口播功能');
+  assert.equal(facets.topic.evidence, 'inferred');
+  assert.equal(anchor.seriesChosenBy(query, '口播'), false);
+  assert.deepEqual(anchor.revokeSeriesBy(query, ['口播']), []);
+
+  const routed = anchor.routeTask(anchor.emptyTasks(), {
+    sessionId: 'sess-boundary-fix', batchKey: 'rb_boundary_fix', messageIds: ['m1'],
+    query, registeredSeries: ['口播'], now: 1000,
+  });
+  assert.notEqual(routed.decision.kind, 'selected');
+  assert.equal(routed.episode.taskKind, 'code');
+  assert.equal(routed.episode.kindEvidence, 'query');
+  assert.equal(routed.anchor.seriesId, undefined);
+  assert.equal(routed.episode.actionKind, 'fix');
+
+  const ctx = anchor.buildRuntimeContext({
+    projectId: '/work/demo', sessionId: 'sess-boundary-fix', batchKey: 'rb_boundary_fix',
+    messageIds: ['m1'], query: '继续修', anchor: routed.anchor, episode: routed.episode,
+  });
+  assert.equal(ctx.task.kind, 'code');
+  assert.equal(ctx.task.evidence, 'query');
+  assert.equal(ctx.task.seriesId, '');
+  assert.equal(ctx.task.action, 'fix');
+});
+
+test('R50 内容任务：数据库事务只是话题，口播才是交付栏目', () => {
+  const query = '做一期口播，讲解数据库事务，给普通观众听';
+  const facets = anchor.taskFacetsOf(query);
+  assert.equal(facets.action.kind, 'create');
+  assert.equal(facets.deliverable.kind, 'content');
+  assert.equal(facets.topic.text, '数据库事务');
+  assert.equal(facets.topic.evidence, 'query');
+  assert.equal(facets.conflict, false);
+  assert.equal(anchor.taskKindOf(query), 'content');
+  assert.equal(anchor.seriesChosenBy(query, '口播'), true);
+  assert.equal(anchor.seriesChosenBy(query, '数据库'), false);
+  assert.equal(anchor.seriesChosenBy(query, '数据库事务'), false);
+
+  const routed = anchor.routeTask(anchor.emptyTasks(), {
+    sessionId: 'sess-boundary-content', batchKey: 'rb_boundary_content', messageIds: ['m1'],
+    query, registeredSeries: ['口播', '数据库', '数据库事务'], now: 1000,
+  });
+  assert.equal(routed.decision.kind, 'selected');
+  assert.equal(routed.anchor.seriesId, '口播');
+  assert.equal(routed.anchor.taskKind, 'content');
+  assert.equal(routed.episode.kindEvidence, 'query');
+  assert.equal(routed.episode.seriesEvidence, 'query');
+  assert.equal(routed.episode.topicText, '数据库事务');
+  assert.equal(routed.episode.topicEvidence, 'query');
+
+  /** 落过一次盘之后，query 推断仍不能自升成用户确认。 */
+  const ctx = anchor.buildRuntimeContext({
+    projectId: '/work/demo', sessionId: 'sess-boundary-content', batchKey: 'rb_boundary_content',
+    messageIds: ['m1'], query: '继续', anchor: routed.anchor, episode: routed.episode,
+  });
+  assert.equal(ctx.task.kind, 'content');
+  assert.equal(ctx.task.evidence, 'query');
+  assert.equal(ctx.task.seriesEvidence, 'query');
+  assert.equal(ctx.task.topic, '数据库事务');
+  assert.equal(ctx.task.topicEvidence, 'query');
+});
+
+test('R51 句末语气词不是撤销；只有明确的停止动作才撤销栏目', () => {
+  const query = '做一期口播吧';
+  assert.deepEqual(anchor.revokeSeriesBy(query, ['口播']), []);
+  assert.equal(anchor.seriesChosenBy(query, '口播'), true);
+  assert.equal(anchor.taskKindOf(query), 'content');
+
+  const routed = anchor.routeTask(anchor.emptyTasks(), {
+    sessionId: 'sess-boundary-particle', batchKey: 'rb_boundary_particle', messageIds: ['m1'],
+    query, registeredSeries: ['口播'], now: 1000,
+  });
+  assert.equal(routed.decision.kind, 'selected');
+  assert.equal(routed.anchor.seriesId, '口播');
+  assert.equal(routed.anchor.taskKind, 'content');
+  assert.equal(routed.episode.kindEvidence, 'query');
+
+  for (const soft of ['做一期口播吧', '做一期口播啦', '做一期口播了', '做一期口播吧！']) {
+    assert.deepEqual(anchor.revokeSeriesBy(soft, ['口播']), [], soft);
+  }
+  for (const hard of ['先不做口播了', '口播不做了', '暂停口播', '放一边口播', '口播先不做']) {
+    assert.deepEqual(anchor.revokeSeriesBy(hard, ['口播']), ['口播'], hard);
+  }
+});
+
+test('R52 中英文标点与同义词：代码对象、话题前缀、内容用法都按同一规则', () => {
+  for (const query of [
+    '口播功能最近有 bug, 请修复代码.',
+    '口播模块报错，帮我排查',
+    '口播页面有个故障！',
+    '口播组件接口流程逻辑都改一下',
+  ]) {
+    assert.equal(anchor.seriesChosenBy(query, '口播'), false, query);
+    assert.equal(anchor.taskKindOf(query), 'code', query);
+  }
+  for (const soft of ['做一期口播吧!', '做一期口播啦。', '做一期口播了？']) {
+    assert.equal(anchor.seriesChosenBy(soft, '口播'), true, soft);
+    assert.equal(anchor.taskKindOf(soft), 'content', soft);
+  }
+  /** 「做一期口播功能」是内容用法，不能因为「功能」就否掉栏目。 */
+  assert.equal(anchor.seriesChosenBy('做一期口播功能', '口播'), true);
+  assert.equal(anchor.taskKindOf('做一期口播功能'), 'content');
+
+  for (const query of ['做一期口播, 讲解数据库事务, 给普通观众听.', '做一期口播；介绍数据库事务；给普通观众听']) {
+    assert.equal(anchor.taskKindOf(query), 'content', query);
+    assert.equal(anchor.seriesChosenBy(query, '口播'), true, query);
+    assert.equal(anchor.seriesChosenBy(query, '数据库'), false, query);
+  }
+  for (const query of ['聊聊数据库事务', '主题是数据库事务', '围绕数据库事务讲讲']) {
+    assert.equal(anchor.seriesChosenBy(query, '数据库'), false, query);
+    assert.equal(anchor.seriesChosenBy(query, '数据库事务'), false, query);
+  }
+
+  const conflict = anchor.taskFacetsOf('日志里提到口播，顺便讲数据库事务');
+  assert.equal(conflict.conflict, true);
+  const routed = anchor.routeTask(anchor.emptyTasks(), {
+    sessionId: 'sess-boundary-conflict', batchKey: 'rb_boundary_conflict', messageIds: ['m1'],
+    query: '日志里提到口播，顺便讲数据库事务', registeredSeries: ['口播'], now: 1000,
+  });
+  assert.notEqual(routed.anchor.seriesId, '口播');
+  const ctx = anchor.buildRuntimeContext({
+    projectId: '/work/demo', sessionId: 'sess-boundary-conflict', batchKey: 'rb_boundary_conflict',
+    messageIds: ['m1'], query: '日志里提到口播，顺便讲数据库事务', anchor: routed.anchor, episode: routed.episode,
+  });
+  assert.equal(ctx.task.conflict, true);
+});

package/test/client.test.mjs

@@ -2,7 +2,8 @@ import assert from 'node:assert/strict';
 
 let seen = null;
 let plugin = null;
-const fakeReact = { createElement: () => null, useRef: (value) => ({ current: value }), useState: (value) => [value, () => {}], useEffect: () => {}, useMemo: (fn) => fn() };
+const makeNode = (type, props, ...children) => ({ type, props: props || {}, children: children.flat(Infinity) });
+const fakeReact = { createElement: makeNode, useRef: (value) => ({ current: value }), useState: (value) => [value, () => {}], useEffect: () => {}, useMemo: (fn) => fn() };
 globalThis.window = { __ModuleLoader__: { load: (definition) => { plugin = definition.factory((name) => (name === 'react' ? fakeReact : null)); } } };
 globalThis.__LITE_MEMORY_TEST__ = (helpers) => { seen = helpers; };
 await import('../client.js');
@@ -26,7 +27,8 @@ assert.ok(panel, '记忆面板没有注册');
 assert.equal(panel.name, 'shell.overlay');
 assert.equal(panel.order, 30);
 
-const { metaOf, citationOf, citationsOfMeta, citationsOfTurn, dedupe, undoRefOf, graphOf, ruleGraphOf } = seen;
+const EMPTY_CHILDREN = [];
+const { metaOf, citationOf, citationsOfMeta, citationsOfTurn, dedupe, undoRefOf, graphOf, ruleGraphOf, processingStatusOf, currentBodyOf, historyDiffsOf, MemoryPanel, MemoryGraph, displayKeyOf, readDisplaySettings, writeDisplaySettings, graphViewOf, viewModeOf, filterRecords, projectionOf, failureStateOf, evidenceTextOf, evidenceMetaOf, MemoryPalace, palaceRoomsOf, palaceRoomPageOf, palacePageWindow, palaceToggleOf, palaceMotionOf, palaceRoomIdOf, TurnMemory, refMetaOf, explainKeyOf, explainModeOf, setExplainMode, agoLabel, checkupOf, titleCountsOf } = seen;
 
 // 图谱只按真实数据画：共享标签成枢纽，显式关联成边，位置由 id 决定。
 const graph = graphOf([
@@ -36,15 +38,38 @@ const graph = graphOf([
 ]);
 assert.equal(graph.nodes.filter((node) => node.kind === 'memory').length, 3);
 assert.equal(graph.nodes.some((node) => node.id === 'tag:发布'), true);
-assert.equal(graph.nodes.some((node) => node.id === 'tag:环境'), true);
-assert.equal(graph.nodes.some((node) => node.id === 'topic:上线'), true);
-assert.equal(graph.edges.filter((edge) => edge.type === 'tag').length, 3);
+assert.equal(graph.nodes.some((node) => node.id === 'tag:环境'), false);
+assert.equal(graph.nodes.some((node) => node.id === 'topic:上线'), false);
+assert.equal(graph.edges.filter((edge) => edge.type === 'tag').length, 2);
 assert.equal(graph.edges.filter((edge) => edge.type === 'link').length, 1);
 assert.deepEqual(graphOf([{ id: 'mem_aaaaaaaa', title: 'A' }]).nodes[0].x, graphOf([{ id: 'mem_aaaaaaaa', title: 'A' }]).nodes[0].x);
 const pair = graphOf([{ id: 'mem_aaaaaaaa', title: 'A' }, { id: 'mem_bbbbbbbb', title: 'B' }]);
 assert.notEqual(pair.nodes[0].x, pair.nodes[1].x);
 assert.notEqual(pair.nodes[0].y, pair.nodes[1].y);
 
+// 共享标签是组：枢纽点比成员大，成员围着它，孤立记忆留在外圈；被更强组吸收的次要标签不另画。
+const hubNode = graph.nodes.find((node) => node.id === 'tag:发布');
+const memberA = graph.nodes.find((node) => node.id === 'mem_aaaaaaaa');
+const memberC = graph.nodes.find((node) => node.id === 'mem_cccccccc');
+assert.ok(hubNode && memberA && memberC);
+assert.ok(hubNode.radius > memberA.radius + 4, '共享标签枢纽应比成员大');
+assert.ok(Math.hypot(memberA.x - hubNode.x, memberA.y - hubNode.y) < 90, '成员应靠近所属枢纽');
+assert.ok(Math.hypot(memberC.x - hubNode.x, memberC.y - hubNode.y) > 90, '无共享标签的记忆应留在外圈');
+
+// 一条记忆只连自己所属组的枢纽：别的共享标签不画跨组虚线。
+const overlap = graphOf([
+  { id: 'mem_dddddddd', title: 'D', tags: ['X', 'Y'] },
+  { id: 'mem_eeeeeeee', title: 'E', tags: ['X', 'Y'] },
+  { id: 'mem_ffffffff', title: 'F', tags: ['X'] },
+  { id: 'mem_gggggggg', title: 'G', tags: ['Y'] },
+  { id: 'mem_hhhhhhhh', title: 'H', tags: ['Y'] },
+  { id: 'mem_iiiiiiii', title: 'I', tags: ['X'] },
+]);
+const overlapTags = overlap.edges.filter((edge) => edge.type === 'tag').map((edge) => `${edge.from}>${edge.to}`);
+assert.equal(overlapTags.length, 6);
+assert.equal(overlapTags.includes('mem_dddddddd>tag:Y'), false);
+assert.equal(overlapTags.includes('mem_eeeeeeee>tag:Y'), false);
+
 // 经验图谱只按共享的适用条件相连，不画没有依据的关系。
 const rules = [
   { id: 'ev_aaaaaaaa', title: 'A', state: 'active', conditions: [{ key: 'seriesId', value: '口播' }] },
@@ -111,4 +136,189 @@ assert.equal(turn[1].id, 'mem_bbbbbbbb');
 // 旧行没有元数据：什么也不产出，绝不从文案猜 id。
 assert.deepEqual(citationsOfTurn([{ root: null }, { root: { kind: 'tool-result', content: [{ type: 'text', text: 'memory · saved "A" mem_aaaaaaaa' }] } }]), []);
 
-console.log('client.test.mjs: 11 passed');
+// 处理状态只认服务端枚举；中文 reason 不参与猜测。
+assert.equal(processingStatusOf({ processingStatus: 'applied' }), 'applied');
+assert.equal(processingStatusOf({ outcome: { status: 'superseded' } }), 'superseded');
+assert.equal(processingStatusOf({ status: 'failed' }), 'failed');
+assert.equal(processingStatusOf({ status: 'ok', reason: '处理失败' }), '');
+assert.equal(processingStatusOf({ reason: '已应用' }), '');
+
+// 当前正文与历史版本分开：历史行只给 old → new，不拼进当前正文。
+const memoryPayload = {
+  currentBody: '新的正文',
+  versions: [
+    { revision: 1, body: '旧的正文', at: '2026-01-01' },
+    { revision: 2, body: '中间正文', at: '2026-02-01' },
+  ],
+};
+assert.equal(currentBodyOf(memoryPayload), '新的正文');
+const diffs = historyDiffsOf(memoryPayload);
+assert.equal(diffs.length, 2);
+assert.equal(diffs[0].old, '旧的正文');
+assert.equal(diffs[0].next, '中间正文');
+assert.equal(diffs[1].next, '新的正文');
+assert.equal(currentBodyOf({ record: { current: { body: '记录正文' }, body: '旧字段' } }), '记录正文');
+assert.deepEqual(historyDiffsOf({ body: '单版本' }), []);
+
+// 图谱截断时保留真实总数，60 是绘制上限而不是总数。
+const many = Array.from({ length: 65 }, (_, index) => ({ id: `mem_${String(index).padStart(8, '0')}`, title: `T${index}` }));
+const big = graphOf(many);
+assert.equal(big.shown, 60);
+assert.equal(big.total, 65);
+assert.equal(big.nodes.filter((node) => node.kind === 'memory').length, 60);
+assert.equal(ruleGraphOf(Array.from({ length: 65 }, (_, index) => ({ id: `ev_${String(index).padStart(8, '0')}`, title: `R${index}`, conditions: [] }))).total, 65);
+
+// 显示设置只决定画不画；按项目 key 分开存，默认都关。
+const memoryStore = new Map();
+globalThis.localStorage = { getItem: (key) => (memoryStore.has(key) ? memoryStore.get(key) : null), setItem: (key, value) => memoryStore.set(key, String(value)) };
+assert.equal(displayKeyOf('project:/a'), 'lite-memory:display:project:/a');
+assert.notEqual(displayKeyOf('project:/a'), displayKeyOf('project:/b'));
+assert.deepEqual(readDisplaySettings('project:/a'), { graph: false, palace: false });
+writeDisplaySettings('project:/a', { graph: true, palace: false });
+assert.deepEqual(readDisplaySettings('project:/a'), { graph: true, palace: false });
+assert.deepEqual(readDisplaySettings('project:/b'), { graph: false, palace: false });
+memoryStore.set(displayKeyOf('project:/c'), '{oops');
+assert.deepEqual(readDisplaySettings('project:/c'), { graph: false, palace: false });
+assert.equal(graphViewOf(false, 'graph'), 'list');
+assert.equal(graphViewOf(true, 'graph'), 'graph');
+assert.equal(graphViewOf(undefined, 'graph'), 'list');
+
+// 点标签/主题按精确值筛，不把「发布」发散成「发布会」。
+const tagged = [
+  { id: 'mem_aaaaaaaa', title: '发布记录', tags: ['发布'], topicKey: '上线' },
+  { id: 'mem_bbbbbbbb', title: '发布会记录', tags: ['发布会'], topicKey: '上线复盘' },
+];
+assert.deepEqual(filterRecords(tagged, '', { kind: 'tag', value: '发布' }).map((row) => row.id), ['mem_aaaaaaaa']);
+assert.deepEqual(filterRecords(tagged, '', { kind: 'topic', value: '上线' }).map((row) => row.id), ['mem_aaaaaaaa']);
+assert.deepEqual(filterRecords(tagged, '发布会', null).map((row) => row.id), ['mem_bbbbbbbb']);
+
+// 60 条投影外也要保住当前选中项，不能点开就消失。
+const long = Array.from({ length: 65 }, (_, index) => ({ id: `mem_${String(index).padStart(8, '0')}`, title: `T${index}` }));
+const kept = projectionOf(long, long[64].id);
+assert.equal(kept.length, 60);
+assert.equal(kept[59].id, long[64].id);
+assert.equal(graphOf(long, long[64].id).nodes.some((node) => node.id === long[64].id), true);
+assert.equal(graphOf(long).nodes.some((node) => node.id === long[64].id), false);
+
+// 失败分当前和过去：只有最近一次失败才提示现有经验没更新。
+assert.equal(failureStateOf({ economy: { recent: [{ status: 'failed' }, { status: 'applied' }] } }), 'current');
+assert.equal(failureStateOf({ economy: { recent: [{ status: 'applied' }, { status: 'failed' }] } }), 'past');
+assert.equal(failureStateOf({ economy: { recent: [{ status: 'applied' }] } }), '');
+assert.equal(failureStateOf(null), '');
+
+// 学习依据读真实摘录与样例元数据，不再拿「样例」占位。
+assert.equal(evidenceTextOf({ sourceExcerpt: '用户说别用渐变' }), '用户说别用渐变');
+assert.equal(evidenceTextOf({ excerpt: '原文' }), '原文');
+assert.equal(evidenceTextOf({ note: '备注' }), '备注');
+assert.equal(evidenceTextOf({ feedbackType: 'negative' }), '');
+assert.equal(evidenceMetaOf({ artifactVersion: 2, dimension: '排版', verified: true, at: '2026-03-04T00:00:00Z' }), '第 2 版 · 排版 · 已核对 · 2026-03-04');
+assert.equal(evidenceMetaOf({ verified: false }), '未核对');
+
+// 显示设置默认关闭：面板首帧只出列表，不挂载图谱组件。
+const nodeTypes = (node, out = []) => {
+  if (!node || typeof node !== 'object') return out;
+  if (node.type) out.push(node.type);
+  for (const child of node.children || EMPTY_CHILDREN) nodeTypes(child, out);
+  return out;
+};
+const firstPaint = MemoryPanel({ sessionId: 'demo', onClose: () => {} });
+assert.ok(firstPaint, '面板首帧应渲染');
+assert.equal(nodeTypes(firstPaint).includes(MemoryGraph), false);
+assert.equal(JSON.stringify(nodeTypes(firstPaint)).includes('MemoryGraph'), false);
+assert.equal(nodeTypes(firstPaint).includes(MemoryPalace), false);
+assert.equal(JSON.stringify(nodeTypes(firstPaint)).includes('MemoryPalace'), false);
+
+
+// 记忆宫殿：固定四间，空房保留位置，未知类型有归处。
+const palaceRecord = (id, kind, title = id) => ({ id, kind, title });
+const palaceRooms = palaceRoomsOf([
+  palaceRecord('mem_1', 'note'), palaceRecord('mem_2', 'pointer'), palaceRecord('mem_3', 'procedure'),
+  palaceRecord('mem_4', 'preference'), palaceRecord('mem_5', 'convention'), palaceRecord('mem_6', 'pitfall'),
+  palaceRecord('mem_7', 'credential_hint'), palaceRecord('mem_8', 'unknown_kind'),
+]);
+assert.deepEqual(palaceRooms.map((room) => room.name), ['习惯与规范', '方法与经验', '资料与入口', '其他记录']);
+assert.deepEqual(palaceRooms.map((room) => room.total), [2, 2, 2, 2]);
+assert.equal(palaceRoomIdOf('unknown_kind'), 'notes');
+assert.deepEqual(palaceRoomsOf([palaceRecord('mem_9', 'note')]).map((room) => room.total), [0, 0, 0, 1]);
+assert.equal(palaceRoomsOf([]).length, 4);
+// 每页 24 条；页码夹在有效范围内。
+const palaceMany = Array.from({ length: 25 }, (_, index) => palaceRecord(`mem_${index}`, 'preference', `P${index}`));
+assert.equal(palaceRoomsOf(palaceMany)[0].pages, 2);
+assert.equal(palaceRoomPageOf(palaceMany, 'habits', 1).items.length, 24);
+assert.equal(palaceRoomPageOf(palaceMany, 'habits', 2).items.length, 1);
+assert.equal(palaceRoomPageOf(palaceMany, 'habits', 99).page, 2);
+assert.equal(palaceRoomPageOf(palaceMany, 'habits', 0).page, 1);
+assert.deepEqual(palacePageWindow(1, 3), [1, 2, 3]);
+assert.deepEqual(palacePageWindow(5, 12), [2, 3, 4, 5, 6, 7, 8]);
+assert.equal(palacePageWindow(12, 12).includes(12), true);
+// 同一时刻只展开一间，再点收起。
+assert.equal(palaceToggleOf('', 'methods'), 'methods');
+assert.equal(palaceToggleOf('methods', 'methods'), '');
+assert.equal(palaceToggleOf('methods', 'habits'), 'habits');
+// 关闭时回列表；减少动态时 0ms，否则 180ms。
+assert.equal(viewModeOf({ graph: true, palace: false }, 'palace'), 'list');
+assert.equal(viewModeOf({ graph: false, palace: true }, 'palace'), 'palace');
+assert.equal(palaceMotionOf(true).duration, 0);
+assert.equal(palaceMotionOf(false).duration, 180);
+// 展品点开只把 id 交给现有详情入口，不另造详情。
+let palacePicked = '';
+const palaceTree = MemoryPalace({
+  records: [palaceRecord('mem_a', 'preference', 'A')],
+  selectedId: '', onPick: (id) => { palacePicked = id; }, emptyText: '这个项目还没有记忆',
+});
+const expandNodes = (node, out = []) => {
+  if (!node || typeof node !== 'object') return out;
+  if (typeof node.type === 'function') return expandNodes(node.type(node.props), out);
+  out.push(node);
+  for (const child of node.children || []) expandNodes(child, out);
+  return out;
+};
+const palaceExhibit = expandNodes(palaceTree).find((node) => node.type === 'button' && node.props.title === 'A');
+assert.ok(palaceExhibit, '展品应是原生按钮');
+palaceExhibit.props.onClick();
+assert.equal(palacePicked, 'mem_a');
+const palaceEmpty = MemoryPalace({ records: [], selectedId: '', onPick: () => {}, emptyText: '这个项目还没有记忆' });
+assert.equal(expandNodes(palaceEmpty).some((node) => node.children.includes('这个项目还没有记忆')), true);
+
+// 每条引用带类型：搜索命中用条目的 kind，读过正文用 recordKind；缺了就只写范围与来源。
+const typedSearch = citationOf({ id: 'mem_aaaaaaaa', title: 'A', scope: 'global', revision: 1, status: 'ok', kind: 'preference' }, 'memory-search');
+assert.equal(typedSearch.entryKind, 'preference');
+assert.equal(refMetaOf(typedSearch), '偏好 · 全局 · 你记的');
+assert.equal(citationOf({ kind: 'memory-read', id: 'mem_bbbbbbbb', recordKind: 'procedure', scope: 'project', revision: 2 }, 'memory-read').entryKind, 'procedure');
+assert.equal(refMetaOf({ scope: 'project', origin: 'user_explicit' }), '项目 · 你记的');
+/** 检索引用也要带类型与更新距今，缺时间时退回两项。 */
+const aged = citationOf({ kind: 'preference', id: 'mem_cccccccc', scope: 'global', revision: 1, updated: new Date(Date.now() - 3 * 86_400_000).toISOString() }, 'memory-search');
+assert.equal(aged.entryKind, 'preference');
+assert.equal(refMetaOf(aged), '偏好 · 全局 · 你记的 · 3 天前更新');
+assert.equal(agoLabel(''), '');
+assert.equal(agoLabel(new Date(Date.now() - 40 * 86_400_000).toISOString()), '');
+
+// 解释模式按会话存在本机，缺省关闭；关着零命中不出提示，打开后才说原因。
+assert.equal(explainModeOf('s1'), false);
+const quietRefs = [];
+Object.defineProperty(quietRefs, 'noTriggerReason', { value: '当前任务不适用', enumerable: false, configurable: true });
+assert.equal(TurnMemory({ sessionId: 's1', turn: '7', useRefs: () => quietRefs }), null);
+setExplainMode('s1', true);
+assert.equal(explainModeOf('s1'), true);
+assert.equal(explainModeOf('s2'), false);
+const told = TurnMemory({ sessionId: 's1', turn: '7', useRefs: () => quietRefs });
+assert.ok(told);
+assert.equal(JSON.stringify(told).includes('当前任务不适用'), true);
+assert.equal(explainKeyOf('s1').startsWith('lite-memory:explain:'), true);
+
+
+const checkupRows = [
+  { id: 'mem_c0000001', title: '同一件事', when: '', lastUsed: '' },
+  { id: 'mem_c0000002', title: '同一件事', when: '当 A 时', lastUsed: '2026-01-01T00:00:00.000Z' },
+  { id: 'mem_c0000003', title: '另一件', when: '当 B 时', lastUsed: '2026-01-01T00:00:00.000Z' },
+];
+const checkupScopes = [{ key: 'p', kind: 'project', entries: 3 }, { key: 'global', kind: 'global', entries: 213 }];
+assert.deepEqual(checkupOf(checkupRows, checkupScopes, false), { duplicate: 1, unread: 1, globalEntries: 213, globalMissingWhen: null });
+assert.deepEqual(checkupOf(checkupRows, checkupScopes, true), { duplicate: 1, unread: 1, globalEntries: 213, globalMissingWhen: 1 });
+assert.deepEqual(filterRecords(checkupRows, '', { kind: 'duplicate' }).map((row) => row.id), ['mem_c0000001', 'mem_c0000002']);
+assert.deepEqual(filterRecords(checkupRows, '', { kind: 'unread' }).map((row) => row.id), ['mem_c0000001']);
+assert.deepEqual(filterRecords(checkupRows, '', { kind: 'noWhen' }).map((row) => row.id), ['mem_c0000001']);
+assert.deepEqual([...titleCountsOf(checkupRows).values()], [2, 1]);
+assert.equal(checkupOf([], [], false).globalEntries, null);
+console.log('client.test.mjs: 21 passed + palace');
+

package/test/contract.test.mjs

@@ -87,6 +87,8 @@ assert.equal(JSON.stringify(saveParams.applicability.enum), JSON.stringify(['all
 assert.deepEqual(saveParams.resolution.enum, ['distinct']);
 /** 一次检索最多回 4 条：列表是给下一步取正文用的，不是索引。 */
 assert.equal(defs.get('memory_search').parameters.properties.limit.maximum, 4);
+/** 空检索结果会带 noTriggerReason，输出 schema 必须声明它，否则宿主校验直接报错。 */
+assert.equal(defs.get('memory_search').output.schema.properties.noTriggerReason.type, 'string');
 assert.equal(saveParams.id.type, 'string');
 assert.deepEqual(saveParams.scope.enum, ['auto', 'project', 'global']);
 assert.equal(saveParams.memoryClass.type, 'string');
@@ -108,13 +110,13 @@ assert.equal(phrased.scope, 'project');
 assert.equal(store.loadIndex(store.globalScope()).entries.some((item) => item.title === '以后都用这个一次性脚本'), false);
 
 assert.equal(typeof saved.id, 'string');
-assert.match(render('memory_save', {}, saved), /^memory · saved \[[^\]]+\] "发布顺序" · mem_[a-z0-9]+$/);
+assert.match(render('memory_save', {}, saved), /^memory · saved \[[^\]]+\] "发布顺序"$/);
 
 const merged = await exec('memory_save', { title: '发布顺序', summary: '发版前要按顺序做的事', body: '第一步\n第二步' });
 assert.equal(merged.merged, true);
 assert.equal(merged.id, saved.id);
 assert.equal(merged.revision, 2);
-assert.match(render('memory_save', {}, merged), /^memory · merged \[[^\]]+\] "发布顺序" · mem_[a-z0-9]+$/);
+assert.match(render('memory_save', {}, merged), /^memory · merged \[[^\]]+\] "发布顺序"$/);
 
 const patch = await exec('memory_save', { id: saved.id, title: '发布顺序', summary: '发版前要按顺序做的事', when: '发版当天' });
 assert.equal(patch.when, '发版当天');
@@ -125,7 +127,7 @@ const again = await exec('memory_save', { title: '发布顺序', summary: '发
 assert.equal(again.changed, false);
 assert.equal(again.id, saved.id);
 assert.equal(again.revision, 3);
-assert.match(render('memory_save', {}, again), /^memory · unchanged \[[^\]]+\] "发布顺序" · mem_[a-z0-9]+$/);
+assert.match(render('memory_save', {}, again), /^memory · unchanged \[[^\]]+\] "发布顺序"$/);
 
 // ── similar title asks before overwriting ────────────────────────────────────
 const probe = await exec('memory_save', { title: '发布顺序是啥', summary: '发版前要按顺序做的事', body: '另一条' });
@@ -152,6 +154,7 @@ assert.doesNotMatch(hitText, /第 .* 版/);
 /** 「发版当天」这类自由文本条件没有可信上下文，不能当成适用条目塞给模型。 */
 const miss = await exec('memory_search', { query: '完全没有出现过的主题' });
 assert.equal(miss.count, 0);
+assert.equal(typeof miss.noTriggerReason, 'string');
 assert.equal(render('memory_search', {}, miss), 'memory · 没有命中');
 
 const read = await exec('memory_read', { id: saved.id });
@@ -160,23 +163,24 @@ assert.equal(read.body, '');
 const plain = await exec('memory_read', { id: distinct.id });
 assert.equal(plain.body, '另一条');
 assert.equal(plain.revision, 1);
-assert.match(render('memory_read', {}, plain), new RegExp(`^memory · \\[[^\\]]+\\] 「发布顺序是啥」 · ${distinct.id}`));
+assert.match(render('memory_read', {}, plain), /^memory · \[[^\]]+\] 「发布顺序是啥」/);
+assert.ok(!render('memory_read', {}, plain).includes(distinct.id));
 
 // 没点明归档还是彻底忘掉时不动盘，先返回待确认
 const undecided = await exec('memory_forget', { id: distinct.id });
 assert.equal(undecided.mode, 'needs_resolution');
-assert.match(render('memory_forget', {}, undecided), new RegExp(`^memory · 先确认是归档还是彻底忘掉 · ${distinct.id}$`));
+assert.match(render('memory_forget', {}, undecided), /^memory · 先确认是归档还是彻底忘掉 · 「发布顺序是啥」$/);
 assert.ok(store.locate(store.scopeOf(cwd), distinct.id));
 const archived = await exec('memory_forget', { id: distinct.id, mode: 'archive' });
 assert.equal(archived.id, distinct.id);
-assert.match(render('memory_forget', {}, archived), new RegExp(`^memory · archived \\[[^\\]]+\\] "发布顺序是啥" · ${distinct.id}，可找回$`));
+assert.match(render('memory_forget', {}, archived), /^memory · archived \[[^\]]+\] "发布顺序是啥"，可找回$/);
 assert.equal(await exec('memory_save', { title: '发布顺序是啥', summary: '发版前要按顺序做的事', body: '第三条' }).then((v) => v.merged), false);
 
 // ── suggestion → keep → replay → reject ──────────────────────────────────────
 const suggested = await exec('memory_suggest', { title: '发布前跑文案检查', summary: '发版前先跑 ui 文案 lint', body: 'node ui-copy-lint.mjs', when: '发布前' });
 assert.equal(suggested.asked, true);
 assert.match(suggested.id, /^sug_[a-z0-9]+$/);
-assert.match(render('memory_suggest', {}, suggested), /^memory · suggested "发布前跑文案检查" · sug_[a-z0-9]+$/);
+assert.match(render('memory_suggest', {}, suggested), /^memory · suggested "发布前跑文案检查"$/);
 
 const duplicate = await exec('memory_suggest', { title: '发布前跑文案检查', summary: '发版前先跑 ui 文案 lint' });
 assert.equal(duplicate.asked, false);
@@ -231,7 +235,7 @@ assert.equal((await call('/lite-memory/keep', {}, { method: 'GET' })).status, 40
 // ── global layer ─────────────────────────────────────────────────────────────
 const global = await exec('memory_save', { title: '回复用中文', summary: '用户要求回复用中文', scope: 'global' });
 assert.equal(global.scope, 'global');
-assert.match(render('memory_save', {}, global), /^memory · saved \[global\] "回复用中文" · mem_[a-z0-9]+$/);
+assert.match(render('memory_save', {}, global), /^memory · saved \[global\] "回复用中文"$/);
 const globalSearch = await exec('memory_search', { query: '回复用中文' });
 assert.equal(globalSearch.count, 1);
 assert.match(render('memory_search', {}, globalSearch), /\[global\] mem_/);
@@ -519,17 +523,24 @@ assert.equal(reopenedSnapshot.body.rules.length, 1);
 const metaOf = (name, args, value) => defs.get(name).output.presentationMeta(args, value);
 const savedMeta = metaOf('memory_save', {}, saved);
 assert.equal(savedMeta.kind, 'memory-save');
+assert.equal(savedMeta.recordKind, saved.kind);
 assert.equal(savedMeta.id, saved.id);
 assert.equal(savedMeta.title, '发布顺序');
 assert.equal(savedMeta.changed, true);
 assert.ok(['created', 'updated'].includes(savedMeta.mode));
 assert.equal('path' in savedMeta, false);
 const searchMeta = metaOf('memory_search', {}, globalSearch);
-assert.deepEqual(Object.keys(searchMeta.refs[0]).sort(), ['id', 'origin', 'revision', 'scope', 'status', 'title']);
+assert.deepEqual(Object.keys(searchMeta.refs[0]).sort(), ['id', 'kind', 'origin', 'revision', 'scope', 'status', 'title', 'updated', 'when']);
 assert.equal(searchMeta.refs[0].id, global.id);
+/** 引用要能区分偏好/约定/流程/资料，界面才不必猜标题文案。 */
+assert.equal(searchMeta.refs[0].kind, store.loadIndex(store.globalScope()).entries.find((item) => item.id === global.id).kind);
+assert.equal(searchMeta.refs[0].when, '');
+/** 出处行要说「N 天前更新」，只给时间不进正文。 */
+assert.equal(typeof searchMeta.refs[0].updated, 'string');
 const readValue = await exec('memory_read', { id: global.id });
 const readMeta = metaOf('memory_read', {}, readValue);
 assert.equal(readMeta.kind, 'memory-read');
+assert.equal(readMeta.recordKind, readValue.kind);
 assert.equal(readMeta.title, '回复用中文');
 assert.equal(readMeta.revision, 1);
 const suggestValue = await exec('memory_suggest', { title: '元数据建议', summary: '建议行只认元数据里的候选 id' });

package/test/crossing.test.mjs

@@ -10,7 +10,7 @@ const view = await import('../view.js');
 
 const {
   saveEntry, routeScope, visibleRules, move, resumeMove, movePending,
-  upsert, forget, readLinks, loadIndex, scopeOf, globalScope, readEntry,
+  upsert, forget, readLinks, loadIndex, scopeOf, globalScope, readEntry, pendingConflictsOf,
 } = store;
 
 let passed = 0;
@@ -369,4 +369,25 @@ await test('L06 展示视图不把关联结构塞给模型', () => {
 });
 
 for (const dir of dirs) fs.rmSync(dir, { recursive: true, force: true });
+
+// ── S12 冲突队列：相近只记待办，确认后才进库 ───────────────────────────────
+await test('S12 相近保存进待办队列，确认 distinct 后出队', () => {
+  const scope = fresh('conflict-queue');
+  saveEntry(globalScope(), { title: '发布前检查清单', summary: '发版前逐项确认', body: '清单', scope: 'global', resolution: 'distinct' });
+  assert.equal(pendingConflictsOf(globalScope()), 0);
+  const near = saveEntry(scope, { title: '发布前检查清单', summary: '发版前逐项确认（项目补充）', body: '项目清单' });
+  assert.equal(near.needsResolution, true);
+  assert.equal(near.pendingConflicts, 1);
+  assert.equal(pendingConflictsOf(scope), 1);
+  const queued = loadIndex(scope).conflicts[0];
+  assert.equal(queued.title, '发布前检查清单');
+  assert.equal(queued.scope, 'project');
+  assert.equal(queued.candidates.length >= 1, true);
+  const again = saveEntry(scope, { title: '发布前检查清单', summary: '发版前逐项确认（项目补充）', body: '项目清单' });
+  assert.equal(pendingConflictsOf(scope), 1);
+  const distinct = saveEntry(scope, { title: '发布前检查清单', summary: '发版前逐项确认（项目补充）', body: '项目清单', resolution: 'distinct' });
+  assert.equal(distinct.needsResolution, false);
+  assert.equal(pendingConflictsOf(scope), 0);
+});
+
 console.log(`crossing.test.mjs: ${passed} passed`);