dsh-lite-memory 0.11.1 → 0.15.0

package/test/anchor.test.mjs

@@ -213,3 +213,224 @@ test('R18 自由措辞不能把未注册栏目变成已绑定', () => {
   assert.equal(routed.anchor.status, 'unbound');
   assert.equal(routed.anchor.seriesId, undefined);
 });
+
+test('R12 无切换词的新任务撤销旧作品绑定，不继承栏目和规则', () => {
+  const sessionId = 'sess-r12';
+  let tasks = anchor.emptyTasks();
+  const first = anchor.routeTask(tasks, {
+    sessionId,
+    batchKey: 'rb_first',
+    messageIds: ['m1'],
+    query: '帮我把这期口播视频的开头改一下',
+    selection: { seriesId: '口播', taskKind: '口播视频' },
+    now: 1000,
+  });
+  assert.equal(first.anchor.status, 'proposed');
+  const bound = anchor.applySelection(first.tasks, { sessionId, selection: { seriesId: '口播' }, batchKey: 'rb_first', messageIds: ['m1'], now: 1500 });
+  assert.equal(bound.anchor.status, 'proposed');
+  const active = bound.tasks.sessions[sessionId];
+  active.status = 'active';
+  tasks = bound.tasks;
+  const next = anchor.routeTask(tasks, {
+    sessionId,
+    batchKey: 'rb_next',
+    messageIds: ['m2'],
+    query: '帮我排查 PostgreSQL 连接超时',
+    registeredSeries: ['口播'],
+    now: 2000,
+  });
+  assert.equal(next.anchor.status, 'unbound');
+  assert.equal(next.decision.kind, 'unbound');
+  assert.equal(next.decision.reason, 'new_task');
+  assert.ok(next.episode.previousEpisodeId);
+
+  /** 新任务已撤销旧绑定：旧栏目规则不能再自动进入这一步。 */
+  const read = anchor.decideRead({
+    enabled: true,
+    identityConfirmed: true,
+    anchor: next.anchor,
+    ranges: [{ seriesId: '口播', taskKind: '口播视频', reason: '旧任务' }],
+  });
+  assert.equal(read.kind, 'index');
+  assert.equal(read.rules, undefined);
+});
+
+test('R13 继续改/接着做仍继承同一任务', () => {
+  let tasks = anchor.emptyTasks();
+  const first = anchor.routeTask(tasks, {
+    sessionId: 'sess-r13',
+    batchKey: 'rb_a',
+    messageIds: ['m1'],
+    query: '帮我把这期口播视频的开头改一下',
+    selection: { seriesId: '口播' },
+    now: 1000,
+  });
+  tasks = first.tasks;
+  const next = anchor.routeTask(tasks, {
+    sessionId: 'sess-r13',
+    batchKey: 'rb_b',
+    messageIds: ['m2'],
+    query: '继续改，节奏再快一点',
+    now: 2000,
+  });
+  assert.equal(next.anchor.status, 'continuable');
+  assert.equal(next.decision.kind, 'continuation');
+});
+
+test('R14 无候选栏目时返回 none，不再要求选栏目', () => {
+  const read = anchor.decideRead({ enabled: true, identityConfirmed: true, anchor: null, ranges: [] });
+  assert.equal(read.kind, 'none');
+  assert.equal(read.reason, 'no_range');
+});
+
+/** 已绑定的口播任务：用于验证换任务时旧范围确实被撤销。 */
+function activeVideoSession() {
+  const first = anchor.routeTask(anchor.emptyTasks(), {
+    sessionId: 'sess-switch',
+    batchKey: 'rb_video',
+    messageIds: ['m1'],
+    query: '帮我把这期口播视频的开头改一下',
+    selection: { seriesId: '口播', taskKind: '口播视频' },
+    now: 1000,
+  });
+  const anchorState = first.tasks.sessions['sess-switch'];
+  anchorState.status = 'active';
+  return first.tasks;
+}
+
+test('R20 带「继续」但出现新对象时，先撤销旧范围', () => {
+  const tasks = activeVideoSession();
+  const next = anchor.routeTask(tasks, {
+    sessionId: 'sess-switch',
+    batchKey: 'rb_pg_continue',
+    messageIds: ['m2'],
+    query: '接下来继续排查 PostgreSQL 连接超时',
+    registeredSeries: ['口播'],
+    now: 2000,
+  });
+  assert.equal(next.decision.kind, 'unbound');
+  assert.equal(next.decision.reason, 'new_task');
+  assert.equal(next.anchor.seriesId, undefined);
+  assert.equal(next.episode.previousEpisodeId, tasks.sessions['sess-switch'].episodeId);
+});
+
+test('R21 带「这个」但出现新对象时，不沿用旧范围', () => {
+  const tasks = activeVideoSession();
+  const next = anchor.routeTask(tasks, {
+    sessionId: 'sess-switch',
+    batchKey: 'rb_pg_this',
+    messageIds: ['m2'],
+    query: '现在帮我排查这个 PostgreSQL 连接超时',
+    registeredSeries: ['口播'],
+    now: 2000,
+  });
+  assert.equal(next.decision.kind, 'unbound');
+  assert.equal(next.decision.reason, 'new_task');
+  assert.equal(next.anchor.seriesId, undefined);
+});
+
+test('R22 真正的续改保留原任务范围', () => {
+  const tasks = activeVideoSession();
+  const next = anchor.routeTask(tasks, {
+    sessionId: 'sess-switch',
+    batchKey: 'rb_video_continue',
+    messageIds: ['m2'],
+    query: '继续改刚才那版脚本，开头再直接一点',
+    registeredSeries: ['口播'],
+    now: 2000,
+  });
+  assert.equal(next.decision.kind, 'continuation');
+  assert.equal(next.anchor.seriesId, '口播');
+  assert.equal(next.episode.previousEpisodeId, tasks.sessions['sess-switch'].episodeId);
+});
+
+test('R23 只指代旧稿的局部修改不被当成换任务', () => {
+  const tasks = activeVideoSession();
+  const next = anchor.routeTask(tasks, {
+    sessionId: 'sess-switch',
+    batchKey: 'rb_video_tweak',
+    messageIds: ['m2'],
+    query: '现在把开头改短一点',
+    registeredSeries: ['口播'],
+    now: 2000,
+  });
+  assert.equal(next.decision.kind, 'focus');
+  assert.equal(next.anchor.seriesId, '口播');
+});
+
+test('R24 继续做新领域的中文任务也算换任务', () => {
+  const tasks = activeVideoSession();
+  const next = anchor.routeTask(tasks, {
+    sessionId: 'sess-switch',
+    batchKey: 'rb_research',
+    messageIds: ['m2'],
+    query: '继续看看竞品定价',
+    registeredSeries: ['口播'],
+    now: 2000,
+  });
+  assert.equal(next.decision.kind, 'unbound');
+  assert.equal(next.decision.reason, 'new_task');
+});
+
+test('R25 单独说「继续」不沿用旧任务范围', () => {
+  const tasks = activeVideoSession();
+  const previous = tasks.sessions['sess-switch'];
+  const next = anchor.routeTask(tasks, {
+    sessionId: 'sess-switch',
+    batchKey: 'rb_weak_continue',
+    messageIds: ['m2'],
+    query: '继续',
+    registeredSeries: ['口播'],
+    now: 2000,
+  });
+  assert.equal(next.decision.kind, 'unbound');
+  assert.equal(next.decision.reason, 'new_task');
+  assert.equal(next.anchor.seriesId, undefined);
+  assert.equal(next.episode.previousEpisodeId, previous.episodeId);
+});
+
+test('R26 单独说「这个」不沿用旧任务范围', () => {
+  const tasks = activeVideoSession();
+  const next = anchor.routeTask(tasks, {
+    sessionId: 'sess-switch',
+    batchKey: 'rb_weak_this',
+    messageIds: ['m2'],
+    query: '这个',
+    registeredSeries: ['口播'],
+    now: 2000,
+  });
+  assert.equal(next.decision.kind, 'unbound');
+  assert.equal(next.decision.reason, 'new_task');
+  assert.equal(next.anchor.seriesId, undefined);
+});
+
+test('R27 单独说「之前」不沿用旧任务范围', () => {
+  const tasks = activeVideoSession();
+  const next = anchor.routeTask(tasks, {
+    sessionId: 'sess-switch',
+    batchKey: 'rb_weak_before',
+    messageIds: ['m2'],
+    query: '之前',
+    registeredSeries: ['口播'],
+    now: 2000,
+  });
+  assert.equal(next.decision.kind, 'unbound');
+  assert.equal(next.decision.reason, 'new_task');
+  assert.equal(next.anchor.seriesId, undefined);
+});
+
+test('R28 指代加动作的续接仍保留旧任务范围', () => {
+  const tasks = activeVideoSession();
+  const previous = tasks.sessions['sess-switch'];
+  const next = anchor.routeTask(tasks, {
+    sessionId: 'sess-switch',
+    batchKey: 'rb_strong_continue',
+    messageIds: ['m2'],
+    query: '把刚才那个再调一下',
+    registeredSeries: ['口播'],
+    now: 2000,
+  });
+  assert.notEqual(next.decision.kind, 'unbound');
+  assert.equal(next.anchor.episodeId, previous.episodeId);
+  assert.equal(next.anchor.seriesId, '口播');
+});

