dsh-lite-memory 0.17.0 → 0.18.19

package/test/contract.test.mjs

@@ -67,13 +67,15 @@ const json = (body) => JSON.parse(body);
 // ── tool contract ────────────────────────────────────────────────────────────
 const names = ['memory_save', 'memory_suggest', 'memory_search', 'memory_read', 'memory_forget'];
 assert.deepEqual([...defs.keys()].sort(), [...names].sort());
+const TITLE_ADDRESSED = ['memory_read', 'memory_forget'];
 for (const name of names) {
   const def = defs.get(name);
   assert.equal(def.parameters.type, 'object');
   assert.equal(def.parameters.additionalProperties, false);
   assert.equal(typeof def.output.render, 'function');
   assert.equal(typeof def.output.schema, 'object');
-  assert.ok(def.parameters.required.length >= 1);
+  assert.ok(Object.keys(def.parameters.properties).length >= 1);
+  if (TITLE_ADDRESSED.includes(name)) assert.equal('title' in def.parameters.properties, true, `${name} 按标题定位`);
 }
 
 const saveParams = defs.get('memory_save').parameters.properties;
@@ -82,6 +84,9 @@ for (const key of ['source', 'origin', 'confirmed', 'force', 'autoRecall']) {
   assert.equal(key in saveParams, false, `memory_save 不该接受 ${key}`);
 }
 assert.equal(saveParams.mode.enum.includes('replace_current'), true);
+/** 关联目标也按标题给，参数里不该出现 mem_ 开头的 id 字段。 */
+assert.equal(saveParams.links.items.properties.id, undefined);
+assert.equal(saveParams.links.items.properties.title.type, 'string');
 assert.equal(JSON.stringify(saveParams.applicability.enum), JSON.stringify(['all_in_scope', 'conditional', 'unresolved']));
 
 assert.deepEqual(saveParams.resolution.enum, ['distinct']);
@@ -89,12 +94,14 @@ assert.deepEqual(saveParams.resolution.enum, ['distinct']);
 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');
+/** 更新句柄只暴露标题：id 是底层实现，参数表里不该出现。 */
+assert.equal(saveParams.updateTitle.type, 'string');
+assert.equal(saveParams.id, undefined);
 assert.deepEqual(saveParams.scope.enum, ['auto', 'project', 'global']);
 assert.equal(saveParams.memoryClass.type, 'string');
 assert.deepEqual(saveParams.memoryClass.enum, ['personal_preference', 'project_fact', 'environment_fact', 'portable_procedure']);
 assert.deepEqual(saveParams.durability.enum, ['durable', 'task']);
-assert.deepEqual(saveParams.sameTopicAs.required, ['scope', 'id', 'revision']);
+assert.deepEqual(saveParams.sameTopicAs.required, ['scope', 'title']);
 assert.equal(defs.get('memory_suggest').parameters.properties.scope, undefined);
 assert.equal(defs.get('memory_suggest').parameters.properties.resolution, undefined);
 
@@ -109,47 +116,56 @@ const phrased = await exec('memory_save', { title: '以后都用这个一次性
 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.equal(typeof saved.title, 'string');
+assert.equal(saved.id, undefined);
+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.title, saved.title);
 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: '发版当天' });
+const patch = await exec('memory_save', { title: '发布顺序', summary: '发版前要按顺序做的事', when: '发版当天' });
 assert.equal(patch.when, '发版当天');
 assert.match(render('memory_save', {}, patch), /（发版当天）/);
 
 /** 同样的字段再存一次不算修改：不改版次，也不该被读成「存过一次」。 */
 const again = await exec('memory_save', { title: '发布顺序', summary: '发版前要按顺序做的事', when: '发版当天' });
 assert.equal(again.changed, false);
-assert.equal(again.id, saved.id);
+assert.equal(again.title, saved.title);
 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: '另一条' });
 assert.equal(probe.needsResolution, true);
-assert.equal(probe.id, '');
+assert.equal(probe.id, undefined);
 assert.equal(probe.revision, 0);
-assert.ok(probe.similarIds.length > 0);
+assert.ok(probe.similarTitles.length > 0);
+assert.doesNotMatch(probe.similarTitles, /mem_[a-z0-9]{6,}/, '相近候选按标题点名');
 const probeText = render('memory_save', {}, probe);
 assert.match(probeText.split('\n')[0], /^memory · 需要确认：「发布顺序是啥」与已有条目相近$/);
-assert.match(probeText, /要更新它，用 id 重存/);
-assert.match(probeText, new RegExp(saved.id));
+assert.match(probeText, /要更新它：用同一个标题再存一次/);
+assert.match(probeText, /「发布顺序」/);
+assert.doesNotMatch(probeText, /mem_[a-z0-9]{6,}/, '相近提示只给标题');
 const distinct = await exec('memory_save', { title: '发布顺序是啥', summary: '发版前要按顺序做的事', body: '另一条', resolution: 'distinct' });
 assert.equal(distinct.needsResolution, false);
 assert.equal(distinct.merged, false);
