dsh-lite-memory 0.11.1 → 0.16.2

package/store.js

@@ -27,7 +27,6 @@ const SECRET_PATTERNS = [
 ];
 
 /** A summary is a noun phrase. An imperative turns a note into an instruction. */
-const IMPERATIVE = /^(?:你要|你得|你必须|请|务必|必须|记得|记住|别忘了|do not|don't|please|you (?:must|should|need))/i;
 
 const SUGGESTION_ID = /^sug_[a-z0-9]{6,}$/;
 
@@ -96,6 +95,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 +115,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 +155,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 +177,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 = {
@@ -274,10 +276,8 @@ function cleanTitle(value) {
 }
 
 export function validSummary(summary) {
-  const text = String(summary ?? '').replace(/\s+/g, ' ').trim();
+  const text = String(summary ?? '').replace(/\s+/g, ' ').trim().slice(0, LIMITS.summaryChars);
   if (!text) return { ok: false, reason: '摘要为空' };
-  if (text.length > LIMITS.summaryChars) return { ok: false, reason: `摘要超过 ${LIMITS.summaryChars} 字，先写短些` };
-  if (IMPERATIVE.test(text)) return { ok: false, reason: '摘要必须写成名词短语，不能写成指令' };
   return { ok: true, text };
 }
 
@@ -297,21 +297,32 @@ export function normalizeDraft(source, options = {}) {
   const mayOmitTitle = Boolean(id);
   if (!title && !mayOmitTitle) throw new Error('标题为空');
   let summary = '';
+  let summaryShortened = false;
   const rawSummary = String(draft.summary ?? '').replace(/\s+/g, ' ').trim();
   if (rawSummary) {
     const check = validSummary(rawSummary);
     if (!check.ok) throw new Error(check.reason);
     summary = check.text;
+    summaryShortened = summary.length < rawSummary.length;
   } else if (has('summary')) {
     throw new Error('摘要为空');
   }
   /** 更新（带 id）与候选草稿允许省略摘要；省略表示保持原值，不拿标题补。 */
   const mayOmitSummary = options.requireSummary === false || Boolean(id);
   if (!summary && !mayOmitSummary) throw new Error('摘要为空');
-  const body = String(draft.body ?? '').trim();
-  const bodyBytes = Buffer.byteLength(body);
+  /**
+   * 正文是否由调用方显式给出，和「摘要太长所以自动补一份」必须分开。
+   * 否则同名更新会被自动补出的正文当成显式覆盖，把原正文冲掉。
+   */
+  const bodyExplicit = has('body');
+  const body = bodyExplicit ? String(draft.body ?? '').trim() : '';
+  const autoBody = !bodyExplicit && summaryShortened ? rawSummary : '';
+  const checked = bodyExplicit ? body : autoBody;
+  const bodyBytes = Buffer.byteLength(checked);
   if (bodyBytes > LIMITS.entryBytes) {
-    throw new Error(`正文 ${bodyBytes} 字节，超过单条 ${LIMITS.entryBytes} 字节；先精简，别让尾部条件被截掉`);
+    throw new Error(autoBody
+      ? `摘要 ${rawSummary.length} 字，超过单条 ${LIMITS.entryBytes} 字节；先拆成两条写，别丢后半段`
+      : `正文 ${bodyBytes} 字节，超过单条 ${LIMITS.entryBytes} 字节；只留原则、判断规则和触发条件`);
   }
   const kind = has('kind') ? textField(draft.kind, 20, '类型') : 'note';
   if (kind && !KINDS.includes(kind)) throw new Error(`类型只能是 ${KINDS.join(' / ')}`);
@@ -334,6 +345,10 @@ export function normalizeDraft(source, options = {}) {
     summary,
     when,
     body,
+    summaryShortened,
+    summaryRaw: rawSummary,
+    autoBody,
+    fullTextInBody: false,
     kind: kind || 'note',
     tags,
     triggers,
@@ -346,7 +361,7 @@ export function normalizeDraft(source, options = {}) {
       title: has('title') && Boolean(title),
       summary: has('summary'),
       when: has('when'),
-      body: has('body'),
+      body: bodyExplicit,
       kind: has('kind'),
       tags: has('tags'),
       triggers: triggers !== undefined,
@@ -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;
@@ -618,6 +651,14 @@ function rulesOf(draft, body, index, foreign) {
   return rules;
 }
 
+/** 长摘要的尾部不能丢：正文里没有这段时补在末尾，已有则不动。 */
+function bodyWithSummaryTail(body, draft) {
+  const raw = String(draft.summaryRaw || '');
+  const current = String(body || '');
+  if (!raw || !draft.summaryShortened || current.includes(raw)) return { body: current, added: false };
+  return { body: current ? `${current}\n\n摘要原文：${raw}` : raw, added: true };
+}
+
 function mergedFields(draft, record, oldBody, index, writeMode = 'patch', foreign) {
   if (writeMode === 'replace_current') {
     const next = {
@@ -631,8 +672,9 @@ function mergedFields(draft, record, oldBody, index, writeMode = 'patch', foreig
       selection: draft.has.selection ? draft.selection : null,
       links: draft.has.links ? draft.links : [],
       topicKey: draft.has.topicKey ? draft.topicKey : '',
-      body: draft.body,
+      body: bodyWithSummaryTail(draft.body, draft).body,
     };
+    if (next.body !== draft.body) draft.fullTextInBody = true;
     next.applicability = view.validateApplicability(draft.has.applicability ? draft.applicability : undefined,
       next.conditions, next.selection, next.when);
     assertLinksVisible(next.links, index, foreign);
@@ -710,6 +752,9 @@ function applyDraft(scope, index, source, now, options = {}) {
   if (record) {
     const oldBody = readBody(scope, record.id);
     const next = mergedFields(draft, record, oldBody, index, writeMode, foreign);
+    const tail = bodyWithSummaryTail(next.body, draft);
+    next.body = tail.body;
+    if (tail.added) draft.fullTextInBody = true;
     const noop = next.title === record.title && next.summary === record.summary
       && next.when === (record.when || '') && next.kind === (record.kind || 'note')
       && JSON.stringify(next.tags) === JSON.stringify(record.tags || [])
@@ -744,7 +789,11 @@ function applyDraft(scope, index, source, now, options = {}) {
     return { record, merged: true, mergedFrom, similar: null, similarList, draft, noop: false, previousBody: oldBody, archived };
   }
   if (writeMode === 'replace_current') throw new Error('整份替换要先指明是哪条，不能用来新增');
-  const rules = rulesOf(draft, draft.body, index, foreign);
+  const seed = draft.autoBody || draft.body;
+  const tail = bodyWithSummaryTail(seed, draft);
+  const createdBody = tail.body;
+  if (tail.added || draft.autoBody) draft.fullTextInBody = true;
+  const rules = rulesOf(draft, createdBody, index, foreign);
   const created = {
     id: newId(),
     title: draft.title,
@@ -758,7 +807,7 @@ function applyDraft(scope, index, source, now, options = {}) {
     selection: rules.selection,
     links: rules.links,
     topicKey: rules.topicKey,
-    body: draft.body,
+    body: createdBody,
     aliases: [],
     created: now,
     updated: now,
@@ -784,8 +833,9 @@ function applyDraft(scope, index, source, now, options = {}) {
  * 结果经 index.__archived 回填，调用方在工具结果里点名。
  */
 function assertFits(scope, index, record) {
-  if (record.bytes > LIMITS.entryBytes) {
-    throw new Error(`这一条 ${record.bytes} 字节，超过单条 ${LIMITS.entryBytes} 字节；先精简正文`);
+  const bodyBytes = Buffer.byteLength(record.body || '');
+  if (bodyBytes > LIMITS.entryBytes) {
+    throw new Error(`正文 ${bodyBytes} 字节，超过单条 ${LIMITS.entryBytes} 字节；先精简正文`);
   }
   const size = recordSize(record);
   if (size > LIMITS.recordBytes) {
@@ -842,23 +892,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 +965,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 +1019,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 +1071,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;
@@ -980,8 +1090,11 @@ export function search(scope, query, limit = 4, options = {}) {
       const group = resolved.get(view.topicSlot(item));
       return Boolean(group && group.status === 'ok' && group.record && group.record.id !== item.id);
     };
-    const visible = rows.filter((row) => row.archived || !shadowed(row.item));
-    visible.sort((a, b) => b.score - a.score
+    const visible = rows.filter((row) => row.archived || !shadowed(row.item))
+      .map((row) => ({ ...row, usable: row.archived || view.statusOf(row.item, options.context || {}) === 'ok' }));
+    /** 先按「本轮能不能用」分组再按相关度：高相关但当前不适用的条目不能挤掉后面真正能用的。 */
+    visible.sort((a, b) => Number(b.usable) - Number(a.usable)
+      || b.score - a.score
       || Number(a.archived) - Number(b.archived)
       || String(b.item.lastUsed).localeCompare(String(a.item.lastUsed)));
     const chosen = visible.slice(0, limit);
@@ -1162,13 +1275,16 @@ function findCurrent(id, scope, options = {}) {
     const record = index.entries.find((item) => item.id === id && item.status !== 'archived');
     if (!record) continue;
     if (!readableRecord(record, options, index)) continue;
+    /** 关联目标也按本轮上下文判适用；条件未知、过期或暂停的目标不给标题。 */
+    if (view.statusOf(record, options.context || {}) !== 'ok') continue;
+    if (isExperimentalRecord(record) && !view.experimentalUsable(record, options.now)) continue;
     return {
       id: record.id,
       title: record.title,
       summary: record.summary || '',
       scope: source.key === 'global' ? 'global' : 'project',
       revision: record.revision || 1,
-      status: view.statusOf(record, {}),
+      status: 'ok',
     };
   }
   return null;
@@ -1184,7 +1300,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 +1398,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 +1687,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 +1999,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 +2010,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 +2287,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 +2307,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 +2417,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 +2531,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 +2596,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 +2616,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 +2624,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 + 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 +2695,7 @@ export function commitLearning(scope, batch = {}) {
               selection: null,
               links: [],
               origin: EXPERIMENTAL_ORIGIN,
+              ownerProjectId: scope.key,
               reviewState: 'active',
               created: at,
               updated: at,
@@ -2536,8 +2709,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 +2777,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 +2802,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 +2833,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 +2879,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 +2903,125 @@ 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 bodyChanged = nextBody !== flat.body;
+        const learningState = { ...(flat.learning || {}) };
+        if (!learningState.specDigest) learningState.specDigest = learning.specDigestOf(flat);
+        if (bodyChanged) {
+          learningState.versions = [...(Array.isArray(learningState.versions) ? learningState.versions : []),
+            { digest: learningState.specDigest, body: flat.body, at }].slice(-learning.LIMITS.versions);
+          learningState.supportedEpisodeIds = [];
+          learningState.evidence = [];
+        }
+        learningState.specDigest = learning.specDigestOf(nextCurrent);
+        learningState.updatedAt = at;
+        if (bodyChanged && 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 +3051,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 +3078,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;