package/test/client.test.mjs

@@ -20,7 +20,47 @@ assert.ok(evolution, '项目开关没有注册');
 assert.equal(evolution.name, 'conversation.session.header.utilities');
 assert.equal(evolution.order, 30);
 
-const { metaOf, citationOf, citationsOfMeta, citationsOfTurn, dedupe, undoRefOf } = seen;
+// 记忆面板占整框浮层，不挤在会话列里。
+const panel = registrations.find((item) => item.id === 'lite-memory:panel');
+assert.ok(panel, '记忆面板没有注册');
+assert.equal(panel.name, 'shell.overlay');
+assert.equal(panel.order, 30);
+
+const { metaOf, citationOf, citationsOfMeta, citationsOfTurn, dedupe, undoRefOf, graphOf, ruleGraphOf } = seen;
+
+// 图谱只按真实数据画：共享标签成枢纽，显式关联成边，位置由 id 决定。
+const graph = graphOf([
+  { id: 'mem_aaaaaaaa', title: 'A', tags: ['发布'], topicKey: '上线', experimental: false, links: [{ id: 'mem_bbbbbbbb' }] },
+  { id: 'mem_bbbbbbbb', title: 'B', tags: ['发布'], topicKey: '上线', experimental: true, links: [] },
+  { id: 'mem_cccccccc', title: 'C', tags: ['环境'], topicKey: '', experimental: false, links: [] },
+]);
+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.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 rules = [
+  { id: 'ev_aaaaaaaa', title: 'A', state: 'active', conditions: [{ key: 'seriesId', value: '口播' }] },
+  { id: 'ev_bbbbbbbb', title: 'B', state: 'trial', conditions: [{ key: 'seriesId', value: '口播' }, { key: 'phase', value: '初稿' }] },
+  { id: 'ev_cccccccc', title: 'C', state: 'pending', conditions: [{ key: 'phase', value: '初稿' }] },
+];
+const ruleGraph = ruleGraphOf(rules);
+assert.equal(ruleGraph.nodes.filter((node) => node.kind === 'rule').length, 3);
+assert.equal(ruleGraph.nodes.some((node) => node.id === 'condition:seriesId:口播'), true);
+assert.equal(ruleGraph.nodes.some((node) => node.id === 'condition:phase:初稿'), true);
+assert.equal(ruleGraph.edges.length, 4);
+assert.equal(ruleGraph.edges.every((edge) => edge.type === 'condition'), true);
+assert.equal(ruleGraph.nodes.some((node) => node.kind === 'tag' || node.kind === 'topic'), false);
+assert.deepEqual(ruleGraphOf(rules).nodes.map((node) => [node.id, node.x, node.y]), ruleGraph.nodes.map((node) => [node.id, node.x, node.y]));
+assert.equal(ruleGraphOf([{ id: 'ev_aaaaaaaa', title: 'A', state: 'active', conditions: [] }]).edges.length, 0);
+
 const settled = (meta, extra = {}) => ({ kind: 'tool-result', meta, isError: false, content: [], ...extra });
 
 // 元数据只从落定结果里取，错误块和旧块一律不认。