-assert.notEqual(distinct.id, saved.id);
+assert.equal(distinct.id, undefined);
+assert.notEqual(distinct.title, saved.title);
+/** 刚存完就能查回来：不是只统计条数，命中的必须是刚存的那一条。 */
+const justSaved = await exec('memory_search', { query: '发布顺序是啥' });
+assert.ok(justSaved.count >= 1);
+assert.match(render('memory_search', {}, justSaved), /「发布顺序是啥」/);
 
 // ── search / read / forget ───────────────────────────────────────────────────
 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, new RegExp(`^memory · 命中 ${hits.count} 条 · 引用 ${hits.chars} 字\\n- \\[[^\\]]+\\] 「`));
+assert.doesNotMatch(hitText, /mem_[a-z0-9]{6,}/, '检索结果只给标题与适用范围');
 assert.doesNotMatch(hitText, /第 .* 版/);
 /** 「发版当天」这类自由文本条件没有可信上下文，不能当成适用条目塞给模型。 */
 const miss = await exec('memory_search', { query: '完全没有出现过的主题' });
@@ -157,29 +173,45 @@ 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 });
+const read = await exec('memory_read', { title: saved.title });
 assert.equal(read.status, 'needs_context');
-assert.equal(read.body, '');
-const plain = await exec('memory_read', { id: distinct.id });
+assert.equal(read.body, '', '条件未知时标题只能定位，不能证明适用，正文不返回');
+assert.doesNotMatch(render('memory_read', {}, read), /发版/);
+const plain = await exec('memory_read', { title: distinct.title });
 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('mem_'));
+assert.equal(plain.title, distinct.title);
+
+/* 界面与工具文本一律不出现内部编号：id 只是存储地址。 */
+for (const [name, value] of [['memory_save', saved], ['memory_save', merged], ['memory_save', patch],
+  ['memory_search', hits], ['memory_read', plain], ['memory_save', probe]]) {
+  assert.doesNotMatch(render(name, {}, value), /\b(mem|sug|cf)_[a-z0-9]{6,}/, `${name} 文案里没有内部编号`);
+}
 
 // 没点明归档还是彻底忘掉时不动盘，先返回待确认
-const undecided = await exec('memory_forget', { id: distinct.id });
+const undecided = await exec('memory_forget', { title: distinct.title });
 assert.equal(undecided.mode, 'needs_resolution');
-assert.match(render('memory_forget', {}, undecided), new RegExp(`^memory · 先确认是归档还是彻底忘掉 · ${distinct.id}$`));
-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', {}, undecided), /^memory · 先确认是归档还是彻底忘掉 · 「发布顺序是啥」$/);
+const distinctRow = store.search(store.scopeOf(cwd), distinct.title).find((row) => row.title === distinct.title);
+assert.ok(distinctRow);
+assert.ok(store.locate(store.scopeOf(cwd), distinctRow.id));
+const archived = await exec('memory_forget', { title: distinct.title, mode: 'archive' });
+assert.equal(archived.title, distinct.title);
+assert.equal(archived.id, undefined);
+assert.match(render('memory_forget', {}, archived), /^memory · archived \[[^\]]+\] "发布顺序是啥"，可找回$/);
+const readArchived = await exec('memory_read', { title: distinct.title });
+assert.equal(readArchived.status, 'archived');
+assert.equal(readArchived.body, '');
+assert.match(render('memory_read', { title: distinct.title }, readArchived), /^memory · 这条记忆已归档$/);
 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);
@@ -234,40 +266,48 @@ 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_/);
+assert.match(render('memory_search', {}, globalSearch), /\[global\] 「/);
 assert.equal(typeof globalThis.__liteMemoryStats, 'function');
 const stats = globalThis.__liteMemoryStats(cwd);
 assert.ok(stats.count >= 1);
 
 // ── 引用条：会话读过哪几条，点开能拿到正文 ───────────────────────────────────
 const cited = await exec('memory_save', { title: '引用测试', summary: '底部引用条要能点开正文', body: '引用正文第一行' });
-await exec('memory_read', { id: cited.id });
+await exec('memory_read', { title: cited.title });
+const citedRow = store.search(store.scopeOf(cwd), '引用测试').find((row) => row.title === '引用测试');
+assert.ok(citedRow);
 const cites = await call('/lite-memory/citations', { sessionId: 'session-contract' });
 assert.equal(cites.status, 200);
-assert.ok(cites.body.items.some((item) => item.id === cited.id && item.title === '引用测试'));
+assert.ok(cites.body.items.some((item) => item.id === citedRow.id && item.title === '引用测试'));
 assert.equal(cites.body.items.some((item) => 'path' in item), false);
-const opened = await call('/lite-memory/body', { sessionId: 'session-contract', id: cited.id });
+const opened = await call('/lite-memory/body', { sessionId: 'session-contract', id: citedRow.id });
 assert.equal(opened.status, 200);
 assert.match(opened.body.body, /引用正文第一行/);
