dsh-lite-memory 0.11.1 → 0.15.0

package/store.js

@@ -96,6 +96,7 @@ function toFlat(entry) {
     revision: Number(entry.revision) || 1,
     status: entry.status === 'archived' ? 'archived' : 'active',
     origin: entry.origin || 'user_explicit',
+    ownerProjectId: typeof entry.ownerProjectId === 'string' ? entry.ownerProjectId : '',
     hits: Number(maintenance.hits) || 0,
     merges: Number(maintenance.merges) || 0,
     versions: Array.isArray(maintenance.versions) ? cloneJson(maintenance.versions) : [],
@@ -115,6 +116,7 @@ function fromFlat(record, status) {
     revision: Number(record.revision) || 1,
     status: status || (record.status === 'archived' ? 'archived' : 'active'),
     origin: typeof record.origin === 'string' && record.origin ? record.origin : 'user_explicit',
+    ownerProjectId: record.ownerProjectId || '',
     createdAt: record.created || at,
     updatedAt: at,
     current: {
@@ -154,7 +156,7 @@ function fromFlat(record, status) {
  * 由 state.js 拦成报告，这里不猜、不补空正文。
  */
 export function loadIndex(scope, options = {}) {
-  if (!fs.existsSync(path.join(scope.dir, 'state.json'))) {
+  if (!options.readOnly && !fs.existsSync(path.join(scope.dir, 'state.json'))) {
     const report = state.migrationReport(scope);
     if (report.required || report.adoptable.length) state.migrateLegacy(scope);
   }
@@ -176,6 +178,7 @@ export function loadIndex(scope, options = {}) {
     suppressions: JSON.parse(JSON.stringify(loaded.state.suppressions || [])),
     __evolution: state.evolutionOf(loaded.state),
     __tasks: anchor.normalizeTasks(state.evolutionOf(loaded.state).tasks),
+    __control: state.controlOf(loaded.state),
     __exists: loaded.exists === true,
   };
   index.__meta = {
@@ -273,6 +276,14 @@ function cleanTitle(value) {
   return String(value ?? '').replace(/\s+/g, ' ').trim();
 }
 
+/** 正文里的实现参数（尺寸/层级/字号）不算记忆：数到三次就要求重写成原则。 */
+const UI_SPEC_PATTERNS = [
+  /\bz-index\s*:\s*-?\d+/gi,
+  /\b(?:padding|margin|gap|font-size|line-height|border-radius|width|height|min-width|max-width|min-height|max-height|box-shadow)\s*:[^;\n]{0,32}\d/gi,
+  /\b\d+(?:\.\d+)?(?:px|rem|em)\b/gi,
+  /\bmin\(\s*\d/gi,
+];
+
 export function validSummary(summary) {
   const text = String(summary ?? '').replace(/\s+/g, ' ').trim();
   if (!text) return { ok: false, reason: '摘要为空' };
@@ -311,7 +322,11 @@ export function normalizeDraft(source, options = {}) {
   const body = String(draft.body ?? '').trim();
   const bodyBytes = Buffer.byteLength(body);
   if (bodyBytes > LIMITS.entryBytes) {
-    throw new Error(`正文 ${bodyBytes} 字节，超过单条 ${LIMITS.entryBytes} 字节；先精简，别让尾部条件被截掉`);
+    throw new Error(`正文 ${bodyBytes} 字节，超过单条 ${LIMITS.entryBytes} 字节；只留原则、判断规则和触发条件`);
+  }
+  if (has('body')) {
+    const concrete = UI_SPEC_PATTERNS.reduce((count, pattern) => count + (body.match(pattern) || []).length, 0);
+    if (concrete >= 3) throw new Error('正文太具体：记忆只留原则和触发条件，像素、字号、层级这类实现参数留在代码或文档里');
   }
   const kind = has('kind') ? textField(draft.kind, 20, '类型') : 'note';
   if (kind && !KINDS.includes(kind)) throw new Error(`类型只能是 ${KINDS.join(' / ')}`);
@@ -434,6 +449,17 @@ function bigrams(text) {
   return out;
 }
 
+/** 只靠这类高频两字词重合不算相关：查询里的实词必须自己命中。 */
+const STOP_GRAMS = new Set([
+  '这个', '那个', '怎么', '什么', '可以', '需要', '我们', '你们', '一下', '现在',
+  '然后', '还是', '就是', '已经', '没有', '不是', '要是', '如果', '因为', '所以',
+  '的话', '这里', '那里', '一个', '一些', '这样', '那样', '看看', '帮我看', '继续',
+]);
+
+const asciiWordsOf = (text) => normalizeText(text, 400).toLowerCase().match(/[a-z][a-z0-9_-]{1,}/g) || [];
+
+const wordIn = (pool, word) => new RegExp(`(^|[^a-z0-9])${word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}($|[^a-z0-9])`).test(pool);
+
 /** 查询按空格/标点切成段：多段按关键词处理，整句仍按相关度处理。 */
 function queryRuns(query) {
   return normalizeText(query, 400)
@@ -463,6 +489,13 @@ function matchesRun(item, runs) {
   let qualified = 0;
   let substantial = 0;
   for (const run of runs) {
+    /** 英文按整词匹配：git 不能因为共享 gi/it 就命中 digital。 */
+    if (/^[a-z][a-z0-9_-]+$/.test(run)) {
+      if (!wordIn(pool, run)) continue;
+      qualified += 1;
+      substantial += 1;
+      continue;
+    }
     const grams = bigrams(run);
     if (grams.size === 0) continue;
     let hit = 0;
@@ -842,23 +875,66 @@ function scoreQuery(item, grams, raw) {
     [(item.triggers || []).join(' '), MATCH_WEIGHT.tags],
   ];
   let score = 0;
+  let substantive = 0;
   for (const [text, weight] of fields) {
     if (!text) continue;
     const pool = bigrams(text);
     let shared = 0;
-    for (const gram of grams) if (pool.has(gram)) shared += 1;
+    for (const gram of grams) {
+      if (!pool.has(gram)) continue;
+      shared += 1;
+      if (!STOP_GRAMS.has(gram)) substantive += 1;
+    }
     score += shared * weight;
   }
   const plain = normalizeText(raw, 200).toLowerCase().replace(/\s+/g, '');
   if (plain && normalizeText(item.title, 200).toLowerCase().replace(/\s+/g, '').includes(plain)) score += 5;
   /** 触发词命中按整词算：用户说的那句话里带着它，就该搜得到。 */
-  if (plain && (item.triggers || []).some((trigger) => {
+  const triggerHit = Boolean(plain) && (item.triggers || []).some((trigger) => {
     const text = normalizeText(trigger, 200).toLowerCase().replace(/\s+/g, '');
     return Boolean(text) && plain.includes(text);
-  })) score += 4;
+  });
+  if (triggerHit) score += 4;
+  /** 纯英文查询必须按整词命中，避免 git 命中 digital 这种字面巧合；混合查询仍按中文实词判断。 */
+  const words = asciiWordsOf(raw);
+  const hasCjk = /[\u4e00-\u9fff]/.test(String(raw || ''));
+  if (words.length && !hasCjk) {
+    const pool = fields.map(([text]) => fieldText(text)).join('\n');
+    if (!words.some((word) => wordIn(pool, word))) return 0;
+  }
+  /** 只重合了「这个」「怎么」这类词，不算命中；触发词命中仍算。 */
+  if (substantive === 0 && !triggerHit && words.length === 0) return 0;
   return score;
 }
 
+/** 项目记忆总开关：读当前层，缺字段按开启。 */
+export function controlStatus(scope) {
+  const index = loadIndex(scope);
+  return { ...(index.__control || state.controlOf(null)) };
+}
+
+export function setMemoryEnabled(scope, enabled, options = {}) {
+  return withLock(scope, () => {
+    const before = loadIndex(scope);
+    const operationId = typeof options.operationId === 'string' ? options.operationId : '';
+    let applied = null;
+    try {
+      state.transact(scope, {
+        operationId,
+        expectCreate: !before.__exists,
+        expected: before.__exists ? { generation: before.generation, epoch: before.epoch } : null,
+      }, (draft) => {
+        applied = state.applyControl(draft, enabled);
+        return applied.changed ? { changed: true } : { changed: false };
+      });
+    } catch (error) {
+      if (error && error.code === 'conflict') return { ok: false, reason: '项目状态刚被改过，重试一次', retry: true };
+      return { ok: false, reason: error instanceof Error ? error.message : '记忆开关没有改动' };
+    }
+    return { ok: true, changed: Boolean(applied && applied.changed), ...controlStatus(scope) };
+  });
+}
+
 /**
  * 项目实验开关：权威状态里缺字段即关闭。状态只回可核验事实，不编学习分数。
  * 关闭时保留已完成成果；试用条目暂停，等新的有效反馈或明确管理动作再复核。
@@ -872,13 +948,26 @@ export function evolutionStatus(scope) {
     const phase = record.learning && typeof record.learning === 'object' ? record.learning.state : '';
     if (phase === 'active' || phase === 'trial' || phase === 'paused') counts[phase] += 1;
   }
-  return { ...config, counts };
+  const control = index.__control || state.controlOf(null);
+  return {
+    ...config,
+    /** 模型可见的 enabled 是有效值：总开关关掉时，自进化一律不运行。 */
+    enabled: config.enabled === true && control.enabled === true,
+    configuredEnabled: config.enabled === true,
+    memoryEnabled: control.enabled === true,
+    ownerProject: config.ownerProject || '',
+    counts,
+  };
 }
 
 export function setEvolution(scope, enabled, options = {}) {
   return withLock(scope, () => {
     const before = loadIndex(scope);
     const config = before.__evolution || {};
+    /** 总开关关掉后，自进化开关也不能改：先恢复本项目记忆。 */
+    if (!(before.__control || state.controlOf(null)).enabled) {
+      return { ok: false, code: 'memory_disabled', reason: '本项目记忆已关闭' };
+    }
     if (config.compatible === false) {
       return { ok: false, reason: '实验配置版本不认，先不要改动开关', compatible: false };
     }
@@ -913,6 +1002,7 @@ export function taskState(scope) {
 export function saveTaskState(scope, tasks, options = {}) {
   return withLock(scope, () => {
     const before = loadIndex(scope);
+    if (!(before.__control || state.controlOf(null)).enabled) return { ok: false, reason: '本项目记忆已关闭' };
     if (!before.__evolution.enabled) return { ok: false, reason: '实验还没开启' };
     const next = anchor.normalizeTasks(tasks);
     const operationId = typeof options.operationId === 'string' ? options.operationId : '';
@@ -964,6 +1054,9 @@ export function search(scope, query, limit = 4, options = {}) {
       const collect = (pool, archived) => {
         for (const item of pool) {
           if (!readableRecord(item, options, index)) continue;
+          /** 已暂停、已过期或待确认的学习规则不进入检索结果，除非明确要病史。 */
+          if (options.allowExperimental === true && options.history !== true
+            && isExperimentalRecord(item) && !view.experimentalUsable(item, options.now)) continue;
           const score = scoreQuery(item, grams, query);
           if (score <= 0) continue;
           if (keywordMode && !matchesRun(item, runs)) continue;
@@ -1184,7 +1277,7 @@ export function undoChange(scope, id, options = {}) {
       if (!record) continue;
       /** 旧回执不能撤掉别人后来的修改：版本对不上就明确拒绝。 */
       if (options.expectedRevision !== undefined && Number(record.revision) !== Number(options.expectedRevision)) {
-        throw new state.StateError('conflict', `这条记忆已经更新到第 ${record.revision} 版`);
+        throw new state.StateError('conflict', '这条记忆已经被更新过，刷新后再改');
       }
       const versions = record.versions || [];
       const last = versions[versions.length - 1];
@@ -1282,9 +1375,9 @@ export function findAnywhere(id) {
 }
 
 /** 按 id 在项目层与全局层里找位置，不靠文案猜作用域；管理动作也要看得见已归档的条目。 */
-export function locate(scope, id) {
+export function locate(scope, id, options = {}) {
   for (const source of [scope, globalScope()]) {
-    const index = loadIndex(source);
+    const index = loadIndex(source, options);
     const active = index.entries.find((item) => item.id === id);
     if (active) return { scope: source, record: active, archived: false };
     const archived = index.archived.find((item) => item.id === id);
@@ -1571,7 +1664,8 @@ export function renderIndex(entries, budget = 400) {
     const stale = now - last > staleMs;
     const stateTag = item.state === 'archived' ? ' · 已归档' : item.state === 'needs_context' ? ' · 适用范围待确认' : item.state === 'not_applicable' ? ' · 当前条件不适用' : '';
     const originTag = item.origin === 'project_evolution' ? ' · 实验' : '';
-    const head = `${item.scope === 'global' ? '[全局] ' : ''}${item.id} ${item.title}${item.when ? `（${item.when}）` : ''} · 第 ${item.revision || 1} 版${originTag}${stateTag}`;
+    const tag = item.scope === 'global' ? '[global]' : item.scopeName ? `[${item.scopeName}]` : '';
+    const head = `${tag ? `${tag} ` : ''}${item.id} ${item.title}${item.when ? `（${item.when}）` : ''}${originTag}${stateTag}`;
     const line = stale ? `- ${head}` : `- ${head}｜${item.summary}`;
     if (used + line.length > budget) break;
     lines.push(line);
@@ -1882,7 +1976,7 @@ function bindSameTopic(projectScope, ref) {
   const record = loadIndex(source).entries.find((item) => item.id === ref.id);
   if (!record) return { error: `sameTopicAs 指向的记忆不存在：${ref.id}` };
   if (Number(ref.revision) !== Number(record.revision || 1)) {
-    return { error: `sameTopicAs 的版本不对：${ref.id} 当前是第 ${record.revision || 1} 版` };
+    return { error: `sameTopicAs 的目标已经改过：${ref.id}` };
   }
   return { topicKey: view.topicSlot(record) };
 }
@@ -1893,6 +1987,10 @@ function bindSameTopic(projectScope, ref) {
  */
 export function saveEntry(projectScope, source) {
   return withLocks([projectScope, globalScope()], () => {
+    const control = loadIndex(projectScope).__control || state.controlOf(null);
+    if (!control.enabled) {
+      return { needsScope: true, chosenScope: '', reasonCode: 'memory_disabled', requiredConditions: [], needsResolution: false, similarList: [], draft: null };
+    }
     const routed = routeScope(source, { project: projectScope });
     const draft = (() => {
       try { return normalizeDraft({ ...source, title: source && source.title }); } catch { return null; }
@@ -2166,6 +2264,9 @@ function driveMove(projectScope, intent, options = {}) {
  * 协调文件里带项目身份与两侧 epoch：换项目续跑会被拒绝，续跑也不再靠猜。
  */
 export function move(projectScope, id, options = {}) {
+  if (!(loadIndex(projectScope).__control || state.controlOf(null)).enabled) {
+    throw new state.StateError('conflict', '本项目记忆已关闭，先开启再整理');
+  }
   return state.withRootLock(() => {
     const existing = state.readMoveIntent();
     if (existing) {
@@ -2183,6 +2284,10 @@ export function move(projectScope, id, options = {}) {
     const sourceScope = projectRecord ? projectScope : globalScope();
     const sourceIndex = projectRecord ? projectIndex : globalIndex;
     const record = projectRecord || globalRecord;
+    /** 实验记录只能在原项目内用：普通移动不能把它带进全局层。 */
+    if (record.origin === EXPERIMENTAL_ORIGIN && options.target === 'global') {
+      throw new state.StateError('conflict', '实验规则不能直接搬到全局，先采纳为普通项目规范');
+    }
     const targetScope = options.target === 'global' ? globalScope() : projectScope;
     if (targetScope.dir === sourceScope.dir) throw new state.StateError('conflict', '源和目标在同一层');
     const targetIndex = loadIndex(targetScope);
@@ -2289,7 +2394,7 @@ function learningRuleView(record) {
  * 普通记忆读取面不会调用这个入口。
  */
 export function learningSnapshot(scope, options = {}) {
-  const index = loadIndex(scope);
+  const index = loadIndex(scope, options);
   const evolution = index.__evolution;
   const rules = learningRulesOf(index).map(learningRuleView);
   return {
@@ -2403,6 +2508,7 @@ export function commitLearning(scope, batch = {}) {
   if (!operationId) return { ok: false, reason: '缺少提交标识' };
   if (changes.length > learning.LIMITS.maxChanges) return { ok: false, reason: '一次改动太多' };
   return withLock(scope, () => {
+    if (!(loadIndex(scope).__control || state.controlOf(null)).enabled) return { ok: false, reason: '本项目记忆已关闭' };
     let receipt = null;
     try {
       const result = state.transact(scope, {
@@ -2467,6 +2573,7 @@ export function commitLearning(scope, batch = {}) {
                 existing: flat,
                 change,
                 evidence: { ...evidence, explicitLongTerm: Boolean(batch.explicitLongTerm) },
+                specChanged: merged.specChanged === true,
                 now,
               }),
               specDigest: merged.digest,
@@ -2486,10 +2593,6 @@ export function commitLearning(scope, batch = {}) {
             entry.updatedAt = at;
             entry.maintenance = { ...(entry.maintenance || {}), learning: merged.learning };
           } else {
-            if (currentRules.length + (touched + 1) > learning.LIMITS.rules) throw new Error('项目实验规则已经到上限');
-            const pending = currentRules.filter((entry) => toFlat(entry).learning?.state === 'pending').length;
-            if (pending >= learning.LIMITS.pending) throw new Error('待确认候选已经到上限');
-            const merged = learning.mergeChange(null, change, { now });
             const evidence = {
               sourceType: 'human_feedback',
               feedbackType: change.feedbackType,
@@ -2498,11 +2601,57 @@ export function commitLearning(scope, batch = {}) {
               messageIds: (batch.messageIds || []).slice(-3),
               at,
             };
+            const merged = learning.mergeChange(null, change, { now });
+            /** 同主题、同条件的新规则并进已有条目：整理器换个措辞不该长出第二条。 */
+            const signature = (list) => (Array.isArray(list) ? list : [])
+              .map((row) => `${row.key}=${row.value}`).sort().join('\u0000');
+            const duplicate = merged.current.topicKey
+              ? currentRules.find((row) => {
+                const flat = toFlat(row);
+                return flat.topicKey === merged.current.topicKey
+                  && signature(flat.conditions) === signature(merged.current.conditions)
+                  && flat.applicability === merged.current.applicability;
+              })
+              : null;
+            if (duplicate) {
+              const flat = toFlat(duplicate);
+              const rem = learning.mergeChange(flat, change, { now });
+              rem.learning = {
+                ...learning.nextLearningState({
+                  existing: flat,
+                  change,
+                  evidence: { ...evidence, explicitLongTerm: Boolean(batch.explicitLongTerm) },
+                  specChanged: rem.specChanged === true,
+                  now,
+                }),
+                specDigest: rem.digest,
+                versions: rem.learning.versions,
+              };
+              duplicate.current = {
+                ...duplicate.current,
+                title: rem.current.title,
+                summary: rem.current.summary,
+                body: rem.current.body,
+                when: rem.current.when,
+                applicability: rem.current.applicability,
+                conditions: rem.current.conditions,
+                topicKey: rem.current.topicKey,
+              };
+              duplicate.revision = Number(duplicate.revision) + 1;
+              duplicate.updatedAt = at;
+              duplicate.maintenance = { ...(duplicate.maintenance || {}), learning: rem.learning };
+              touched += 1;
+              continue;
+            }
+            if (currentRules.length + (touched + 1) > learning.LIMITS.rules) throw new Error('项目实验规则已经到上限');
+            const pending = currentRules.filter((entry) => toFlat(entry).learning?.state === 'pending').length;
+            if (pending >= learning.LIMITS.pending) throw new Error('待确认候选已经到上限');
             merged.learning = {
               ...learning.nextLearningState({
                 existing: { learning: merged.learning },
                 change,
                 evidence: { ...evidence, explicitLongTerm: Boolean(batch.explicitLongTerm) },
+                specChanged: merged.specChanged === true,
                 now,
               }),
               specDigest: merged.digest,
@@ -2523,6 +2672,7 @@ export function commitLearning(scope, batch = {}) {
               selection: null,
               links: [],
               origin: EXPERIMENTAL_ORIGIN,
+              ownerProjectId: scope.key,
               reviewState: 'active',
               created: at,
               updated: at,
@@ -2536,8 +2686,9 @@ export function commitLearning(scope, batch = {}) {
               checks: [],
               learning: merged.learning,
             };
-            draft.entries.push(fromFlat(flat));
-            currentRules.push(flat);
+            const created = fromFlat(flat);
+            draft.entries.push(created);
+            currentRules.push(created);
             touched += 1;
             continue;
           }
@@ -2603,12 +2754,19 @@ export function recordLearningFailure(scope, options = {}) {
   });
 }
 
+/** 管理面写操作的统一闸门：总开关关掉时服务端直接拒绝，不写盘也不返回旧正文。 */
+function managementClosed(scope) {
+  const index = loadIndex(scope);
+  return !(index.__control || state.controlOf(null)).enabled;
+}
+
 /** 删除：仍按管理面看到的版本比对，删掉正文与旧版本，只留审计回执。 */
 export function removeLearningRule(scope, id, options = {}) {
   const expectedRevision = Number(options.expectedRevision);
   const operationId = String(options.operationId || '');
   const at = new Date(options.now || Date.now()).toISOString();
   return withLock(scope, () => {
+    if (managementClosed(scope)) return { ok: false, code: 'memory_disabled', reason: '本项目记忆已关闭' };
     try {
       const result = state.transact(scope, { operationId }, (draft) => {
         const evolution = draft.experimental && draft.experimental.projectEvolution;
@@ -2621,18 +2779,19 @@ export function removeLearningRule(scope, id, options = {}) {
         entry.status = 'archived';
         entry.updatedAt = at;
         entry.current = { ...entry.current, body: '', summary: '' };
-        entry.maintenance = {
-          ...(entry.maintenance || {}),
-          learning: {
-            ...(flat.learning || {}),
-            state: 'paused',
-            blockedReason: 'deleted',
-            pausedBy: 'management',
-            pausedAt: at,
-            versions: [],
-            specDigest: '',
-          },
+        const deletedLearning = {
+          ...(flat.learning || {}),
+          state: 'paused',
+          blockedReason: 'deleted',
+          pausedBy: 'management',
+          pausedAt: at,
+          versions: [],
+          specDigest: '',
         };
+        /** 删掉的规范正文不能再从 lastText 里漏出来。 */
+        delete deletedLearning.lastText;
+        delete deletedLearning.trialUntil;
+        entry.maintenance = { ...(entry.maintenance || {}), learning: deletedLearning };
         addLearningReceipt(evolution, learning.receiptOf({ operationId, episodeId: flat.learning?.evidence?.[0]?.episodeId || '', status: 'deleted', changes: 1, at }));
         return { changed: true, kind: 'learning_delete' };
       });
@@ -2651,6 +2810,7 @@ export function undoLearningChange(scope, id, options = {}) {
   const now = options.now || Date.now();
   const at = new Date(now).toISOString();
   return withLock(scope, () => {
+    if (managementClosed(scope)) return { ok: false, code: 'memory_disabled', reason: '本项目记忆已关闭' };
     try {
       const result = state.transact(scope, { operationId }, (draft) => {
         const evolution = draft.experimental && draft.experimental.projectEvolution;
@@ -2696,6 +2856,7 @@ export function pinLearningRule(scope, id, options = {}) {
   const operationId = String(options.operationId || '');
   const at = new Date(options.now || Date.now()).toISOString();
   return withLock(scope, () => {
+    if (managementClosed(scope)) return { ok: false, code: 'memory_disabled', reason: '本项目记忆已关闭' };
     try {
       const result = state.transact(scope, { operationId }, (draft) => {
         const evolution = draft.experimental && draft.experimental.projectEvolution;
@@ -2719,12 +2880,122 @@ export function pinLearningRule(scope, id, options = {}) {
   });
 }
 
+/**
+ * 管理面编辑：只保存内容，不改变学习状态；正文变了就清掉旧证据并留上一版。
+ * 已生效规则改写后降回试用，避免拿新正文沿用旧证据直接当默认。
+ */
+export function editLearningRule(scope, id, options = {}) {
+  const expectedRevision = Number(options.expectedRevision);
+  const operationId = String(options.operationId || '');
+  const now = options.now || Date.now();
+  const at = new Date(now).toISOString();
+  const title = typeof options.title === 'string' ? options.title.trim() : '';
+  const body = typeof options.body === 'string' ? options.body.trim() : '';
+  if (!title && !body) throw new Error('没有要保存的内容');
+  if (title && title.length > LIMITS.titleChars) throw new Error(`标题超过 ${LIMITS.titleChars} 字`);
+  if (body && Buffer.byteLength(body) > LIMITS.entryBytes) throw new Error(`正文超过单条 ${LIMITS.entryBytes} 字节`);
+  return withLock(scope, () => {
+    if (managementClosed(scope)) return { ok: false, code: 'memory_disabled', reason: '本项目记忆已关闭' };
+    try {
+      const result = state.transact(scope, { operationId }, (draft) => {
+        const entry = draft.entries.find((row) => row.id === id && row.status === 'active');
+        if (!entry || !isExperimentalRecord(toFlat(entry))) throw new Error('没有这条实验规则');
+        if (!Number.isInteger(expectedRevision) || Number(entry.revision) !== expectedRevision) throw new Error('这条规则刚被改过，先刷新再保存');
+        const flat = toFlat(entry);
+        const nextTitle = title || flat.title;
+        const nextBody = body || flat.body;
+        if (nextTitle === flat.title && nextBody === flat.body) return { changed: false };
+        const nextCurrent = { ...entry.current, title: nextTitle, body: nextBody };
+        const learningState = { ...(flat.learning || {}) };
+        if (!learningState.specDigest) learningState.specDigest = learning.specDigestOf(flat);
+        learningState.versions = [...(Array.isArray(learningState.versions) ? learningState.versions : []),
+          { digest: learningState.specDigest, body: flat.body, at }].slice(-learning.LIMITS.versions);
+        learningState.specDigest = learning.specDigestOf(nextCurrent);
+        learningState.supportedEpisodeIds = [];
+        learningState.evidence = [];
+        learningState.updatedAt = at;
+        if (learningState.state === 'active') {
+          learningState.state = 'trial';
+          learningState.trialUntil = new Date(now + learning.LIMITS.trialMs).toISOString();
+        }
+        if (learningState.state === 'paused') {
+          learningState.blockedReason = 'edited';
+          learningState.pausedAt = at;
+          learningState.pausedBy = 'management';
+        }
+        entry.current = nextCurrent;
+        entry.maintenance = { ...(entry.maintenance || {}), learning: learningState };
+        entry.revision = Number(entry.revision) + 1;
+        entry.updatedAt = at;
+        return { changed: true, kind: 'learning_edit' };
+      });
+      return { ok: true, changed: result.changed === true, replayed: result.replayed === true };
+    } catch (error) {
+      if (error && error.code === 'conflict') return { ok: false, reason: '项目状态刚被改过，重试一次', retry: true };
+      return { ok: false, reason: error instanceof Error ? error.message : '没有保存' };
+    }
+  });
+}
+
+/** 采纳：候选/试用转为生效，默认在适用任务中参与召回；可选同时保存改过的标题或正文。 */
+export function adoptLearningRule(scope, id, options = {}) {
+  const expectedRevision = Number(options.expectedRevision);
+  const operationId = String(options.operationId || '');
+  const now = options.now || Date.now();
+  const at = new Date(now).toISOString();
+  const title = typeof options.title === 'string' ? options.title.trim() : '';
+  const body = typeof options.body === 'string' ? options.body.trim() : '';
+  if (!Number.isInteger(expectedRevision) || expectedRevision < 1) throw new Error('缺少版本，先刷新');
+  if (title && title.length > LIMITS.titleChars) throw new Error(`标题超过 ${LIMITS.titleChars} 字`);
+  if (body && Buffer.byteLength(body) > LIMITS.entryBytes) throw new Error(`正文超过单条 ${LIMITS.entryBytes} 字节`);
+  return withLock(scope, () => {
+    if (managementClosed(scope)) return { ok: false, code: 'memory_disabled', reason: '本项目记忆已关闭' };
+    try {
+      const result = state.transact(scope, { operationId }, (draft) => {
+        const entry = draft.entries.find((row) => row.id === id && row.status === 'active');
+        if (!entry || !isExperimentalRecord(toFlat(entry))) throw new Error('没有这条实验规则');
+        if (Number(entry.revision) !== expectedRevision) throw new Error('这条规则刚被改过，先刷新再采纳');
+        const flat = toFlat(entry);
+        const learningState = { ...(flat.learning || {}) };
+        if (learningState.state === 'active' && !title && !body) return { changed: false };
+        const nextTitle = title || flat.title;
+        const nextBody = body || flat.body;
+        const nextCurrent = { ...entry.current, title: nextTitle, body: nextBody };
+        if (!learningState.specDigest) learningState.specDigest = learning.specDigestOf(flat);
+        if (nextBody !== flat.body || nextTitle !== flat.title) {
+          learningState.versions = [...(Array.isArray(learningState.versions) ? learningState.versions : []),
+            { digest: learningState.specDigest, body: flat.body, at }].slice(-learning.LIMITS.versions);
+          learningState.specDigest = learning.specDigestOf(nextCurrent);
+          learningState.supportedEpisodeIds = [];
+          learningState.evidence = [];
+        }
+        learningState.state = 'active';
+        delete learningState.trialUntil;
+        delete learningState.blockedReason;
+        delete learningState.pausedAt;
+        delete learningState.pausedBy;
+        learningState.updatedAt = at;
+        entry.current = nextCurrent;
+        entry.maintenance = { ...(entry.maintenance || {}), learning: learningState };
+        entry.revision = Number(entry.revision) + 1;
+        entry.updatedAt = at;
+        return { changed: true, kind: 'learning_adopt' };
+      });
+      return { ok: true, changed: result.changed === true, replayed: result.replayed === true };
+    } catch (error) {
+      if (error && error.code === 'conflict') return { ok: false, reason: '项目状态刚被改过，重试一次', retry: true };
+      return { ok: false, reason: error instanceof Error ? error.message : '没有采纳' };
+    }
+  });
+}
+
 /** 结构化负反馈先在本地暂停命中的试用规则，再决定是否调用整理器。 */
 export function pauseLearningRules(scope, ids, options = {}) {
   const targets = Array.isArray(ids) ? ids.filter(Boolean).slice(0, 12) : [];
   if (!targets.length) return { ok: true, changed: 0 };
   const at = new Date(options.now || Date.now()).toISOString();
   return withLock(scope, () => {
+    if (managementClosed(scope)) return { ok: false, code: 'memory_disabled', reason: '本项目记忆已关闭' };
     try {
       const result = state.transact(scope, { operationId: options.operationId || '' }, (draft) => {
         let changed = 0;
@@ -2754,6 +3025,7 @@ export function resumeLearningRule(scope, id, options = {}) {
   const operationId = String(options.operationId || '');
   const at = new Date(options.now || Date.now()).toISOString();
   return withLock(scope, () => {
+    if (managementClosed(scope)) return { ok: false, code: 'memory_disabled', reason: '本项目记忆已关闭' };
     try {
       const result = state.transact(scope, { operationId }, (draft) => {
         const entry = draft.entries.find((row) => row.id === id && row.status === 'active');
@@ -2780,6 +3052,7 @@ export function expireLearning(scope, options = {}) {
   const now = options.now || Date.now();
   const at = new Date(now).toISOString();
   return withLock(scope, () => {
+    if (managementClosed(scope)) return { ok: false, code: 'memory_disabled', reason: '本项目记忆已关闭' };
     try {
       const result = state.transact(scope, { operationId: options.operationId || '' }, (draft) => {
         const evolution = draft.experimental && draft.experimental.projectEvolution;