@@ -53,20 +93,22 @@ assert.equal(refs.length, 2);
 assert.equal(refs[1].status, 'archived');
 assert.equal(refs[0].exposure, 'reference');
 
-// 一轮里 PTC 子结果也算；同 id 同版同用途去重。
+// 一轮里 PTC 子结果也算；同 id 同用途只留一条，位置不变、内容取最新。
 const nodes = [
   { root: settled({ kind: 'memory-search', refs: [
     { id: 'mem_aaaaaaaa', title: 'A', scope: 'project', revision: 1, status: 'ok' },
   ] }) },
   { root: settled({ kind: 'memory-read', id: 'mem_aaaaaaaa', title: 'A2', scope: 'project', revision: 2, status: 'ok' }, { subCalls: [settled({ kind: 'memory-read', id: 'mem_aaaaaaaa', title: 'A3', scope: 'project', revision: 2, status: 'ok' })] }) },
+  { root: settled({ kind: 'memory-read', id: 'mem_bbbbbbbb', title: 'B', scope: 'global', revision: 1, status: 'ok' }) },
 ];
 const turn = dedupe(citationsOfTurn(nodes));
 assert.equal(turn.length, 2);
-assert.equal(turn[0].revision, 1);
-assert.equal(turn[1].revision, 2);
-assert.equal(turn[1].title, 'A2');
+assert.equal(turn[0].id, 'mem_aaaaaaaa');
+assert.equal(turn[0].revision, 2);
+assert.equal(turn[0].title, 'A3');
+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: 10 passed');
+console.log('client.test.mjs: 11 passed');