+/** 界面只有标题：按标题也要能点开，不能因为引用行不存 title 就报已删除。 */
+const openedByTitle = await call('/lite-memory/body', { sessionId: 'session-contract', title: '引用测试', revision: opened.body.revision });
+assert.equal(openedByTitle.status, 200);
+assert.equal(openedByTitle.body.status, 'active');
+assert.match(openedByTitle.body.body, /引用正文第一行/);
+assert.equal((await call('/lite-memory/body', { sessionId: 'session-contract', title: '没有这条' })).body.status, 'gone');
 assert.equal(opened.body.scopeLabel, path.basename(cwd));
 const gone = await call('/lite-memory/body', { sessionId: 'session-contract', id: 'mem_999999999999' });
 assert.equal(gone.status, 200);
 assert.equal(gone.body.status, 'gone');
 assert.equal('title' in gone.body, false);
 /** 别的会话、别的工作目录都不能拿 id 探正文；本会话引用过或本目录这一层才行。 */
-const foreignSession = await call('/lite-memory/body', { sessionId: 'session-contract-2', id: cited.id });
+const foreignSession = await call('/lite-memory/body', { sessionId: 'session-contract-2', id: citedRow.id });
 assert.equal(foreignSession.status, 200);
 assert.equal(foreignSession.body.status, 'gone');
 assert.equal('body' in foreignSession.body, false);
-const viaCwd = await call('/lite-memory/body', { cwd, id: cited.id });
+const viaCwd = await call('/lite-memory/body', { cwd, id: citedRow.id });
 assert.equal(viaCwd.status, 200);
 assert.match(viaCwd.body.body, /引用正文第一行/);
-const foreignCwd = await call('/lite-memory/body', { cwd: path.join(os.tmpdir(), 'lite-memory-contract-foreign'), id: cited.id });
+const foreignCwd = await call('/lite-memory/body', { cwd: path.join(os.tmpdir(), 'lite-memory-contract-foreign'), id: citedRow.id });
 assert.equal(foreignCwd.body.status, 'gone');
-assert.equal((await call('/lite-memory/body', { id: cited.id })).status, 400);
+assert.equal((await call('/lite-memory/body', { id: citedRow.id })).status, 400);
 assert.equal((await call('/lite-memory/citations', {})).status, 400);
 assert.equal((await call('/lite-memory/citations', {}, { origin: 'http://evil.example' })).status, 403);
 assert.notEqual((await call('/lite-memory/citations', { sessionId: 'session-contract' }, { origin: 'dsh-app://app' })).status, 403);
