dsh-lite-memory 0.18.33 → 0.18.35

package/store.js

@@ -2595,16 +2595,16 @@ export function routeScope(draft, options = {}) {
       requiredConditions: [{ key: 'machine', value: '' }, { key: 'runtime', value: '' }],
     };
   };
-  /** 人明确点过「就存全局」才算数；模型自己提的 global 不抵消本机痕迹。 */
+  /** 人明确点过「就存全局」才算数；模型自己提的 scope 只是提案。 */
   const humanConfirmed = options.humanScope === true || source.scopeConfirmed === true;
+  /** 实验/自动整理的产物永远留在项目层：它们没有「用户要求跨项目」这层依据。 */
+  const autoOrigin = source.origin === 'project_evolution' || source.origin === 'model_drafted';
   /** 「本项目里…」是项目事实的措辞，类别写成偏好/流程也不能这样进通用层。 */
   const projectBound = projectBoundText(source);
   if (durability === 'task') return { ...base, needsScope: true, reasonCode: 'task_state' };
-  if (explicit) {
+  if (explicit && (humanConfirmed || !autoOrigin)) {
     /**
-     * 显式 scope 代表「用户这个消息里要的那一层」：这是唯一能让全局层落地的输入，
-     * 所以不能再按模型自荐降级，只有本机痕迹和项目事实两种硬冲突能改落点。
-     * 没显式 scope 时才用 memoryClass 提案，缺可搬依据的流程留在项目层。
+     * 只有人确认过的 scope 才代表「用户这个消息里要的那一层」；模型写进参数的 scope 只是提案。
      */
     if (explicit === 'global' && !humanConfirmed) {
       if (machineConflict) return fallbackToProject('machine_bound_scope');
@@ -2631,21 +2631,28 @@ export function routeScope(draft, options = {}) {
     }
     return { ...base, chosenScope: 'project', reasonCode: 'class_project_fact' };
   }
+  /**
+   * 自动归类只能决定「它像哪类」，不能决定跨项目；默认落点一律是当前项目。
+   * 具体冲突（本机痕迹、「本项目」措辞）仍按原原因报告，其余全局结论统一降级。
+   */
+  const globalOutcome = (reasonCode) => (humanConfirmed
+    ? { ...base, chosenScope: 'global', reasonCode }
+    : fallbackToProject('model_class_project'));
   if (cls === 'personal_preference') {
     /** 偏好也分「我的习惯」和「这台机器上的习惯」：后者绑机器，不进通用层。 */
     if (machineConflict) return fallbackToProject('machine_bound_preference');
     /** 说了「本项目」的偏好其实是项目约定，类别写错也不能跨项目。 */
     if (projectBound) return fallbackToProject('project_bound_preference');
-    return { ...base, chosenScope: 'global', reasonCode: 'class_personal_preference' };
+    return globalOutcome('class_personal_preference');
   }
   if (cls === 'portable_procedure') {
     if (machineConflict) return fallbackToProject('machine_bound_procedure');
     if (projectBound) return fallbackToProject('project_bound_procedure');
     /** 带适用环境条件的本机流程：条件成立时才用，换台机器自然不生效。 */
-    if (envScoped) return { ...base, chosenScope: 'global', reasonCode: 'machine_scoped_procedure' };
+    if (envScoped) return globalOutcome('machine_scoped_procedure');
     /** 说能搬去别的项目，就要有能搬的依据；没有就先留在本项目。 */
     if (!evidence) return fallbackToProject('unbound_evidence');
-    return { ...base, chosenScope: 'global', reasonCode: 'class_portable_procedure' };
+    return globalOutcome('class_portable_procedure');
   }
   if (projectBound) return fallbackToProject('project_bound_environment');
   const conditions = view.normalizeConditions(source.conditions) || [];
@@ -2658,7 +2665,7 @@ export function routeScope(draft, options = {}) {
       requiredConditions: [{ key: 'machine', value: '' }, { key: 'runtime', value: '' }],
     };
   }
-  return { ...base, chosenScope: 'global', reasonCode: 'class_environment_fact' };
+  return globalOutcome('class_environment_fact');
 }
 
 function locateInLayers(projectScope, id) {
@@ -2738,7 +2745,7 @@ function bindSameTopic(projectScope, ref) {
 const CONFLICT_LIMIT = 20;
 
 /** 待办里留一份可重放的草稿：面板能直接另存，不用用户回忆刚才想记什么。 */
-const CONFLICT_DRAFT_KEYS = ['title', 'summary', 'body', 'when', 'kind', 'tags', 'conditions', 'applicability', 'topicKey', 'source', 'origin'];
+const CONFLICT_DRAFT_KEYS = ['title', 'summary', 'body', 'when', 'kind', 'tags', 'conditions', 'applicability', 'selection', 'triggers', 'links', 'topicKey', 'source', 'origin'];
 function conflictDraftOf(draft) {
   const out = {};
   if (!draft || typeof draft !== 'object') return out;
@@ -2754,6 +2761,10 @@ function conflictDraftOf(draft) {
     else if (key === 'conditions') out.conditions = Array.isArray(value) ? value.slice(0, 8) : undefined;
     else if (key === 'applicability') out.applicability = value;
     else if (key === 'topicKey') out.topicKey = normalizeText(value, 80);
+    /** 适用范围、召回触发词与关联整份重放：经过待裁决不能改变语义。 */
+    else if (key === 'selection') out.selection = value && typeof value === 'object' && !Array.isArray(value) ? { ...value } : null;
+    else if (key === 'triggers') out.triggers = Array.isArray(value) ? value.slice(0, 8).map((item) => normalizeText(item, 40)).filter(Boolean) : [];
+    else if (key === 'links') out.links = Array.isArray(value) ? value.slice(0, 3).map((item) => (item && typeof item === 'object' ? { ...item } : null)).filter(Boolean) : [];
     else if (key === 'source') out.source = value;
     else if (key === 'origin') out.origin = value;
   }
@@ -2821,30 +2832,35 @@ function staleDraft(row, ref) {
 
 /** 确认另存：用队列里的草稿按 distinct 重放一次，成功后按 id 出队。 */
 export function resolveConflict(scope, ref, options = {}) {
-  const row = conflictRowLocked(scope, ref);
-  if (!row) return { ok: false, reason: '这条待裁决已经不在了，刷新面板看看' };
-  if (staleDraft(row, ref)) return { ok: false, reasonCode: 'stale_draft', reason: '这条待裁决又更新了，刷新后再处理' };
-  const draft = { ...(row.draft || {}), resolution: 'distinct', writeMode: options.writeMode === 'append' ? 'append' : 'patch' };
-  if (scope.key === 'global') draft.scope = 'global';
-  else draft.scope = 'project';
-  if (!draft.title) draft.title = row.title;
-  const result = saveEntry(scope, draft);
-  if (result && result.needsResolution) return { ok: false, reason: '还是相近：换一个标题或等确认', result };
-  if (result && result.needsScope) {
-    const reason = result.reasonCode === 'memory_disabled' ? '这层记忆已关闭' : '这条记忆的适用范围还没定，先说明当前环境';
-    return { ok: false, reason, result };
-  }
-  clearConflictLocked(scope, { id: row.id });
-  return { ok: true, result, record: result && result.record };
+  /** 版本检查、另存和出队必须在同一临界区：中间被新反馈改写时，旧面板不能批准新草稿。 */
+  return withLocks([scope, globalScope()], () => {
+    const row = conflictRowLocked(scope, ref);
+    if (!row) return { ok: false, reason: '这条待裁决已经不在了，刷新面板看看' };
+    if (staleDraft(row, ref)) return { ok: false, reasonCode: 'stale_draft', reason: '这条待裁决又更新了，刷新后再处理' };
+    const draft = { ...(row.draft || {}), resolution: 'distinct', writeMode: options.writeMode === 'append' ? 'append' : 'patch' };
+    if (scope.key === 'global') draft.scope = 'global';
+    else draft.scope = 'project';
+    if (!draft.title) draft.title = row.title;
+    const result = saveEntry(scope, draft);
+    if (result && result.needsResolution) return { ok: false, reason: '还是相近：换一个标题或等确认', result };
+    if (result && result.needsScope) {
+      const reason = result.reasonCode === 'memory_disabled' ? '这层记忆已关闭' : '这条记忆的适用范围还没定，先说明当前环境';
+      return { ok: false, reason, result };
+    }
+    clearConflictLocked(scope, { id: row.id });
+    return { ok: true, result, record: result && result.record };
+  });
 }
 
 /** 删掉待裁决：用户决定不再另存。 */
 export function dropConflict(scope, ref) {
-  const row = conflictRowLocked(scope, ref);
-  if (!row) return { ok: false, reason: '这条待裁决已经不在了，刷新面板看看' };
-  if (staleDraft(row, ref)) return { ok: false, reasonCode: 'stale_draft', reason: '这条待裁决又更新了，刷新后再处理' };
-  clearConflictLocked(scope, { id: row.id });
-  return { ok: true };
+  return withLocks([scope, globalScope()], () => {
+    const row = conflictRowLocked(scope, ref);
+    if (!row) return { ok: false, reason: '这条待裁决已经不在了，刷新面板看看' };
+    if (staleDraft(row, ref)) return { ok: false, reasonCode: 'stale_draft', reason: '这条待裁决又更新了，刷新后再处理' };
+    clearConflictLocked(scope, { id: row.id });
+    return { ok: true };
+  });
 }
 
 /** 当前层还有几条没处理的冲突。 */

package/test/contract.test.mjs

@@ -377,10 +377,15 @@ assert.equal((await call('/lite-memory/unknown', { cwd })).status, 404);
 assert.equal((await call('/lite-memory/keep', {}, { method: 'GET' })).status, 405);
 
 // ── global layer ─────────────────────────────────────────────────────────────
-const global = await exec('memory_save', { title: '回复用中文', summary: '用户要求回复用中文', scope: 'global' });
-assert.equal(global.scope, 'global');
-assert.equal(global.scopeNote, undefined, '正常落全局不该带降级说明');
-assert.match(render('memory_save', {}, global), /^memory · saved \[global\] "回复用中文"$/);
+const proposedGlobal = await exec('memory_save', { title: '回复语言模型提案', summary: '模型建议回复语言用中文', scope: 'global' });
+assert.equal(proposedGlobal.scope, 'project', '模型自填 scope 只是提案，默认落项目层');
+assert.match(proposedGlobal.scopeNote, /模型归类只是提案/, '降级要能解释');
+const global = store.saveEntry(store.globalScope(), {
+  title: '回复用中文', summary: '用户要求回复用中文', body: '回复默认用中文', scopeConfirmed: true,
+});
+assert.ok(global.record, '人明确要全局时才落全局层');
+assert.equal(global.chosenScope, 'global');
+assert.equal(exec === null, false);
 
 // 显式写 global 也不再被悄无声息地改层：本机痕迹和项目事实各有一条能解释的降级。
 const machineGlobal = await exec('memory_save', {
@@ -402,7 +407,7 @@ const factGlobal = await exec('memory_save', {
 assert.equal(factGlobal.scope, 'project');
 assert.match(factGlobal.scopeNote, /按项目事实留在项目层/);
 const globalSearch = await exec('memory_search', { query: '回复用中文' });
-assert.equal(globalSearch.count, 1);
+assert.ok(globalSearch.count >= 1, '全局层条目能被搜到');
 assert.match(render('memory_search', {}, globalSearch), /\[global\] 「/);
 assert.equal(typeof globalThis.__liteMemoryStats, 'function');
 const stats = globalThis.__liteMemoryStats(cwd);
@@ -1050,10 +1055,9 @@ await defs.get('memory_save').execute(
   { title: '发布窗口', summary: '只在周四晚上发版', body: '周四晚上再发版。', when: '周四晚上' },
   { agent: ovAgent },
 );
-await defs.get('memory_save').execute(
-  { title: '观察全局', summary: '跨项目通用说明', body: '全局正文。', scope: 'global' },
-  { agent: ovAgent },
-);
+store.saveEntry(store.globalScope(), {
+  title: '观察全局', summary: '跨项目通用说明', body: '全局正文。', scopeConfirmed: true,
+});
 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 } } } },
@@ -1215,7 +1219,7 @@ const cfCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-contract-confli
 sessionCwds.set('session-conflict-panel', cfCwd);
 sessionCwds.set('session-conflict-other', fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-contract-conflict-other-')));
 const cfAgent = { id: 'session-conflict-panel', cwd: cfCwd, session: { id: 'session-conflict-panel', header: { cwd: cfCwd } } };
-await defs.get('memory_save').execute({ title: '发布窗口', summary: '只在周四晚上发版', body: '周四晚上再发版。', scope: 'global' }, { agent: cfAgent });
+store.saveEntry(store.globalScope(), { title: '发布窗口', summary: '只在周四晚上发版', body: '周四晚上再发版。', scopeConfirmed: true });
 const cfSave = await defs.get('memory_save').execute({ title: '发布窗口', summary: '本项目周五发版', body: '周五发版。' }, { agent: cfAgent });
 assert.equal(cfSave.needsResolution, true);
 assert.equal(store.loadIndex(store.scopeOf(cfCwd)).entries.length, 0, '没确认前不落库');
@@ -1276,7 +1280,7 @@ const cfgCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-contract-confl
 sessionCwds.set('session-conflict-global', cfgCwd);
 const cfgAgent = { id: 'session-conflict-global', cwd: cfgCwd, session: { id: 'session-conflict-global', header: { cwd: cfgCwd } } };
 await defs.get('memory_save').execute({ title: '命名规则', summary: '项目里用短横线', body: '短横线。' }, { agent: cfgAgent });
-const cfgSave = await defs.get('memory_save').execute({ title: '命名规则', summary: '所有项目用下划线', body: '下划线。', scope: 'global' }, { agent: cfgAgent });
+const cfgSave = store.saveEntry(store.scopeOf(cfgCwd), { title: '命名规则', summary: '所有项目用下划线', body: '下划线。', scope: 'global', scopeConfirmed: true });
 assert.equal(cfgSave.needsResolution, true);
 const cfgView = await call('/lite-memory/overview', { sessionId: 'session-conflict-global', scopeKey: 'global' });
 assert.equal(cfgView.body.selected.conflicts.length, 1, '全局层也要有这条待裁决');

package/test/crossing.test.mjs

@@ -44,12 +44,18 @@ const idsOfPrev = (scope) => {
 };
 
 // ── S03 范围路由 ────────────────────────────────────────────────────────────
-await test('S03 个人偏好没有显式范围就进全局层，项目层不落副本', () => {
+await test('S03 个人偏好：模型自动归类留项目层，人明确要全局才落全局', () => {
   const scope = fresh('route-pref');
-  const saved = saveEntry(scope, { title: '回答用中文', summary: '回复语言偏好', body: '中文、简短', memoryClass: 'personal_preference' });
+  const automatic = saveEntry(scope, { title: '回答用中文（自动）', summary: '回复语言偏好', body: '中文、简短（自动）', memoryClass: 'personal_preference' });
+  assert.equal(automatic.chosenScope, 'project', '模型归类只是提案，不能自己跨项目');
+  assert.equal(automatic.reasonCode, 'model_class_project');
+  assert.equal(idsOf(scope).length, 1);
+  const saved = saveEntry(scope, {
+    title: '回答用中文', summary: '回复语言偏好', body: '中文、简短',
+    memoryClass: 'personal_preference', scopeConfirmed: true, resolution: 'distinct',
+  });
   assert.equal(saved.chosenScope, 'global');
   assert.equal(saved.reasonCode, 'class_personal_preference');
-  assert.equal(idsOf(scope).length, 0);
   assert.equal(stateOf(globalScope()).entries.filter((row) => row.current.title === '回答用中文').length, 1);
 });
 
@@ -100,7 +106,7 @@ await test('S03 设备事实没给设备条件就返回 needsScope，不落盘',
 await test('S03 设备事实带条件进全局层且是条件适用', () => {
   const scope = fresh('route-env-ok');
   const saved = saveEntry(scope, {
-    title: '本机 Node', summary: '本机 Node 版本', body: 'v24', memoryClass: 'environment_fact',
+    title: '本机 Node', summary: '本机 Node 版本', body: 'v24', memoryClass: 'environment_fact', scopeConfirmed: true,
     conditions: [{ key: 'machine', value: 'mac-mini' }],
   });
   assert.equal(saved.chosenScope, 'global');
@@ -434,7 +440,32 @@ await test('S12 待裁决留可重放草稿，面板确认另存后才落库', (
   assert.equal(pendingConflictsOf(scope), 0);
   assert.equal(loadIndex(scope).entries.length, 1);
   assert.equal(loadIndex(scope).entries[0].body, '项目补充');
+  assert.equal(loadIndex(scope).entries[0].when, '本仓库', 'when 经过待裁决不能丢');
   assert.equal(dropConflict(scope, '不存在').ok, false);
 });
 
+await test('S12 经过待裁决另存不改变适用范围、触发词和关联', () => {
+  const scope = fresh('conflict-semantics');
+  const globalOne = saveEntry(globalScope(), { title: '发票抬头规则', summary: '开票信息固定', body: '全局版本', resolution: 'distinct' });
+  const linked = saveEntry(globalScope(), { title: '生效核验顺序', summary: '先验规则再验页面', body: '先验规则', resolution: 'distinct' });
+  const near = saveEntry(scope, {
+    title: '发票抬头规则', summary: '本项目发票只认这套抬头', body: '项目版本',
+    selection: { mode: 'complete', artifactKey: 'artifact-invoice-v1' },
+    triggers: ['artifact-hookword'],
+    links: [{ type: 'related', id: linked.record.id }],
+    topicKey: 'invoice',
+  });
+  assert.equal(near.needsResolution, true);
+  const [row] = conflictsOf(scope);
+  assert.deepEqual(row.draft.selection, { mode: 'complete', artifactKey: 'artifact-invoice-v1', items: [] });
+  assert.deepEqual(row.draft.triggers, ['artifact-hookword']);
+  assert.deepEqual(row.draft.links, [{ type: 'related', id: linked.record.id }]);
+  const kept = resolveConflict(scope, { id: row.id, expectedRevision: row.revision });
+  assert.equal(kept.ok, true, JSON.stringify(kept));
+  const [record] = loadIndex(scope).entries;
+  assert.deepEqual(record.selection, { mode: 'complete', artifactKey: 'artifact-invoice-v1', items: [] });
+  assert.deepEqual(record.triggers, ['artifact-hookword']);
+  assert.deepEqual(record.links, [{ type: 'related', id: linked.record.id }]);
+});
+
 console.log(`crossing.test.mjs: ${passed} passed`);

package/test/layer-read.test.mjs

@@ -1,4 +1,4 @@
-import { fileURLToPath } from 'node:url'
+import { fileURLToPath } from 'node:url'
 import assert from 'node:assert/strict';
 import fs from 'node:fs';
 import { spawn } from 'node:child_process';
@@ -172,7 +172,7 @@ const globalDraft = store.saveEntry(store.scopeOf(projectB), {
   title: 'npm 发布凭据取用与发布后验版',
   summary: 'npm 发布用 account regrevia，发布后轮询 dist-tags 验版',
   body: '发布用 regrevia 身份；发完轮询 dist-tags.latest 判上线。',
-  memoryClass: 'personal_preference',
+  memoryClass: 'personal_preference', scope: 'global', scopeConfirmed: true,
 });
 assert.equal(globalDraft.chosenScope, 'global');
 const near = await exec('memory_save', {

package/test/learning.test.mjs

@@ -1036,6 +1036,54 @@ test('L03d2 代码任务学到的规则不会在数据库任务里生效', () =>
   assert.equal(db.reason, 'condition_mismatch');
 });
 
+test('L03d3 空项目的第一条反馈能带上真实任务范围保存', () => {
+  const parsed = learning.parseOutput(JSON.stringify({
+    changes: [{
+      target: 'new', feedbackType: 'spec_change', topicKey: '前端边框',
+      currentText: '前端页面默认采用细边框', applicability: 'all_in_scope', evidence: ['u0'],
+    }],
+  }), {
+    finish: { kind: 'stop' }, refs: { feedback: { u0: 'm1' }, rules: {} }, rules: [],
+    ranges: { taskKinds: [], series: [], projects: ['p'] },
+    expectedTarget: { scope: 'episode', projectId: 'p', episodeId: 'ep1', taskKind: 'code', phase: 'brief' },
+  });
+  assert.equal(parsed.ok, true, parsed.reason);
+  assert.equal(parsed.changes[0].applicability, 'conditional');
+  assert.deepEqual(parsed.changes[0].conditions, [{ key: 'taskKind', value: 'code' }], '采集阶段不该锁死长期适用范围');
+});
+
+test('L03d4 模型条件与采集任务范围冲突时拒绝，不生成永不生效的规则', () => {
+  const parsed = learning.parseOutput(JSON.stringify({
+    changes: [{
+      target: 'new', feedbackType: 'spec_change', topicKey: '迁移',
+      currentText: '先跑迁移再改代码', applicability: 'conditional',
+      conditions: [{ key: 'taskKind', value: 'database' }], evidence: ['u0'],
+    }],
+  }), {
+    finish: { kind: 'stop' }, refs: { feedback: { u0: 'm1' }, rules: {} }, rules: [],
+    ranges: { ...RANGES, taskKinds: ['code', 'database'] },
+    expectedTarget: { scope: 'episode', projectId: 'p', episodeId: 'ep1', taskKind: 'code' },
+  });
+  assert.equal(parsed.ok, false);
+  assert.match(parsed.reason, /冲突/);
+});
+
+test('L03d5 同一条件键的两个值不能都留下', () => {
+  const parsed = learning.parseOutput(JSON.stringify({
+    changes: [{
+      target: 'new', feedbackType: 'spec_change', topicKey: '阶段冲突',
+      currentText: '只在脚本阶段生效', applicability: 'conditional',
+      conditions: [{ key: 'phase', value: 'script' }, { key: 'phase', value: 'brief' }], evidence: ['u0'],
+    }],
+  }), {
+    finish: { kind: 'stop' }, refs: { feedback: { u0: 'm1' }, rules: {} }, rules: [],
+    ranges: { ...RANGES },
+    expectedTarget: { scope: 'episode', projectId: 'p', episodeId: 'ep1', taskKind: 'code', phase: 'brief' },
+  });
+  assert.equal(parsed.ok, false);
+  assert.match(parsed.reason, /条件/);
+});
+
 test('L03e 先按相关性排序再截断，输入顺序不挤掉真正相关的旧规则', () => {
   const rules = [];
   for (let index = 0; index < 32; index += 1) {
@@ -1360,4 +1408,43 @@ test('L10 整理器规则先稳定排序再取 8', () => {
   assert.equal(learning.orderOrganizerRules([], { limit: 3 }).length, 0);
 });
 
+/* 收敛：连续纠正同一主题只留一条现行规则；换栏目不适用；关掉再开还是同一现行版。 */
+test('B30 连续纠正同一规则收敛到一条现行版', () => {
+  const scope = fresh('converge');
+  enable(scope);
+  const firstEpisode = seedEpisode(scope, { sessionId: 'conv1', messageIds: ['cm1'] });
+  const firstStart = begin(scope, firstEpisode);
+  assert.equal(commitNew(scope, firstEpisode, firstStart, NEW_CHANGE).ok, true);
+  const id = ruleRows(scope)[0].id;
+  const bodies = ['开头两句内给结论。', '开头一句内给结论。'];
+  bodies.forEach((body, index) => {
+    const episode = seedEpisode(scope, { sessionId: `conv${index + 2}`, messageIds: [`cm${index + 2}`] });
+    const started = begin(scope, episode);
+    assert.equal(started.ok, true, started.reason);
+    const result = commitExisting(scope, episode, started, id, {
+      target: 'r0', feedbackType: 'spec_change', currentText: body, evidence: ['u0'],
+    });
+    assert.equal(result.ok, true, result.reason);
+  });
+  const rows = ruleRows(scope);
+  assert.equal(rows.length, 1, '同一主题不堆多份现行规则');
+  const current = rows[0];
+  assert.equal(current.id, id);
+  assert.match(current.body, /一句内给结论/);
+  assert.ok((current.versions || []).length <= 2, '旧版有上限');
+  const wrongColumn = view.eligibility(current, {
+    projectId: scope.key,
+    context: { seriesId: '字幕' },
+    task: { taskKind: 'video', seriesId: '字幕' },
+  }, 'auto');
+  assert.equal(wrongColumn.ok, false, '换栏目不适用');
+  store.setMemoryEnabled(scope, false, { operationId: 'conv-close' });
+  assert.equal(ruleRows(scope).length, 1, '关闭不清成果');
+  store.setMemoryEnabled(scope, true, { operationId: 'conv-open' });
+  const reopened = ruleOf(scope, id);
+  assert.equal(reopened.body, current.body);
+  assert.equal(reopened.revision, current.revision);
+  assert.equal(reopened.learning.state, current.learning.state);
+});
+
 console.log(`learning.test.mjs: ${passed} passed`);