package/test/contract.test.mjs

@@ -108,13 +108,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]+ · 第 1 版$/);
+assert.match(render('memory_save', {}, saved), /^memory · saved \[[^\]]+\] "发布顺序" · mem_[a-z0-9]+$/);
 
 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]+ · 第 2 版$/);
+assert.match(render('memory_save', {}, merged), /^memory · merged \[[^\]]+\] "发布顺序" · mem_[a-z0-9]+$/);
 
 const patch = await exec('memory_save', { id: saved.id, title: '发布顺序', summary: '发版前要按顺序做的事', when: '发版当天' });
 assert.equal(patch.when, '发版当天');
@@ -125,7 +125,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]+ · 第 3 版$/);
+assert.match(render('memory_save', {}, again), /^memory · unchanged \[[^\]]+\] "发布顺序" · mem_[a-z0-9]+$/);
 
 // ── similar title asks before overwriting ────────────────────────────────────
 const probe = await exec('memory_save', { title: '发布顺序是啥', summary: '发版前要按顺序做的事', body: '另一条' });
@@ -147,16 +147,20 @@ const hits = await exec('memory_search', { query: '发布流程' });
 assert.ok(hits.count >= 1);
 assert.ok(hits.chars > 0);
 const hitText = render('memory_search', {}, hits);
-assert.match(hitText, new RegExp(`^memory · 命中 ${hits.count} 条 · 引用 ${hits.chars} 字\\n- mem_`));
-assert.match(hitText, /第 3 版/);
+assert.match(hitText, new RegExp(`^memory · 命中 ${hits.count} 条 · 引用 ${hits.chars} 字\\n- \\[[^\\]]+\\] mem_`));
+assert.doesNotMatch(hitText, /第 .* 版/);
+/** 「发版当天」这类自由文本条件没有可信上下文，不能当成适用条目塞给模型。 */
 const miss = await exec('memory_search', { query: '完全没有出现过的主题' });
 assert.equal(miss.count, 0);
 assert.equal(render('memory_search', {}, miss), 'memory · 没有命中');
 
 const read = await exec('memory_read', { id: saved.id });