@@ -325,6 +365,8 @@ assert.equal(fs.existsSync(path.join(store.scopeOf(evoUnknown).dir, 'state.json'
 
 // ── 自动召回：只在这句话跟已有记忆有关时出现，且不改命中计数 ─────────────────
 const hinted = await exec('memory_save', { title: 'Chrome 弹钥匙串窗口要带 mock keychain', summary: '临时 profile 起 Chrome 会弹钥匙串窗口' });
+const hintedRow = store.search(store.scopeOf(cwd), 'mock keychain').find((row) => row.title === hinted.title);
+assert.ok(hintedRow);
 // 只有一句 when、没有结构化条件的条目属于未解决，不自动注入
 await exec('memory_save', { title: '发布窗口在周四晚上', summary: '只在周四晚上发版', when: '周四晚上' });
 const recallAgent = { id: 'session-contract', cwd, session: { id: 'session-recall', header: { cwd } } };
@@ -342,17 +384,43 @@ assert.equal(recall.interpolate, false);
 assert.equal(recall.required, false);
 
 const sig1 = new AbortController().signal;
-const hitsBefore = store.loadIndex(store.scopeOf(cwd)).entries.find((item) => item.id === hinted.id).hits;
+const hitsBefore = store.loadIndex(store.scopeOf(cwd)).entries.find((item) => item.id === hintedRow.id).hits;
 await preStep({ agent: recallAgent, signal: sig1, turn: '2' }, pass('又弹钥匙串窗口了，怎么弄', 'h1'));
 const hintText = recall.text({ agent: recallAgent, signal: sig1 });
-assert.match(hintText, new RegExp(hinted.id));
+assert.doesNotMatch(hintText, /mem_[a-z0-9]{6,}/, '召回卡只给标题，不给内部编号');
 assert.match(hintText, /需要细节用 memory_read/);
-const hitsAfter = store.loadIndex(store.scopeOf(cwd)).entries.find((item) => item.id === hinted.id).hits;
+sessionCwds.set('session-recall', cwd);
+const recallReceipt = await call('/lite-memory/overview', { sessionId: 'session-recall' });
+assert.equal(recallReceipt.status, 200);
+assert.equal(recallReceipt.body.current.recall.reason, 'hit', '面板能回答这次为什么提醒');
+assert.equal(recallReceipt.body.current.recall.limit, 3);
+assert.equal(recallReceipt.body.current.recall.cards, 1);
+assert.ok(recallReceipt.body.current.recall.chars > 0);
+assert.ok(!/mem_[a-z0-9]{6,}/.test(JSON.stringify(recallReceipt.body.current.recall)), '判断依据不带内部编号');
+const missTurn = await preStep({ agent: recallAgent, signal: sig1, turn: '3' }, pass('把这段视频的字幕导出来', 'h2'));
+assert.equal(missTurn.kind, 'enter');
+assert.equal(recall.text({ agent: recallAgent, signal: sig1 }), '');
+const missReceipt = await call('/lite-memory/overview', { sessionId: 'session-recall' });
+assert.ok(['no_overlap', 'needs_context'].includes(missReceipt.body.current.recall.reason), '没提醒时也说明依据');
+assert.equal(missReceipt.body.current.recall.cards, 0);
+const hitsAfter = store.loadIndex(store.scopeOf(cwd)).entries.find((item) => item.id === hintedRow.id).hits;
 assert.equal(hitsAfter, hitsBefore);
 
 const sig2 = new AbortController().signal;
 await preStep({ agent: recallAgent, signal: sig2, turn: '3' }, pass('周四晚上发版要注意什么', 'h2'));
 assert.equal(recall.text({ agent: recallAgent, signal: sig2 }).includes('发布窗口在周四晚上'), false);
+const waitingReceipt = await call('/lite-memory/overview', { sessionId: 'session-recall' });
+assert.equal(waitingReceipt.body.current.recall.reason, 'needs_context', '有候选但条件未确认时，不误报成没有匹配');
+assert.equal(waitingReceipt.body.current.recall.cards, 0);
+
+// 同一主题的两条现行规范互相冲突：整组不进自动召回，但面板要说是「相关但没确认」，不是「没有匹配」
+await exec('memory_save', { title: '发版前检查清单', summary: '发版前先跑一遍检查清单', topicKey: 'release-checklist' });
+await exec('memory_save', { title: '发版前通知渠道', summary: '发版前在群里通知相关人', topicKey: 'release-checklist', resolution: 'distinct' });
+await preStep({ agent: recallAgent, signal: sig2, turn: '4' }, pass('发版前要做哪些检查', 'h4'));
+const conflictReceipt = await call('/lite-memory/overview', { sessionId: 'session-recall' });
+assert.equal(conflictReceipt.body.current.recall.reason, 'needs_context', '冲突未解决时也不能报成没有匹配');
+assert.equal(conflictReceipt.body.current.recall.cards, 0);
+assert.ok(conflictReceipt.body.current.recall.matched >= 1);
 
 const sig3 = new AbortController().signal;
 await preStep({ agent: recallAgent, signal: sig3, turn: '4' }, pass('把这个按钮的圆角改小一点', 'h3'));
@@ -371,11 +439,13 @@ const evoRule = await defs.get('memory_save').execute(
   { title: '口播开头', summary: '口播开头三句内给结论', body: '开场三句内给结论。' },
   { agent: evoAgentSeed },
 );
+const evoRow = store.loadIndex(evoReadScope).entries.find((entry) => entry.title === evoRule.title);
+assert.ok(evoRow, '口播开头落在这一层');
 state.transact(evoReadScope, {}, (draft) => {
-  const row = draft.entries.find((entry) => entry.id === evoRule.id);
+  const row = draft.entries.find((entry) => entry.id === evoRow.id);
   row.origin = 'project_evolution';
   row.current.conditions = [{ key: 'seriesId', value: '口播' }];
-  row.maintenance = { ...(row.maintenance || {}), learning: { state: 'active', source: 'evolution' } };
+  row.maintenance = { ...(row.maintenance || {}), learning: { state: 'active', source: 'evolution', specDigest: 'seeded' } };
   return { changed: true };
 });
 await store.setTaskDefault(evoReadScope, { seriesId: '口播' });
@@ -410,14 +480,14 @@ assert.equal(evoRecall.text({ agent: evoAgent, signal: evoSig }), '');
 const evoManage = await call('/lite-memory/evolution', { sessionId: 'session-evo-read', learningAction: 'snapshot' });
 assert.equal(evoManage.status, 200);
 assert.equal(evoManage.body.rules.length, 1);
-assert.equal(evoManage.body.rules[0].id, evoRule.id);
+assert.equal(evoManage.body.rules[0].id, evoRow.id);
 assert.ok(evoManage.body.payload.bytes > 0);
 const evoDeleteStale = await call('/lite-memory/evolution', {
-  sessionId: 'session-evo-read', learningAction: 'delete', id: evoRule.id, expectedRevision: evoManage.body.rules[0].revision - 1,
+  sessionId: 'session-evo-read', learningAction: 'delete', id: evoRow.id, expectedRevision: evoManage.body.rules[0].revision - 1,
 });
 assert.equal(evoDeleteStale.status, 409);
 const evoDelete = await call('/lite-memory/evolution', {
-  sessionId: 'session-evo-read', learningAction: 'delete', id: evoRule.id, expectedRevision: evoManage.body.rules[0].revision,
+  sessionId: 'session-evo-read', learningAction: 'delete', id: evoRow.id, expectedRevision: evoManage.body.rules[0].revision,
 });
 assert.equal(evoDelete.status, 200);
 assert.equal(evoDelete.body.ok, true);
@@ -427,44 +497,46 @@ const manageSeed = await defs.get('memory_save').execute(
   { title: '口播收尾', summary: '口播收尾留一句行动', body: '结尾给一句具体行动。' },
   { agent: evoAgent },
 );
+const manageRow = store.loadIndex(evoReadScope).entries.find((entry) => entry.title === manageSeed.title);
+assert.ok(manageRow, '口播收尾落在这一层');
 state.transact(evoReadScope, {}, (draft) => {
-  const row = draft.entries.find((entry) => entry.id === manageSeed.id);
+  const row = draft.entries.find((entry) => entry.id === manageRow.id);
   row.origin = 'project_evolution';
   row.current.conditions = [{ key: 'seriesId', value: '口播' }];
-  row.maintenance = { ...(row.maintenance || {}), learning: { state: 'pending', source: 'evolution' } };
+  row.maintenance = { ...(row.maintenance || {}), learning: { state: 'pending', source: 'evolution', specDigest: 'seeded' } };
   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);
+const manageRule = manageSnap.body.rules.find((rule) => rule.id === manageRow.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,
+  sessionId: 'session-evo-read', learningAction: 'edit', id: manageRow.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);
+const afterManageEdit = (await call('/lite-memory/evolution', { sessionId: 'session-evo-read', learningAction: 'snapshot' })).body.rules.find((rule) => rule.id === manageRow.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,
+  sessionId: 'session-evo-read', learningAction: 'adopt', id: manageRow.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');
+assert.equal((await call('/lite-memory/evolution', { sessionId: 'session-evo-read', learningAction: 'snapshot' })).body.rules.find((rule) => rule.id === manageRow.id).state, 'active');
 const managePause = await call('/lite-memory/evolution', {
-  sessionId: 'session-evo-read', learningAction: 'pause', ids: [manageSeed.id],
+  sessionId: 'session-evo-read', learningAction: 'pause', ids: [manageRow.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');
+assert.equal((await call('/lite-memory/evolution', { sessionId: 'session-evo-read', learningAction: 'snapshot' })).body.rules.find((rule) => rule.id === manageRow.id).state, 'paused');
 const manageResume = await call('/lite-memory/evolution', {
-  sessionId: 'session-evo-read', learningAction: 'resume', id: manageSeed.id,
+  sessionId: 'session-evo-read', learningAction: 'resume', id: manageRow.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);
+const manageResumed = (await call('/lite-memory/evolution', { sessionId: 'session-evo-read', learningAction: 'snapshot' })).body.rules.find((rule) => rule.id === manageRow.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,
+  sessionId: 'session-evo-read', learningAction: 'discard', id: manageRow.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);
@@ -478,10 +550,12 @@ const closedSeed = await defs.get('memory_save').execute(
   { title: '口播开头', summary: '口播开头三句内给结论', body: '开场三句内给结论。' },
   { agent: closedAgent },
 );
+const closedRow = store.loadIndex(closedScope).entries.find((entry) => entry.title === closedSeed.title);
+assert.ok(closedRow, '关闭前的样例落在这一层');
 state.transact(closedScope, {}, (draft) => {
-  const row = draft.entries.find((entry) => entry.id === closedSeed.id);
+  const row = draft.entries.find((entry) => entry.id === closedRow.id);
   row.origin = 'project_evolution';
-  row.maintenance = { ...(row.maintenance || {}), learning: { state: 'active' } };
+  row.maintenance = { ...(row.maintenance || {}), learning: { state: 'active', specDigest: 'seeded' } };
   return { changed: true };
 });
 assert.equal((await call('/lite-memory/evolution', { sessionId: 'session-closed', enabled: true })).status, 200);
@@ -499,7 +573,7 @@ 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];
+  if (action === 'pause') payload.ids = [closedRow.id];
   const result = await call('/lite-memory/evolution', payload);
   assert.equal(result.status, 409, action);
   assert.equal(result.body.code, 'memory_disabled', action);
@@ -510,7 +584,7 @@ const closedTool = await defs.get('memory_save').execute(
 );
 assert.equal(closedTool.changed, false);
 assert.equal(closedTool.reason, 'memory_disabled');
-assert.equal(closedTool.id, '');
+assert.equal(closedTool.id, undefined);
 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);
@@ -523,18 +597,25 @@ const metaOf = (name, args, value) => defs.get(name).output.presentationMeta(arg
 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.id, undefined);
 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', 'kind', 'origin', 'revision', 'scope', 'status', 'title', 'when']);
-assert.equal(searchMeta.refs[0].id, global.id);
+assert.deepEqual(Object.keys(searchMeta.refs[0]).sort(), ['kind', 'origin', 'revision', 'scope', 'status', 'title', 'updated', 'when']);
+/** 输出 schema 不能再要求内部 id：引用对外只有标题，宿主校验会因此整条工具报错。 */
+const searchRefSchema = defs.get('memory_search').output.schema.properties.refs.items;
+assert.equal('id' in searchRefSchema.properties, false);
+assert.deepEqual([...searchRefSchema.required].sort(), ['kind', 'origin', 'revision', 'scope', 'status', 'title', 'when']);
+assert.equal(searchMeta.refs[0].title, '回复用中文');
+assert.equal(searchMeta.refs[0].scope, 'global');
 /** 引用要能区分偏好/约定/流程/资料，界面才不必猜标题文案。 */
-assert.equal(searchMeta.refs[0].kind, store.loadIndex(store.globalScope()).entries.find((item) => item.id === global.id).kind);
+assert.equal(searchMeta.refs[0].kind, store.loadIndex(store.globalScope()).entries.find((item) => item.title === '回复用中文').kind);
 assert.equal(searchMeta.refs[0].when, '');
-const readValue = await exec('memory_read', { id: global.id });
+/** 出处行要说「N 天前更新」，只给时间不进正文。 */
+assert.equal(typeof searchMeta.refs[0].updated, 'string');
+const readValue = await exec('memory_read', { title: '回复用中文' });
 const readMeta = metaOf('memory_read', {}, readValue);
 assert.equal(readMeta.kind, 'memory-read');
 assert.equal(readMeta.recordKind, readValue.kind);
@@ -550,10 +631,10 @@ if (suggestMeta.asked === true) assert.match(suggestMeta.id, /^sug_[a-z0-9]+$/);
 // ── 撤销带着当时的版本：过期就冲突，不覆盖后来的修改 ─────────────────────────
 const guarded = await exec('memory_save', { title: '版本守卫', summary: '撤销要带当时版本' });
 await exec('memory_save', { title: '版本守卫', summary: '撤销要带当时版本', body: '第二版正文' });
-const stale = await call('/lite-memory/undo', { op: 'undo', id: guarded.id, revision: 1, cwd });
+const stale = await call('/lite-memory/undo', { op: 'undo', title: '版本守卫', revision: 1, cwd });
 assert.equal(stale.status, 409);
-const fresh = store.loadIndex(store.scopeOf(cwd)).entries.find((item) => item.id === guarded.id);
-const accepted = await call('/lite-memory/undo', { op: 'undo', id: guarded.id, revision: fresh.revision, cwd });
+const fresh = store.loadIndex(store.scopeOf(cwd)).entries.find((item) => item.title === '版本守卫');
+const accepted = await call('/lite-memory/undo', { op: 'undo', title: '版本守卫', revision: fresh.revision, cwd });
 assert.equal(accepted.status, 200);
 
 // ── 第二组：确认前后语义一致、比较口径统一 ──────────────────────────────────
@@ -594,9 +675,9 @@ const narrow = await exec2('memory_save', {
   conditions: [{ key: 'targetOs', value: 'windows' }],
 });
 assert.equal(narrow.changed, true);
-const narrowed = await exec2('memory_save', { id: narrow.id, title: 'windows 上跑构建', summary: 'windows 构建用这条命令' });
+const narrowed = await exec2('memory_save', { title: 'windows 上跑构建', summary: 'windows 构建用这条命令' });
 assert.equal(narrowed.changed, true);
-const narrowRecord = projectEntries().find((item) => item.id === narrow.id);
+const narrowRecord = projectEntries().find((item) => item.title === 'windows 上跑构建');
 assert.equal(narrowRecord.applicability, 'conditional');
 assert.deepEqual(narrowRecord.conditions, [{ key: 'targetOs', value: 'windows' }]);
 
@@ -621,11 +702,11 @@ const boxB = await exec2('memory_save', {
   conditions: [{ key: 'machine', value: 'box-b' }],
 });
 assert.equal(boxB.changed, true);
-assert.notEqual(boxB.id, boxA.id);
 const bothBoxes = projectEntries().filter((item) => item.title === '冒烟顺序' && item.status === 'active');
 assert.equal(bothBoxes.length, 2);
 assert.deepEqual(bothBoxes.map((item) => item.conditions[0].value).sort(), ['box-a', 'box-b']);
-assert.equal(bothBoxes.find((item) => item.id === boxA.id).body, '先登录再下单');
+assert.equal(bothBoxes.find((item) => item.conditions[0].value === 'box-a').body, '先登录再下单');
+assert.equal(bothBoxes.find((item) => item.conditions[0].value === 'box-b').body, '先建号再登录');
 
 /** 同一主题、条件一致但正文不同：读取要报冲突，不能悄悄挑一条当现行规范。 */
 const slotA = await exec2('memory_save', {
@@ -646,7 +727,9 @@ const slotB = await exec2('memory_save', {
   topicKey: '发版检查',
   resolution: 'distinct',
 });
-assert.notEqual(slotA.id, slotB.id);
+const slotEntries = projectEntries().filter((item) => item.title === '发版检查项');
+assert.equal(slotEntries.length, 2);
+assert.notEqual(slotEntries[0].id, slotEntries[1].id);
 const resolvedSlots = store.visibleRules(projectScope, {}).resolved;
 const slotRow = [...resolvedSlots.values()].find((row) => row.key === '发版检查');
 assert.ok(slotRow);
@@ -654,7 +737,7 @@ assert.equal(slotRow.status, 'conflict');
 
 /** 工具参数里的 links / selection.items / topicKey:null 是合法输入，不能被 schema 挡掉或被校验器拒绝。 */
 assert.equal(saveParams.links.items.type, 'object');
-assert.deepEqual(saveParams.links.items.required, ['id']);
+assert.deepEqual(saveParams.links.items.required, ['title']);
 assert.equal(saveParams.selection.properties.items.type, 'array');
 assert.deepEqual(saveParams.topicKey.type, ['string', 'null']);
 const linkedA = await exec2('memory_save', { title: '关联目标甲', summary: '用来当关联目标', body: '甲', scope: 'project' });
@@ -664,13 +747,21 @@ const linkedB = await exec2('memory_save', {
   body: '乙',
   scope: 'project',
   resolution: 'distinct',
-  links: [{ type: 'related', id: linkedA.id }],
+  links: [{ type: 'related', title: linkedA.title }],
 });
 assert.equal(linkedB.changed, true, JSON.stringify(linkedB));
-const linkedRecord = projectEntries().find((item) => item.id === linkedB.id);
+const linkedRecord = projectEntries().find((item) => item.title === '关联目标乙');
+const linkedTarget = projectEntries().find((item) => item.title === '关联目标甲');
+assert.ok(linkedRecord && linkedTarget);
 assert.equal(linkedRecord.links.length, 1);
-assert.equal(linkedRecord.links[0].id, linkedA.id);
+assert.equal(linkedRecord.links[0].id, linkedTarget.id);
 assert.equal(linkedRecord.links[0].type, 'related');
+/** 更新句柄也是标题：抄标题改这一条，不需要任何内部编号。 */
+const retitled = await exec2('memory_save', { updateTitle: linkedA.title, title: linkedA.title, summary: '改过的摘要' });
+assert.equal(retitled.changed, true);
+assert.equal(retitled.summary, '改过的摘要');
+const missingUpdate = await exec2('memory_save', { updateTitle: '从来没有存过的标题', title: '新的一条', summary: '新' });
+assert.match(missingUpdate.error, /没有「从来没有存过的标题」这条记忆/);
 
 
 // ── 项目实验：正常回合结束后走一次短整理，只写后台结果 ─────────────────────────
@@ -696,7 +787,7 @@ llmImpl = {
           ? { target: ref, feedbackType: 'execution_miss', currentText: '交付前先核对开头是否先给结论。', evidence: ['u0'], persistence: 'project_candidate' }
           : orgMode === 'sample'
             ? { target: ref, feedbackType: 'artifact_accept', evidence: ['u0'], persistence: 'project_candidate' }
-            : { target: 'new', feedbackType: 'spec_change', topicKey: '开头', currentText: '开头先给结论。', applicability: 'all_in_scope', conditions: [], evidence: ['u0'], persistence: 'project_candidate' };
+            : { target: 'new', feedbackType: 'spec_change', topicKey: '开头', currentText: '开头先给结论。', applicability: 'conditional', conditions: [{ key: 'taskKind', value: 'video' }, { key: 'seriesId', value: '口播' }, { key: 'phase', value: 'brief' }], evidence: ['u0'], persistence: 'project_candidate' };
         yield { type: 'text-delta', text: JSON.stringify({ changes: [change] }) };
         yield { type: 'usage', usage: { inputTokens: 12, outputTokens: 6 } };
         yield { type: 'finish', reason: { kind: 'stop' } };
@@ -810,11 +901,12 @@ 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.current.recall, null, '没发生过自动召回时不给判断依据');
 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.ok(ov.body.selected.records.some((row) => 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);
@@ -837,16 +929,62 @@ 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 });
+// 面板改正文：只动当前项目、必须带读到的版本，冲突和改名撞车都不覆盖
+const ovRow = ov.body.selected.records.find((row) => row.title === '开场先给结论');
+const ovEntry = await call('/lite-memory/entry', {
+  sessionId: 'session-overview', scopeKey: ov.body.current.key, id: ovRow.id,
+  title: '开场先给结论', body: '开场 2 句内给结论，结尾留 3 秒；本地端口 49631。', expectedRevision: ovRow.revision,
+});
+assert.equal(ovEntry.status, 200);
+assert.equal(ovEntry.body.ok, true);
+assert.equal(ovEntry.body.title, '开场先给结论');
+assert.ok(ovEntry.body.revision > ovRow.revision, '改过就升版本');
+const ovKept = store.readEntry(store.scopeOf(ovCwd), ovRow.id);
+assert.deepEqual(ovKept.tags, ['口播', '开头'], '只改标题正文，标签等字段保持');
+assert.equal(ovKept.kind, 'note');
+const ovEditedBody = await call('/lite-memory/body', { sessionId: 'session-overview', title: '开场先给结论', scopeKey: ov.body.current.key });
+assert.equal(ovEditedBody.body.body, '开场 2 句内给结论，结尾留 3 秒；本地端口 49631。');
+const ovStale = await call('/lite-memory/entry', {
+  sessionId: 'session-overview', scopeKey: ov.body.current.key, id: ovRow.id,
+  title: '开场先给结论', body: '被旧版本覆盖。', expectedRevision: ovRow.revision,
+});
+assert.equal(ovStale.status, 409);
+assert.equal(ovStale.body.retry, true, '版本过期要明说可以重试');
+const ovAfterStale = await call('/lite-memory/body', { sessionId: 'session-overview', title: '开场先给结论', scopeKey: ov.body.current.key });
+assert.equal(ovAfterStale.body.body, '开场 2 句内给结论，结尾留 3 秒；本地端口 49631。', '旧版本写不进去');
+const ovRenameClash = await call('/lite-memory/entry', {
+  sessionId: 'session-overview', scopeKey: ov.body.current.key, id: ovRow.id,
+  title: '封面留白', body: '开场 2 句内给结论，结尾留 3 秒；本地端口 49631。', expectedRevision: ovEntry.body.revision,
+});
+assert.equal(ovRenameClash.status, 400, '改名撞上另一条要拒绝');
+assert.match(ovRenameClash.body.reason, /同名/);
+const ovOtherEdit = await call('/lite-memory/entry', {
+  sessionId: 'session-overview', scopeKey: ov.body.current.key, id: ovOther.body && ovOther.body.record ? ovOther.body.record.id : 'mem_other',
+  title: '别的项目', body: '想跨项目改。', expectedRevision: 1,
+});
+assert.equal(ovOtherEdit.status >= 400, true, '别的项目不能从这里改');
+const ovGlobalRow = ovGlobal.body.selected.records.find((row) => row.title === '观察全局');
+const ovGlobalEdit = await call('/lite-memory/entry', {
+  sessionId: 'session-overview', scopeKey: 'global', id: ovGlobalRow.id,
+  title: '观察全局', body: '想改全局。', expectedRevision: ovGlobalRow.revision,
+});
+assert.equal(ovGlobalEdit.status, 409, '全局层在项目会话里只读');
+assert.equal((await call('/lite-memory/entry', { sessionId: 'session-overview', scopeKey: ov.body.current.key, id: ovRow.id, title: '', body: 'x', expectedRevision: 1 })).status, 400);
+
+// 详情按服务端枚举过的 scopeKey 取；内部路径、未知键一律不放行。
+// 宫殿里点开一条只走这个只读入口：不改记忆、不记用量、不占额度。
+const ovStateFile = path.join(store.scopeOf(ovCwd).dir, 'state.json');
+const ovStateBefore = fs.readFileSync(ovStateFile, 'utf8');
+const ovBody = await call('/lite-memory/body', { sessionId: 'session-overview', title: '开场先给结论', scopeKey: ov.body.current.key });
 assert.equal(ovBody.status, 200);
-assert.equal(ovBody.body.body, '开场三句内给结论。');
+assert.equal(fs.readFileSync(ovStateFile, 'utf8'), ovStateBefore, '面板看正文不写状态');
+assert.equal(ovBody.body.body, '开场 2 句内给结论，结尾留 3 秒；本地端口 49631。');
 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 });
+const ovOtherBody = await call('/lite-memory/body', { sessionId: 'session-overview', title: '别的项目', 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/body', { sessionId: 'session-overview', title: '开场先给结论', scopeKey: 'nope' })).status, 404);
+assert.equal((await call('/lite-memory/body', { sessionId: 'session-overview', title: '开场先给结论', 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-'));
@@ -860,27 +998,27 @@ assert.equal(fs.existsSync(path.join(store.scopeOf(ovUnknownCwd).dir, 'state.jso
 
 // 实验条目也画进图里，但只有面板能看见；普通读取面仍然拿不到
 state.transact(store.scopeOf(ovCwd), {}, (draft) => {
-  const row = draft.entries.find((entry) => entry.id === ovSecond.id);
+  const row = draft.entries.find((entry) => (entry.current || {}).title === '封面留白');
   row.origin = 'project_evolution';
-  row.maintenance = { ...(row.maintenance || {}), learning: { state: 'trial', source: 'evolution' } };
+  row.maintenance = { ...(row.maintenance || {}), learning: { state: 'trial', source: 'evolution', specDigest: 'seeded' } };
   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);
+assert.equal(ovExperimental.body.selected.records.find((row) => row.title === '封面留白').experimental, true);
+assert.equal(store.loadIndex(store.scopeOf(ovCwd), { allowExperimental: true }).entries.some((row) => row.title === '封面留白'), true);
 
 // 归档不是死数字：总数诚实，列表单独取，正文还能按 id 打开
 state.transact(store.scopeOf(ovCwd), {}, (draft) => {
-  const row = draft.entries.find((entry) => entry.id === ovSecond.id);
+  const row = draft.entries.find((entry) => (entry.current || {}).title === '封面留白');
   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(ovArchived.body.selected.records.some((row) => row.title === '封面留白'), false);
+assert.equal(ovArchived.body.selected.archived.some((row) => row.title === '封面留白'), true);
+const ovArchivedBody = await call('/lite-memory/body', { sessionId: 'session-overview', title: '封面留白', scopeKey: ovArchived.body.selected.key });
 assert.equal(ovArchivedBody.status, 200);
 assert.equal(ovArchivedBody.body.status, 'archived');
 assert.equal(ovArchivedBody.body.body, '右侧留白。');