-assert.equal(read.body, '第一步\n第二步');
-assert.equal(read.revision, 3);
-assert.match(render('memory_read', {}, read), new RegExp(`^memory · 「发布顺序」（发版当天） · ${saved.id} · 第 3 版`));
+assert.equal(read.status, 'needs_context');
+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}`));
 
 // 没点明归档还是彻底忘掉时不动盘，先返回待确认
 const undecided = await exec('memory_forget', { id: distinct.id });
@@ -165,7 +169,7 @@ assert.match(render('memory_forget', {}, undecided), new RegExp(`^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), new RegExp(`^memory · archived \\[[^\\]]+\\] "发布顺序是啥" · ${distinct.id}，可找回$`));
 assert.equal(await exec('memory_save', { title: '发布顺序是啥', summary: '发版前要按顺序做的事', body: '第三条' }).then((v) => v.merged), false);
 
 // ── suggestion → keep → replay → reject ──────────────────────────────────────
@@ -227,10 +231,10 @@ 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 \[全局\] "回复用中文" · mem_[a-z0-9]+ · 第 1 版$/);
+assert.match(render('memory_save', {}, global), /^memory · saved \[global\] "回复用中文" · mem_[a-z0-9]+$/);
 const globalSearch = await exec('memory_search', { query: '回复用中文' });
 assert.equal(globalSearch.count, 1);
-assert.match(render('memory_search', {}, globalSearch), /\[全局\] mem_/);
+assert.match(render('memory_search', {}, globalSearch), /\[global\] mem_/);
 assert.equal(typeof globalThis.__liteMemoryStats, 'function');
 const stats = globalThis.__liteMemoryStats(cwd);
 assert.ok(stats.count >= 1);
@@ -415,6 +419,102 @@ const evoDelete = await call('/lite-memory/evolution', {
 assert.equal(evoDelete.status, 200);
 assert.equal(evoDelete.body.ok, true);
 
+// 管理面成功路径：候选可修改、采纳、暂停、恢复、放弃，每次返回后能继续操作
+const manageSeed = await defs.get('memory_save').execute(
+  { title: '口播收尾', summary: '口播收尾留一句行动', body: '结尾给一句具体行动。' },
+  { agent: evoAgent },
+);
+state.transact(evoReadScope, {}, (draft) => {
+  const row = draft.entries.find((entry) => entry.id === manageSeed.id);
+  row.origin = 'project_evolution';
+  row.current.conditions = [{ key: 'seriesId', value: '口播' }];
+  row.maintenance = { ...(row.maintenance || {}), learning: { state: 'pending', source: 'evolution' } };
+  return { changed: true };
+});
+const manageSnap = await call('/lite-memory/evolution', { sessionId: 'session-evo-read', learningAction: 'snapshot' });
+const manageRule = manageSnap.body.rules.find((rule) => rule.id === manageSeed.id);
+assert.ok(manageRule);
+assert.equal(manageRule.state, 'pending');
+const manageEdit = await call('/lite-memory/evolution', {
+  sessionId: 'session-evo-read', learningAction: 'edit', id: manageSeed.id,
+  expectedRevision: manageRule.revision, body: '结尾给一句具体动作。',
+});
+assert.equal(manageEdit.status, 200);
+assert.equal(manageEdit.body.ok, true);
+const afterManageEdit = (await call('/lite-memory/evolution', { sessionId: 'session-evo-read', learningAction: 'snapshot' })).body.rules.find((rule) => rule.id === manageSeed.id);
+assert.equal(afterManageEdit.state, 'pending');
+assert.equal(afterManageEdit.body, '结尾给一句具体动作。');
+const manageAdopt = await call('/lite-memory/evolution', {
+  sessionId: 'session-evo-read', learningAction: 'adopt', id: manageSeed.id, expectedRevision: afterManageEdit.revision,
+});
+assert.equal(manageAdopt.status, 200);
+assert.equal((await call('/lite-memory/evolution', { sessionId: 'session-evo-read', learningAction: 'snapshot' })).body.rules.find((rule) => rule.id === manageSeed.id).state, 'active');
+const managePause = await call('/lite-memory/evolution', {
+  sessionId: 'session-evo-read', learningAction: 'pause', ids: [manageSeed.id],
+});
+assert.equal(managePause.status, 200);
+assert.equal((await call('/lite-memory/evolution', { sessionId: 'session-evo-read', learningAction: 'snapshot' })).body.rules.find((rule) => rule.id === manageSeed.id).state, 'paused');
+const manageResume = await call('/lite-memory/evolution', {
+  sessionId: 'session-evo-read', learningAction: 'resume', id: manageSeed.id,
+});
+assert.equal(manageResume.status, 200);
+const manageResumed = (await call('/lite-memory/evolution', { sessionId: 'session-evo-read', learningAction: 'snapshot' })).body.rules.find((rule) => rule.id === manageSeed.id);
+assert.equal(manageResumed.state, 'trial');
+const manageDiscard = await call('/lite-memory/evolution', {
+  sessionId: 'session-evo-read', learningAction: 'discard', id: manageSeed.id, expectedRevision: manageResumed.revision,
+});
+assert.equal(manageDiscard.status, 200);
+assert.equal((await call('/lite-memory/evolution', { sessionId: 'session-evo-read', learningAction: 'snapshot' })).body.rules.length, 0);
+
+// ── 关闭项目记忆后：面板只读，管理面写操作全部拒绝，工具也不落盘 ─────────────
+const closedCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-contract-closed-'));
+sessionCwds.set('session-closed', closedCwd);
+const closedScope = store.scopeOf(closedCwd);
+const closedAgent = { id: 'session-closed', cwd: closedCwd, session: { id: 'session-closed', header: { cwd: closedCwd } } };
+const closedSeed = await defs.get('memory_save').execute(
+  { title: '口播开头', summary: '口播开头三句内给结论', body: '开场三句内给结论。' },
+  { agent: closedAgent },
+);
+state.transact(closedScope, {}, (draft) => {
+  const row = draft.entries.find((entry) => entry.id === closedSeed.id);
+  row.origin = 'project_evolution';
+  row.maintenance = { ...(row.maintenance || {}), learning: { state: 'active' } };
+  return { changed: true };
+});
+assert.equal((await call('/lite-memory/evolution', { sessionId: 'session-closed', enabled: true })).status, 200);
+const closedOff = await call('/lite-memory/control', { sessionId: 'session-closed', enabled: false, operationId: 'op_close_contract' });
+assert.equal(closedOff.status, 200);
+assert.equal(closedOff.body.enabled, false);
+const closedFile = path.join(closedScope.dir, 'state.json');
+const closedBefore = fs.readFileSync(closedFile);
+const closedSnapshot = await call('/lite-memory/evolution', { sessionId: 'session-closed', learningAction: 'snapshot' });
+assert.equal(closedSnapshot.status, 200);
+assert.equal(closedSnapshot.body.enabled, false);
+assert.equal(closedSnapshot.body.rules.length, 1);
+assert.equal(Buffer.compare(closedBefore, fs.readFileSync(closedFile)), 0);
+const closedRevision = closedSnapshot.body.rules[0].revision;
+for (const action of ['adopt', 'edit', 'delete', 'pause', 'resume', 'pin', 'undo']) {
+  const payload = { sessionId: 'session-closed', learningAction: action, id: closedSeed.id, expectedRevision: closedRevision, body: '改过的正文' };
+  if (action === 'pin') payload.pinned = true;
+  if (action === 'pause') payload.ids = [closedSeed.id];
+  const result = await call('/lite-memory/evolution', payload);
+  assert.equal(result.status, 409, action);
+  assert.equal(result.body.code, 'memory_disabled', action);
+}
+const closedTool = await defs.get('memory_save').execute(
+  { title: '关闭后写入', summary: '应当拒绝', body: '不该落盘' },
+  { agent: closedAgent },
+);
+assert.equal(closedTool.changed, false);
+assert.equal(closedTool.reason, 'memory_disabled');
+assert.equal(closedTool.id, '');
+assert.equal(Buffer.compare(closedBefore, fs.readFileSync(closedFile)), 0);
+const reopened = await call('/lite-memory/control', { sessionId: 'session-closed', enabled: true, operationId: 'op_reopen_contract' });
+assert.equal(reopened.status, 200);
+const reopenedSnapshot = await call('/lite-memory/evolution', { sessionId: 'session-closed', learningAction: 'snapshot' });
+assert.equal(reopenedSnapshot.body.enabled, false);
+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);
@@ -674,4 +774,107 @@ assert.equal(orgEconomy2.knownCalls, 3);
 assert.equal(orgEconomy2.inputTokens, 36);
 llmImpl = null;
 
+// ── 记忆面板总览：只读枚举各项目层，正文按 scopeKey 单读，不泄露内部路径 ──────
+const ovCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-contract-overview-'));
+const ovOtherCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-contract-overview-other-'));
+sessionCwds.set('session-overview', ovCwd);
+sessionCwds.set('session-overview-other', ovOtherCwd);
+const ovAgent = { id: 'session-overview', cwd: ovCwd, session: { id: 'session-overview', header: { cwd: ovCwd } } };
+const ovFirst = await defs.get('memory_save').execute(
+  { title: '开场先给结论', summary: '口播开头先给结论', body: '开场三句内给结论。', tags: ['口播', '开头'], links: [] },
+  { agent: ovAgent },
+);
+const ovSecond = await defs.get('memory_save').execute(
+  { title: '封面留白', summary: '封面别放满', body: '右侧留白。', tags: ['封面'] },
+  { agent: ovAgent },
+);
+await defs.get('memory_save').execute(
+  { title: '观察全局', summary: '跨项目通用说明', body: '全局正文。', scope: 'global' },
+  { agent: ovAgent },
+);
+const ovOther = await defs.get('memory_save').execute(
+  { title: '别的项目', summary: '只在别的项目里', body: '另一层的正文。', tags: ['别的'] },
+  { agent: { id: 'session-overview-other', cwd: ovOtherCwd, session: { id: 'session-overview-other', header: { cwd: ovOtherCwd } } } },
+);
+const ov = await call('/lite-memory/overview', { sessionId: 'session-overview' });
+assert.equal(ov.status, 200);
+assert.equal(ov.body.ok, true);
+assert.equal(ov.body.current.key, store.scopeOf(ovCwd).key);
+assert.equal(ov.body.current.label, path.basename(ovCwd));
+assert.equal(ov.body.current.evolution.enabled, false);
+assert.equal(ov.body.selected.key, ov.body.current.key);
+assert.equal(ov.body.selected.kind, 'project');
+assert.equal(ov.body.selected.evolution.enabled, false);
+assert.ok(Array.isArray(ov.body.selected.evolution.rules));
+assert.ok(ov.body.selected.records.some((row) => row.id === ovFirst.id && row.title === '开场先给结论'));
+assert.equal(ov.body.selected.records.some((row) => 'body' in row), false, '列表不带正文');
+assert.equal(ov.body.selected.stats.total, 2);
+assert.equal(ov.body.selected.stats.tags, 3);
+assert.equal(JSON.stringify(ov.body).includes('"dir"'), false, '不暴露内部目录');
+assert.equal(JSON.stringify(ov.body).includes(process.env.DSH_HOME), false);
+const ovKeys = ov.body.scopes.map((row) => row.key);
+assert.ok(ovKeys.includes(ov.body.current.key));
+assert.ok(ovKeys.includes(store.scopeOf(ovOtherCwd).key));
+assert.ok(ovKeys.includes('global'), '全局层总在列表里');
+
+// 切到别的项目只是换一面看，不写那个项目
+const ovOtherView = await call('/lite-memory/overview', { sessionId: 'session-overview', scopeKey: store.scopeOf(ovOtherCwd).key });
+assert.equal(ovOtherView.status, 200);
+assert.equal(ovOtherView.body.selected.key, store.scopeOf(ovOtherCwd).key);
+assert.deepEqual(ovOtherView.body.selected.records.map((row) => row.title), ['别的项目']);
+assert.equal(ovOtherView.body.selected.evolution.enabled, false, '别的项目也要给只读实验状态');
+assert.equal(ovOtherView.body.current.key, ov.body.current.key);
+const ovGlobal = await call('/lite-memory/overview', { sessionId: 'session-overview', scopeKey: 'global' });
+assert.equal(ovGlobal.status, 200);
+assert.equal(ovGlobal.body.selected.kind, 'global');
+assert.ok(ovGlobal.body.selected.records.some((row) => row.title === '观察全局'));
+
+// 详情按服务端枚举过的 scopeKey 取；内部路径、未知键一律不放行
+const ovBody = await call('/lite-memory/body', { sessionId: 'session-overview', id: ovFirst.id, scopeKey: ov.body.current.key });
+assert.equal(ovBody.status, 200);
+assert.equal(ovBody.body.body, '开场三句内给结论。');
+assert.equal(ovBody.body.scopeLabel, path.basename(ovCwd));
+const ovOtherBody = await call('/lite-memory/body', { sessionId: 'session-overview', id: ovOther.id, scopeKey: store.scopeOf(ovOtherCwd).key });
+assert.equal(ovOtherBody.status, 200);
+assert.equal(ovOtherBody.body.scopeLabel, path.basename(ovOtherCwd));
+assert.equal((await call('/lite-memory/body', { sessionId: 'session-overview', id: ovFirst.id, scopeKey: 'nope' })).status, 404);
+assert.equal((await call('/lite-memory/body', { sessionId: 'session-overview', id: ovFirst.id, scopeKey: '../x' })).status, 404);
+assert.equal((await call('/lite-memory/overview', {})).status, 400);
+assert.equal((await call('/lite-memory/overview', { sessionId: 'session-overview' }, { origin: 'http://evil.example' })).status, 403);
+const ovUnknownCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-contract-overview-unknown-'));
+sessionCwds.set('session-overview-unknown', ovUnknownCwd);
+const ovUnconfirmedSaved = process.env.PATH;
+process.env.PATH = '';
+const ovUnconfirmed = await call('/lite-memory/overview', { sessionId: 'session-overview-unknown' });
+process.env.PATH = ovUnconfirmedSaved;
+assert.equal(ovUnconfirmed.status, 409);
+assert.equal(fs.existsSync(path.join(store.scopeOf(ovUnknownCwd).dir, 'state.json')), false);
+
+// 实验条目也画进图里，但只有面板能看见；普通读取面仍然拿不到
+state.transact(store.scopeOf(ovCwd), {}, (draft) => {
+  const row = draft.entries.find((entry) => entry.id === ovSecond.id);
+  row.origin = 'project_evolution';
+  row.maintenance = { ...(row.maintenance || {}), learning: { state: 'trial', source: 'evolution' } };
+  return { changed: true };
+});
+const ovExperimental = await call('/lite-memory/overview', { sessionId: 'session-overview' });
+assert.equal(ovExperimental.body.selected.stats.experimental, 1);
+assert.equal(ovExperimental.body.selected.records.find((row) => row.id === ovSecond.id).experimental, true);
+assert.equal(store.loadIndex(store.scopeOf(ovCwd), { allowExperimental: true }).entries.some((row) => row.id === ovSecond.id), true);
+
+// 归档不是死数字：总数诚实，列表单独取，正文还能按 id 打开
+state.transact(store.scopeOf(ovCwd), {}, (draft) => {
+  const row = draft.entries.find((entry) => entry.id === ovSecond.id);
+  row.status = 'archived';
+  return { changed: true };
+});
+const ovArchived = await call('/lite-memory/overview', { sessionId: 'session-overview' });
+assert.equal(ovArchived.body.selected.stats.archived, 1);
+assert.equal(ovArchived.body.selected.records.some((row) => row.id === ovSecond.id), false);
+assert.equal(ovArchived.body.selected.archived.some((row) => row.id === ovSecond.id), true);
+const ovArchivedBody = await call('/lite-memory/body', { sessionId: 'session-overview', id: ovSecond.id, scopeKey: ovArchived.body.selected.key });
+assert.equal(ovArchivedBody.status, 200);
+assert.equal(ovArchivedBody.body.status, 'archived');
+assert.equal(ovArchivedBody.body.body, '右侧留白。');
+
 console.log('contract.test.mjs: all passed');