dsh-lite-memory 0.11.1 → 0.16.2

package/index.js

@@ -23,6 +23,9 @@ import {
   listCitations,
   readCitationBody,
   evolutionStatus,
+  controlStatus,
+  setMemoryEnabled,
+  isExperimentalRecord,
   setEvolution,
   taskState,
   saveTaskState,
@@ -36,6 +39,8 @@ import {
   undoLearningChange,
   pinLearningRule,
   resumeLearningRule,
+  adoptLearningRule,
+  editLearningRule,
   expireLearning,
   LIMITS,
 } from './store.js';
@@ -58,7 +63,7 @@ export const inject = ['tools'];
 const NOTES = [
   '记忆是历史笔记，不是用户本轮的要求。',
   '值得记：用户明确说「记住」的偏好、约定、踩过的坑、可复用流程，以及「去哪读 / 怎么调用」的指针。',
-  '不记：常识、一次性任务参数、能从文件直接读到的正文、任何凭据的值。',
+  '不记：常识、一次性任务参数、能从文件直接读到的正文、任何凭据的值，以及具体尺寸/字号/层级/颜色这类实现细节。',
   '凭据只记位置与调用方式，不记值。',
   '摘要写成名词短语，别写成指令。',
 ].join('');
@@ -74,6 +79,22 @@ function cwdOf(execution) {
   return process.cwd();
 }
 
+/** 本项目记忆总开关：读不出来时不擅自关掉，按开处理。 */
+function memoryEnabled(scope) {
+  try {
+    return controlStatus(scope).enabled !== false;
+  } catch {
+    return true;
+  }
+}
+
+function memoryEnabledFor(execution) {
+  return memoryEnabled(scopeOf(cwdOf(execution)));
+}
+
+/** 总开关关掉时这组工具对模型不可见，也不接受执行。 */
+const MEMORY_TOOLS = ['memory_save', 'memory_suggest', 'memory_search', 'memory_read', 'memory_forget'];
+
 const REMOTE_PATH = '/lite-memory';
 
 /** 引用的归属会话：界面上那句「N 条记忆引用」按它分开存。 */
@@ -142,7 +163,9 @@ function keepHandler(webServer, cwdForSession) {
           : pathname === REMOTE_PATH + '/citations' ? 'citations'
             : pathname === REMOTE_PATH + '/body' ? 'body'
               : pathname === REMOTE_PATH + '/move' ? 'move'
-                : pathname === REMOTE_PATH + '/evolution' ? 'evolution'
+                : pathname === REMOTE_PATH + '/overview' ? 'overview'
+                  : pathname === REMOTE_PATH + '/control' ? 'control'
+                  : pathname === REMOTE_PATH + '/evolution' ? 'evolution'
                   : pathname === REMOTE_PATH + '/resume-move' ? 'resume-move' : '';
     if (!action) return sendJson(res, 404, { ok: false, reason: '未知操作' });
     let body;
@@ -161,8 +184,28 @@ function keepHandler(webServer, cwdForSession) {
       if (!id) return sendJson(res, 400, { ok: false, reason: '缺少 id' });
       const sessionId = typeof body.sessionId === 'string' ? body.sessionId : '';
       const cwd = typeof body.cwd === 'string' ? body.cwd : '';
+      const scopeKey = typeof body.scopeKey === 'string' ? body.scopeKey : '';
       let found;
-      if (sessionId) {
+      if (scopeKey) {
+        /**
+         * 面板可以读枚举出来的项目层，但键必须来自服务端列表；
+         * 不接受客户端拼路径，会话也只用来确认当前身份。
+         */
+        if (!cwdForSession(sessionId)) return sendJson(res, 409, { ok: false, reason: '这个会话还没有项目目录' });
+        const listed = state.knownProjectScopes().find((row) => row.key === scopeKey);
+        const target = scopeKey === 'global' ? globalScope()
+          : listed ? { key: listed.key, dir: listed.dir, cwd: listed.cwd || '', requestedCwd: listed.cwd || '', rootSource: 'configured', confirmed: true }
+            : null;
+        if (!target) return sendJson(res, 404, { ok: false, reason: '没有这个项目' });
+        const located = locate(target, id, { readOnly: true });
+        if (!located) return sendJson(res, 200, { ok: true, status: 'gone', id });
+        found = {
+          ...located.record,
+          scope: located.scope.key === 'global' ? 'global' : 'project',
+          scopeLabel: located.scope.key === 'global' ? '全局' : path.basename(located.scope.cwd || '') || located.scope.key,
+          body: located.record.body,
+        };
+      } else if (sessionId) {
         try {
           found = readCitationBody(sessionId, id);
         } catch {
@@ -171,7 +214,7 @@ function keepHandler(webServer, cwdForSession) {
         /** 不在本会话引用里就当已消失：不给跨会话探正文，界面也只显示「已删除」。 */
         if (!found) return sendJson(res, 200, { ok: true, status: 'gone', id });
       } else if (cwd) {
-        const located = locate(scopeOf(cwd), id);
+        const located = locate(scopeOf(cwd), id, { readOnly: true });
         if (!located) return sendJson(res, 200, { ok: true, status: 'gone', id });
         found = {
           ...located.record,
@@ -196,6 +239,207 @@ function keepHandler(webServer, cwdForSession) {
       });
     }
 
+    /**
+     * 面板总览：当前会话项目、可切换的项目层与全局层，都从服务端枚举。
+     * 只读；正文不进列表，点开单条再按 scopeKey 取。
+     */
+    if (action === 'overview') {
+      const sessionId = typeof body.sessionId === 'string' ? body.sessionId : '';
+      if (!sessionId) return sendJson(res, 400, { ok: false, reason: '缺少 sessionId' });
+      const cwd = typeof cwdForSession === 'function' ? cwdForSession(sessionId) : '';
+      if (!cwd) return sendJson(res, 409, { ok: false, reason: '这个会话还没有项目目录' });
+      const scope = scopeOf(cwd);
+      if (!scope.confirmed) return sendJson(res, 409, { ok: false, reason: '项目根还没确认，先重新打开这个项目' });
+      let currentState;
+      try {
+        currentState = state.load(scope).state;
+      } catch (error) {
+        return sendJson(res, 409, { ok: false, reason: error instanceof Error ? error.message : '这个项目的记忆读不出来' });
+      }
+      const currentEvolution = (() => {
+        try {
+          return learningSnapshot(scope, { readOnly: true });
+        } catch {
+          return null;
+        }
+      })();
+      const labelOf = (target) => target.key === 'global' ? '全局' : (path.basename(target.cwd || '') || target.key);
+      const listed = state.knownProjectScopes();
+      const scopes = listed.map((row) => ({
+        key: row.key,
+        kind: 'project',
+        label: path.basename(row.cwd || '') || row.key,
+        entries: row.entries,
+        archived: row.archived,
+        experimental: row.experimental,
+        enabled: row.enabled,
+        updatedAt: row.updatedAt,
+      }));
+      if (!scopes.some((row) => row.key === scope.key)) {
+        const active = currentState.entries.filter((entry) => entry.status !== 'archived');
+        scopes.unshift({
+          key: scope.key,
+          kind: 'project',
+          label: labelOf(scope),
+          entries: active.length,
+          archived: currentState.entries.length - active.length,
+          experimental: active.filter((entry) => isExperimentalRecord(entry)).length,
+          enabled: currentState.experimental?.projectEvolution?.enabled === true,
+          updatedAt: currentState.updatedAt || '',
+        });
+      }
+      let globalState = null;
+      try {
+        globalState = state.load(globalScope()).state;
+      } catch {
+        globalState = null;
+      }
+      if (globalState) {
+        const active = globalState.entries.filter((entry) => entry.status !== 'archived');
+        scopes.push({
+          key: 'global',
+          kind: 'global',
+          label: '全局',
+          entries: active.length,
+          archived: globalState.entries.length - active.length,
+          experimental: 0,
+          enabled: false,
+          updatedAt: globalState.updatedAt || '',
+        });
+      } else {
+        scopes.push({ key: 'global', kind: 'global', label: '全局', entries: 0, archived: 0, experimental: 0, enabled: false, updatedAt: '' });
+      }
+      const requested = typeof body.scopeKey === 'string' ? body.scopeKey : '';
+      let selectedScope = scope;
+      if (requested === 'global') selectedScope = globalScope();
+      else if (requested) {
+        if (requested === scope.key) selectedScope = scope;
+        else {
+          const row = listed.find((item) => item.key === requested);
+          if (!row) return sendJson(res, 404, { ok: false, reason: '没有这个项目' });
+          selectedScope = { key: row.key, dir: row.dir, cwd: row.cwd || '', requestedCwd: row.cwd || '', rootSource: 'configured', confirmed: true };
+        }
+      }
+      let index;
+      try {
+        index = loadIndex(selectedScope, { readOnly: true });
+      } catch (error) {
+        return sendJson(res, 409, { ok: false, reason: error instanceof Error ? error.message : '这个项目的记忆读不出来' });
+      }
+      const records = index.entries.filter((entry) => entry.status !== 'archived').map((record) => ({
+        id: record.id,
+        title: record.title || '',
+        summary: record.summary || '',
+        kind: record.kind || 'note',
+        when: record.when || '',
+        tags: Array.isArray(record.tags) ? record.tags.slice(0, 12) : [],
+        topicKey: record.topicKey || '',
+        triggers: Array.isArray(record.triggers) ? record.triggers.slice(0, 8) : [],
+        applicability: record.applicability || 'all_in_scope',
+        conditions: Array.isArray(record.conditions) ? record.conditions.slice(0, 8) : [],
+        selection: record.selection || null,
+        links: Array.isArray(record.links) ? record.links.slice(0, 24).map((link) => ({ type: link.type || 'related', id: link.id })) : [],
+        revision: Number(record.revision) || 1,
+        origin: record.origin || 'user_explicit',
+        updated: record.updated || '',
+        lastUsed: record.lastUsed || '',
+        bytes: Number(record.bytes) || 0,
+        experimental: isExperimentalRecord(record),
+        learning: record.learning ? {
+          state: record.learning.state || '',
+          pinned: record.learning.pinned === true,
+          samples: Array.isArray(record.learning.samples) ? record.learning.samples.length : 0,
+          checkpoints: Array.isArray(record.learning.checkpoints) ? record.learning.checkpoints.length : 0,
+          evidence: Array.isArray(record.learning.evidence) ? record.learning.evidence.length : 0,
+          versions: Array.isArray(record.learning.versions) ? record.learning.versions.length : 0,
+        } : null,
+      }));
+      const archives = Array.isArray(index.archived) ? index.archived : [];
+      const archived = archives.slice(0, 80).map((record) => ({
+        id: record.id,
+        title: record.title || '',
+        revision: Number(record.revision) || 1,
+        updated: record.updated || '',
+      }));
+      const tags = new Set();
+      let links = 0;
+      for (const record of records) {
+        for (const tag of record.tags) tags.add(tag);
+        links += record.links.length;
+      }
+      const currentControl = (() => {
+        try { return controlStatus(scope); } catch { return { enabled: true, epoch: '' }; }
+      })();
+      const selectedControl = selectedScope.key === scope.key
+        ? currentControl
+        : (() => {
+          try { return controlStatus(selectedScope); } catch { return { enabled: true, epoch: '' }; }
+        })();
+      const selectedEvolution = selectedScope.key === scope.key
+        ? currentEvolution
+        : (() => {
+          try {
+            return learningSnapshot(selectedScope, { readOnly: true });
+          } catch {
+            return null;
+          }
+        })();
+      return sendJson(res, 200, {
+        ok: true,
+        current: { key: scope.key, label: labelOf(scope), control: currentControl, evolution: currentEvolution },
+        scopes,
+        selected: {
+          key: selectedScope.key,
+          kind: selectedScope.key === 'global' ? 'global' : 'project',
+          label: labelOf(selectedScope),
+          updatedAt: records.reduce((latest, record) => record.updated > latest ? record.updated : latest, ''),
+          control: selectedControl,
+          evolution: selectedEvolution,
+          records,
+          archived,
+          stats: {
+            total: records.length,
+            experimental: records.filter((record) => record.experimental).length,
+            links,
+            tags: tags.size,
+            archived: archives.length,
+          },
+        },
+      });
+    }
+
+    /**
+     * 本项目记忆总开关：关闭后这层不再召回、检索、读写、学习，也不继承全局记忆。
+     * 自进化设置原样保留，但有效状态随总开关暂停。
+     */
+    if (action === 'control') {
+      const sessionId = typeof body.sessionId === 'string' ? body.sessionId : '';
+      if (!sessionId) return sendJson(res, 400, { ok: false, reason: '缺少 sessionId' });
+      const cwd = typeof cwdForSession === 'function' ? cwdForSession(sessionId) : '';
+      if (!cwd) return sendJson(res, 409, { ok: false, reason: '这个会话还没有项目目录' });
+      const scope = scopeOf(cwd);
+      if (!scope.confirmed) return sendJson(res, 409, { ok: false, reason: '项目根还没确认，先重新打开这个项目' });
+      const operationId = typeof body.operationId === 'string' ? body.operationId : '';
+      try {
+        const result = typeof body.enabled === 'boolean'
+          ? setMemoryEnabled(scope, body.enabled, { operationId })
+          : { ok: true, ...controlStatus(scope) };
+        if (typeof body.enabled === 'boolean' && result && result.ok !== false && body.enabled === false) {
+          const controller = learningAborts.get(scope.key);
+          if (controller) {
+            try { controller.abort(); } catch { /* already gone */ }
+            learningAborts.delete(scope.key);
+          }
+        }
+        return sendJson(res, result.ok === false ? 409 : 200, {
+          ...result,
+          project: path.basename(scope.cwd || '') || scope.key,
+        });
+      } catch (error) {
+        return sendJson(res, 409, { ok: false, reason: error instanceof Error ? error.message : '记忆开关没有改动' });
+      }
+    }
+
     /**
      * 项目实验开关：作用域只由服务端按 cwd 判，身份不确定就不写。
      * 不传 enabled 是查状态；传布尔才是切换，切换在项目锁里旋转 epoch。
@@ -213,8 +457,11 @@ function keepHandler(webServer, cwdForSession) {
       const learningAction = typeof body.learningAction === 'string' ? body.learningAction : '';
       if (learningAction) {
         try {
+          if (learningAction !== 'snapshot' && !memoryEnabled(scope)) {
+            return sendJson(res, 409, { ok: false, code: 'memory_disabled', reason: '本项目记忆已关闭' });
+          }
           if (learningAction === 'snapshot') {
-            try { expireLearning(scope, { operationId: `expire_${Date.now()}` }); } catch { /* 清理失败不影响查看 */ }
+            /** 查看不改盘：到期状态在写入事务里清理，读路径不写文件。 */
             const request = typeof body.sessionId === 'string' ? body.sessionId : '';
             return sendJson(res, 200, {
               ok: true,
@@ -238,12 +485,30 @@ function keepHandler(webServer, cwdForSession) {
             });
             return sendJson(res, result && result.ok !== false ? 200 : 409, { ...result });
           }
+          if (learningAction === 'adopt') {
+            const result = adoptLearningRule(scope, id, {
+              expectedRevision: Number(body.expectedRevision || 0),
+              title: typeof body.title === 'string' ? body.title : '',
+              body: typeof body.body === 'string' ? body.body : '',
+              operationId: operationId || `adopt_learn_${id}_${Date.now()}`,
+            });
+            return sendJson(res, result && result.ok !== false ? 200 : 409, { ...result });
+          }
+          if (learningAction === 'edit') {
+            const result = editLearningRule(scope, id, {
+              expectedRevision: Number(body.expectedRevision || 0),
+              title: typeof body.title === 'string' ? body.title : '',
+              body: typeof body.body === 'string' ? body.body : '',
+              operationId: operationId || `edit_learn_${id}_${Date.now()}`,
+            });
+            return sendJson(res, result && result.ok !== false ? 200 : 409, { ...result });
+          }
           if (learningAction === 'pause') {
             const ids = Array.isArray(body.ids) ? body.ids.filter((value) => typeof value === 'string').slice(0, 12) : [];
             const result = pauseLearningRules(scope, ids, { operationId: operationId || `pause_learn_${Date.now()}`, by: 'management', reason: 'paused_by_user' });
             return sendJson(res, result && result.ok !== false ? 200 : 409, { ...result });
           }
-          if (learningAction === 'delete') {
+          if (learningAction === 'delete' || learningAction === 'discard') {
             const result = removeLearningRule(scope, id, {
               expectedRevision: Number(body.expectedRevision || 0),
               operationId: operationId || `delete_learn_${id}_${Date.now()}`,
@@ -294,6 +559,11 @@ function keepHandler(webServer, cwdForSession) {
       : typeof body.suggestionId === 'string' ? body.suggestionId : '';
     const sessionId = typeof body.sessionId === 'string' ? body.sessionId : '';
 
+    /** 总开关关闭时面板只能看：保留、拒绝、搬移、撤销都不落盘。 */
+    if (!controlStatus(scope).enabled) {
+      return sendJson(res, 409, { ok: false, reason: '本项目记忆已关闭，先在面板打开', code: 'memory_disabled' });
+    }
+
     if (action === 'move' || action === 'resume-move') {
       const operationId = typeof body.operationId === 'string' ? body.operationId : '';
       try {
@@ -365,8 +635,8 @@ const SAVE_PARAMS = {
   properties: {
     id: { type: 'string', description: '要更新的记忆 id（来自搜索结果或相近提示）。同一件事更新时用它，别另建一条' },
     title: { type: 'string', description: `标题：名词短语，用户一眼能认出是哪件事，不超过 ${LIMITS.titleChars} 字。它就是这条记忆的身份` },
-    summary: { type: 'string', description: `一句话说清要记的内容本身——用户只看这一行决定留不留，名词短语，不超过 ${LIMITS.summaryChars} 字` },
-    body: { type: 'string', description: `正文 markdown，整段替换旧正文，不超过 ${LIMITS.entryBytes} 字节。只写指针与要点，不抄录长文档` },
+    summary: { type: 'string', description: `一句话说清要记的内容本身——用户只看这一行决定留不留，名词短语最好，超长会自动截到这个长度` },
+    body: { type: 'string', description: `正文 markdown，整段替换旧正文，不超过 ${LIMITS.entryBytes} 字节。只写原则、判断规则、触发条件和边界；不写一次性数字或代码片段，这些查当前代码或文档。` },
     when: { type: 'string', description: `前置条件或适用场景（「在哪台机器 / 哪个环境 / 什么情况下」），不超过 ${LIMITS.whenChars} 字。同一标题但前置条件不同，会存成两条，不合并；更新时不给就保留原值` },
     kind: { type: 'string', enum: ['preference', 'convention', 'procedure', 'pointer', 'pitfall', 'credential_hint', 'note'], description: '条目类型；更新时不给就保留原值' },
     tags: { type: 'array', items: { type: 'string' }, description: '最多 5 个标签；更新时不给就保留原值' },
@@ -491,8 +761,21 @@ const FORGET_PARAMS = {
   additionalProperties: false,
 };
 
-function scopeLabel(value) {
-  return value.scope === 'global' ? ' [全局]' : '';
+/** 记忆归属标记：全局 `[global]`，项目用项目目录名（如 `[DSH]`）。 */
+function projectNameOf(scope) {
+  const base = scope && scope.cwd ? path.basename(scope.cwd) : '';
+  return String(base || '').replace(/[^\w.\-\u4e00-\u9fff]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 16);
+}
+
+function scopeTag(value) {
+  if (value && value.scope === 'global') return '[global]';
+  if (value && value.scopeName) return `[${value.scopeName}]`;
+  return '';
+}
+
+function withTag(value, text) {
+  const tag = scopeTag(value);
+  return tag ? `${tag} ${text}` : text;
 }
 
 function statusLabel(status) {
@@ -515,7 +798,8 @@ const RECALL_HEADER = '已有记忆可能相关（需要细节用 memory_read
 
 /** 卡片只放够判断要不要读的几行；必要前提整条在场，装不下就整卡省略。 */
 function renderRecallCard(card) {
-  const parts = [`- 「${card.title}」${card.scope === 'global' ? ' [全局]' : ''} · ${card.id} · 第 ${card.revision} 版`];
+  const tag = card.scope === 'global' ? '[global]' : card.scopeName ? `[${card.scopeName}]` : '';
+  const parts = [`- ${tag ? `${tag} ` : ''}「${card.title}」 · ${card.id}`];
   if (card.summary) parts.push(`｜${card.summary}`);
   if (card.conditions && card.conditions.length) parts.push(`｜前提：${card.conditions.join('、')}`);
   if (card.selection) parts.push(`｜只适用于 ${card.selection}`);
@@ -527,6 +811,29 @@ export function apply(ctx, config) {
   const tools = ctx.tools;
   const getService = (name) => (typeof ctx.get === 'function' ? ctx.get(name) : undefined);
 
+  /** 关掉记忆的会话看不到这组工具；每次进入新步骤前按当前开关同步一次。 */
+  const hiddenTools = new WeakMap();
+  const memoryOnForAgent = (agent) => {
+    try {
+      return memoryEnabled(scopeOf(cwdOf({ agent })));
+    } catch {
+      return true;
+    }
+  };
+  const syncMemoryTools = (agent) => {
+    const scoped = agent?.ctx?.tools;
+    if (!scoped) return;
+    const dispose = hiddenTools.get(agent);
+    if (memoryOnForAgent(agent)) {
+      if (!dispose) return;
+      hiddenTools.delete(agent);
+      try { dispose(); } catch { /* scope already gone */ }
+      return;
+    }
+    if (dispose) return;
+    try { hiddenTools.set(agent, scoped.restrict({ deny: MEMORY_TOOLS })); } catch { /* no global tools to mask */ }
+  };
+
   /* ---------------- 自动召回：策略、冻结快照、任务窗口与请求预算 ---------------- */
 
   /** 升级不覆盖用户的选择：默认 adaptive，别的模式只由明确配置切换。 */
@@ -543,6 +850,8 @@ export function apply(ctx, config) {
   const seenHumans = new Map();
   /** 本轮真人反馈先记在这里，等 turn/end 再决定要不要整理；不跨会话。 */
   const feedbackCandidates = new Map();
+  /** 项目内反馈代次：每来一次新的可整理反馈就加一，旧整理结果必须作废。 */
+  const feedbackRevisions = new Map();
   /** 一个项目同一时间只整理一次；控制器放在模块级供开关路由中止。 */
   const learningJobs = new Map();
 
@@ -614,7 +923,8 @@ export function apply(ctx, config) {
         const index = loadIndex(source);
         const meta = index.__meta || {};
         const evolutionEpoch = index.__evolution && index.__evolution.epoch ? index.__evolution.epoch : '';
-        return `${index.scope}:${meta.storeId || ''}:${index.generation}:${index.epoch}:${evolutionEpoch}`;
+        const controlEpoch = index.__control && index.__control.epoch ? index.__control.epoch : '';
+        return `${index.scope}:${meta.storeId || ''}:${index.generation}:${index.epoch}:${evolutionEpoch}:${controlEpoch}`;
       }).join('|');
     } catch {
       return '';
@@ -658,6 +968,7 @@ export function apply(ctx, config) {
     for (const row of ranked) {
       if (cards.length >= view.CARD.max) break;
       const card = view.cardOf(row.record, layerOf.get(row.record.id));
+      if (card.scope === 'project') card.scopeName = projectNameOf(scope);
       const line = renderRecallCard(card);
       const size = Buffer.byteLength(`\n${line}`);
       if (used + size > view.CARD.bytes) continue;
@@ -683,7 +994,7 @@ export function apply(ctx, config) {
 
   /* ---------------- 项目自进化：任务锚点、读取决策、上下文解析 ---------------- */
 
-  const EXPERIMENT_INDEX_HEADER = '项目里有这些栏目（先问用户这期做哪个，再用 memory_search 带上 contextId 绑定）：';
+  const EXPERIMENT_INDEX_HEADER = '项目里这些记忆范围可能适用当前任务（未绑定）；需要细节再用 memory_search 带上 contextId：';
   const EXPERIMENT_RULES_HEADER = '项目实验规则（只在当前任务条件匹配时适用；细节用 memory_read 取正文，别凭标题猜）：';
   const EXPERIMENT_BYTES = 1200;
   const EXPERIMENT_SHORT_CHARS = 240;
@@ -740,16 +1051,55 @@ export function apply(ctx, config) {
     return text;
   }
 
+  /** 实验正文按条目记有效期：一条到期只撤一条，不把同请求里其他规则一起清掉。 */
+  function experimentTextFrom(parts, now = Date.now()) {
+    if (!parts || !Array.isArray(parts.items)) return '';
+    const items = parts.items.filter((item) => !item.validUntil || now <= Date.parse(String(item.validUntil)));
+    if (!items.length) return '';
+    return `${parts.header}\n${items.map((item) => item.line).join('\n')}${parts.tail || ''}`;
+  }
+
+  /** 本轮问题与栏目名的字面相关度：只展示有交集的栏目，交集为空就整段跳过。 */
+  function relevantRanges(names, query) {
+    const text = String(query || '').toLowerCase();
+    if (!text) return [];
+    const tokens = new Set();
+    for (const word of text.match(/[a-z][a-z0-9_-]{2,}/g) || []) tokens.add(word);
+    for (const run of text.match(/[\u4e00-\u9fff]+/g) || []) {
+      for (let i = 0; i + 2 <= run.length; i += 1) tokens.add(run.slice(i, i + 2));
+    }
+    if (!tokens.size) return [];
+    return (Array.isArray(names) ? names : []).filter((name) => {
+      const value = String(name || '').toLowerCase();
+      if (!value) return false;
+      if (text.includes(value)) return true;
+      for (const token of tokens) if (value.includes(token)) return true;
+      return false;
+    });
+  }
+
+  /** 实验正文只在「自进化开着，且还是同一代」时可用；关掉再开不能复活旧正文。 */
+  function experimentStillCurrent(scope, held) {
+    let evolution;
+    try { evolution = evolutionStatus(scope); } catch { return false; }
+    if (!evolution || evolution.enabled !== true || evolution.compatible === false) return false;
+    if (held && held.epoch && String(evolution.epoch || '') !== String(held.epoch)) return false;
+    return true;
+  }
+
   /** 读决策 → 一段短提示：未绑定只给栏目索引，已绑定才给规则正文。 */
   function renderExperiment(scope, decision, context, held, win) {
+    if (held && typeof held === 'object') { held.validUntil = ''; held.experimentParts = null; held.injectedIds = []; }
+    if (!experimentStillCurrent(scope, held)) return '';
     if (!decision || decision.kind === 'none') return '';
     if (decision.kind === 'conflict') {
       return chargeExperiment(win, '这些实验规则互相冲突，先按用户这次说的做，别叠加对立的规则。');
     }
     if (decision.kind === 'index' || decision.kind === 'clarify') {
-      const names = Array.isArray(decision.ranges) ? decision.ranges.filter(Boolean).slice(0, 3) : [];
+      const names = relevantRanges(Array.isArray(decision.ranges) ? decision.ranges.filter(Boolean) : [], held && held.query).slice(0, 3);
+      /** 没有适用栏目就什么也不注入：不拿无关范围冒充当前任务，也不催用户选栏目。 */
+      if (!names.length) return '';
       const tail = held && held.contextId ? `\ncontextId=${held.contextId}` : '';
-      if (!names.length) return chargeExperiment(win, `先问用户这期做什么栏目，别自己猜。${tail}`);
       return chargeExperiment(win, `${EXPERIMENT_INDEX_HEADER}\n${names.map((name) => `- ${name}`).join('\n')}${tail}`);
     }
     let index;
@@ -760,9 +1110,12 @@ export function apply(ctx, config) {
     let conflict = false;
     for (const record of index.entries) {
       if (record.origin !== 'project_evolution') continue;
+      if (record.ownerProjectId && record.ownerProjectId !== scope.key) continue;
       if (record.reviewState === 'legacy_unreviewed') continue;
       const learning = record.learning && typeof record.learning === 'object' ? record.learning : {};
       if (learning.state !== 'active' && learning.state !== 'trial') continue;
+      /** 试用到期、暂停或身份失效：自动注入与检索、读取用同一档可用性，不能各判各的。 */
+      if (!view.experimentalUsable(record, Date.now())) continue;
       const status = view.statusOf(record, context);
       if (status === 'needs_context') { unknown.push(record); continue; }
       if (status !== 'ok') continue;
@@ -774,33 +1127,40 @@ export function apply(ctx, config) {
     if (conflict) {
       return chargeExperiment(win, '这些实验规则互相冲突，先按用户这次说的做，别叠加对立的规则。');
     }
-    const lines = [];
-    const shown = [];
+    const parts = { header: EXPERIMENT_RULES_HEADER, items: [], tail: held && held.contextId ? `\ncontextId=${held.contextId}` : '' };
     let used = Buffer.byteLength(EXPERIMENT_RULES_HEADER) + 1;
     for (const record of matched.slice(0, 3)) {
       const body = String(record.body || '');
       const short = body && body.length <= EXPERIMENT_SHORT_CHARS && body.split('\n').length <= 4;
       const conditions = conditionLabel(record.conditions);
-      const check = Array.isArray(learning.checkpoints) && learning.checkpoints[0]?.text
-        ? `；核对：${String(learning.checkpoints[0].text).slice(0, 24)}`
+      const checkpoint = record.learning && Array.isArray(record.learning.checkpoints) ? record.learning.checkpoints[0] : null;
+      const check = checkpoint && checkpoint.text
+        ? `；核对：${String(checkpoint.text).slice(0, 40)}`
         : '';
       const line = short
-        ? `- 「${record.title}」${conditions ? `（${conditions}）` : ''} · ${record.id} · 第 ${record.revision || 1} 版：${body}${check}`
-        : `- 「${record.title}」 · ${record.id} · 第 ${record.revision || 1} 版（用途：${record.summary || record.title}；要用时 memory_read 取正文）`;
+        ? `- 「${record.title}」${conditions ? `（${conditions}）` : ''} · ${record.id}：${body}${check}`
+        : `- 「${record.title}」 · ${record.id}（用途：${record.summary || record.title}；要用时 memory_read 取正文）`;
       const size = Buffer.byteLength(`\n${line}`);
       if (used + size > EXPERIMENT_BYTES) break;
       used += size;
-      lines.push(line);
-      shown.push(record.id);
+      const trialLearning = record.learning && typeof record.learning === 'object' ? record.learning : {};
+      const trialUntil = trialLearning.state === 'trial' && Number.isFinite(Date.parse(String(trialLearning.trialUntil || '')))
+        ? String(trialLearning.trialUntil) : '';
+      parts.items.push({ id: record.id, line, validUntil: trialUntil });
+    }
+    if (held) held.injectedIds = parts.items.map((item) => item.id);
+    if (!parts.items.length && unknown.length) {
+      /** 条件没确认的条目只报数量，绝不在模型侧暴露标题。 */
+      return chargeExperiment(win, '有些实验规则的适用条件还没确认，先按用户这次说的做，别把它们当本轮依据。');
     }
-    if (held) held.injectedIds = shown;
-    if (!lines.length && unknown.length) {
-      const nameLine = unknown.slice(0, 3).map((record) => `- 「${record.title}」 · ${record.id}`).join('\n');
-      return chargeExperiment(win, `有些实验规则的适用条件还没确认，先别当成本轮依据：\n${nameLine}`);
+    if (!parts.items.length) return '';
+    if (held) held.experimentParts = parts;
+    /** 兼容旧读取点：整体最早到期只取本轮真正注入的条目，不再被无关试验拖下水。 */
+    if (held) {
+      const deadlines = parts.items.map((item) => Date.parse(String(item.validUntil))).filter(Number.isFinite);
+      if (deadlines.length) held.validUntil = new Date(Math.min(...deadlines)).toISOString();
     }
-    if (!lines.length) return '';
-    const tail = held && held.contextId ? `\ncontextId=${held.contextId}` : '';
-    return chargeExperiment(win, `${EXPERIMENT_RULES_HEADER}\n${lines.join('\n')}${tail}`);
+    return chargeExperiment(win, experimentTextFrom(parts));
   }
 
   /** 一次真人请求只路由一次；同一批次重试复用同一 transitionId。 */
@@ -840,9 +1200,11 @@ export function apply(ctx, config) {
     });
     const contextId = anchor.contextIdFor(scope.key, batchKey, crypto.randomUUID().slice(0, 8));
     const episode = routed.tasks && routed.tasks.episodes ? routed.tasks.episodes[routed.anchor.episodeId] : null;
+    let epoch = '';
+    try { epoch = String(evolutionStatus(scope).epoch || ''); } catch { epoch = ''; }
     const held = {
-      contextId, projectKey: scope.key, sessionId, batchKey, messageIds,
-      context, anchor: routed.anchor, ranges, decision,
+      contextId, projectKey: scope.key, sessionId, batchKey, messageIds, query,
+      context, anchor: routed.anchor, ranges, decision, epoch,
       episodeUpdatedAt: episode ? episode.updatedAt : '', injectedIds: [],
       at: Date.now(),
     };
@@ -866,42 +1228,77 @@ export function apply(ctx, config) {
     if (!win) return { ok: false, status: 'needs_context', reason: '这个请求的上下文已经过期，先重新问一次当前任务' };
     const held = win.contexts.get(contextId);
     if (!held) return { ok: false, status: 'needs_context', reason: '这个上下文已经过期，先重新问一次当前任务' };
+    /** 凭据只在当轮、当次开关代次内有效：换轮、关闭、重开或过期都不再放行旧正文。 */
+    const expired = (reason) => {
+      win.contexts.delete(contextId);
+      if (win.experiment && win.experiment.contextId === contextId) win.experiment = null;
+      return { ok: false, status: 'needs_context', reason };
+    };
+    if (held.projectKey !== scope.key) return expired('这个上下文属于另一个项目');
+    if (held.sessionId && held.sessionId !== String(win.sessionId || '')) return expired('这个上下文已经过期，先重新问一次当前任务');
+    if (!held.batchKey || held.batchKey !== anchor.requestBatchKey(win.messageIds || [])) {
+      return expired('这个上下文已经过期，先重新问一次当前任务');
+    }
+    let evolution;
+    try { evolution = evolutionStatus(scope); } catch { return expired('当前项目状态读不出来，先重新问一次当前任务'); }
+    if (!evolution || evolution.enabled !== true || evolution.compatible === false) {
+      return expired('项目自进化已经关闭，先重新问一次当前任务');
+    }
+    if (held.epoch && evolution.epoch !== held.epoch) {
+      return expired('项目自进化重新开过，先重新问一次当前任务');
+    }
     return { ok: true, scope, win, context: held.context, experimental: true, held, contextId };
   }
 
-  /** 工具模式没有自动索引时，按本轮真人消息现开一个请求上下文，仍要前台点名栏目才绑定。 */
+  /** 工具模式没有自动索引时，按本轮真人消息现开一个请求上下文，只按问题与记忆范围的字面关系判断。 */
   function toolContextFor(execution) {
     const win = windowOf(execution && execution.agent);
     if (!win || !win.sessionId || !Array.isArray(win.messageIds) || win.messageIds.length === 0) return '';
-    let status;
-    try { status = evolutionStatus(scopeOf(cwdOf(execution))); } catch { return ''; }
-    if (!status || status.enabled !== true || status.compatible === false) return '';
     const scope = scopeOf(cwdOf(execution));
     if (scope.confirmed !== true) return '';
+    let status;
+    try { status = evolutionStatus(scope); } catch { return ''; }
+    if (!status || status.enabled !== true || status.compatible === false) return '';
     const batchKey = anchor.requestBatchKey(win.messageIds);
-    const held = win.experiment && win.experiment.batchKey === batchKey ? win.experiment : null;
+    const held = win.experiment && win.experiment.batchKey === batchKey && win.experiment.epoch === status.epoch
+      ? win.experiment
+      : null;
     if (held) return held.contextId;
     const contextId = anchor.contextIdFor(scope.key, batchKey, crypto.randomUUID().slice(0, 8));
     const created = {
       contextId, projectKey: scope.key, sessionId: win.sessionId, batchKey,
-      messageIds: win.messageIds.slice(), context: view.trustedContext(scope, {}),
-      anchor: null, ranges: rangesOf(scope), decision: { kind: 'none' }, at: Date.now(),
+      messageIds: win.messageIds.slice(), query: trustedQueryOf(win), context: view.trustedContext(scope, {}),
+      anchor: null, ranges: rangesOf(scope), decision: { kind: 'none' }, epoch: status.epoch, at: Date.now(),
     };
     win.experiment = created;
     win.contexts.set(contextId, created);
     return contextId;
   }
 
+  /** 本轮真人消息是唯一可信的任务依据；模型自己写的 query 只用于检索词，不能拿来建绑定。 */
+  function trustedQueryOf(win) {
+    return win && typeof win.query === 'string' ? win.query : '';
+  }
+
   /** 前台绑定只升到 proposed：真正执行链还没发生，不冒充 active。 */
-  function bindSelection(execution, resolved, query) {
+  function bindSelection(execution, resolved) {
     const held = resolved.held;
+    if (!held || typeof held !== 'object') return { ok: false, status: 'needs_context', reason: '本轮还没有可核对的用户消息，先重新问一次当前任务' };
+    const query = held.query || trustedQueryOf(resolved.win);
+    if (!query) return { ok: false, status: 'needs_context', reason: '本轮还没有可核对的用户消息，先重新问一次当前任务' };
     const ranges = held.ranges || { series: [], taskKinds: [] };
+    /** 自动路由已经选了范围就沿用同一个结果，工具绑定不重新猜一遍，避免两处给出不同任务。 */
+    const routedAnchor = held.anchor && typeof held.anchor === 'object' ? held.anchor : null;
     const hits = [];
-    for (const value of ranges.series || []) if (query.includes(value)) hits.push({ seriesId: value });
-    for (const value of ranges.taskKinds || []) if (query.includes(value)) hits.push({ taskKind: value });
+    if (routedAnchor && routedAnchor.seriesId) hits.push({ seriesId: routedAnchor.seriesId });
+    else if (routedAnchor && routedAnchor.taskKind) hits.push({ taskKind: routedAnchor.taskKind });
+    else {
+      for (const value of ranges.series || []) if (anchor.seriesChosenBy(query, value)) hits.push({ seriesId: value });
+      for (const value of ranges.taskKinds || []) if (anchor.seriesChosenBy(query, value)) hits.push({ taskKind: value });
+    }
     if (hits.length !== 1) {
       const names = [...(ranges.series || []), ...(ranges.taskKinds || [])].slice(0, 3);
-      return { ok: false, status: 'needs_context', reason: names.length ? `先在问题里点名一个栏目：${names.join('、')}` : '先说要做的栏目' };
+      return { ok: false, status: 'needs_context', reason: names.length ? '本轮没有匹配的记忆范围，按当前任务继续' : '本轮没有适用的记忆范围，按当前任务继续' };
     }
     let tasks;
     try { tasks = taskState(resolved.scope); } catch { return { ok: false, status: 'needs_context', reason: '任务状态还没读出来' }; }
@@ -920,7 +1317,11 @@ export function apply(ctx, config) {
     resolved.context = held.context;
     const text = renderExperiment(resolved.scope, held.decision, held.context, held, resolved.win);
     const preparedState = prepared.get(execution && execution.agent);
-    if (preparedState) preparedState.experimentText = text;
+    if (preparedState) {
+      preparedState.experimentText = text;
+      preparedState.experimentParts = held.experimentParts || null;
+      preparedState.validUntil = held.validUntil || '';
+    }
     return { ok: true };
   }
 
@@ -936,7 +1337,22 @@ export function apply(ctx, config) {
       if (state.signal && signal && state.signal !== signal) return '';
       const sessionId = agent?.session?.id;
       if (state.sessionId !== (typeof sessionId === 'string' ? sessionId : '')) return '';
-      return [state.experimentText, state.text].filter(Boolean).join('\n\n');
+      /** 开关/自进化换代后，关掉前准备好的正文一律不再输出。 */
+      const scope = scopeOf(cwdOf({ agent }));
+      if (!memoryEnabled(scope)) return '';
+      const epoch = controlStatus(scope).epoch || '';
+      if (state.controlEpoch && epoch && state.controlEpoch !== epoch) return '';
+      /** 自进化关掉或换过代：关掉前的实验正文不再输出，重开也不复活。 */
+      let evolutionText = state.experimentParts ? experimentTextFrom(state.experimentParts) : state.experimentText;
+      if (evolutionText) {
+        let evolution;
+        try { evolution = evolutionStatus(scope); } catch { evolution = null; }
+        if (!evolution || evolution.enabled !== true || evolution.compatible === false
+          || (state.evolutionEpoch && String(evolution.epoch || '') !== state.evolutionEpoch)) evolutionText = '';
+      }
+      /** 没有逐条快照时才退回整段到期判断；有快照就只撤到期的那一条。 */
+      if (evolutionText && !state.experimentParts && state.validUntil && Date.now() > Date.parse(String(state.validUntil))) evolutionText = '';
+      return [evolutionText, state.text].filter(Boolean).join('\n\n');
     } catch {
       return '';
     }
@@ -945,7 +1361,7 @@ export function apply(ctx, config) {
 
   ctx.effect(() => tools.register({
     name: 'memory_save',
-    description: `保存一条记忆。用户明确说「记住」时直接调用；用户自己的话已经是长期规则（「以后都这样」「别再 X」）时也直接调用，不要先问。更新同一件事时带 id：身份只看标题、旧标题和前置条件，像不像不授权覆盖。文本相近但标题不同时先不写，返回 needsResolution 与 1–2 条相近条目：确实是同一条就用那个 id 更新，确实是另一条才带 resolution="distinct" 再存。带 id 更新时没给的字段保持原值，正文整段替换，旧版本留在 versions 里（每字都留，不截断）。条数到硬上限时把同层最久没被读的一条移进归档，结果里写明动了哪条，不拒绝新记忆；单条正文超限只报错、不截断。前置条件不同的同一标题是两条。${NOTES}`,
+    description: `保存一条记忆。只在会改变以后判断时才存；先搜已有条目，能更新就不要新建。保存前先蒸馏：标题是结论，正文只写原则与触发条件，不抄原始输出里的具体数值。用户明确说「记住」时直接调用；用户自己的话已经是长期规则（「以后都这样」「别再 X」）时也直接调用，不要先问。更新同一件事时带 id：身份只看标题、旧标题和前置条件，像不像不授权覆盖。文本相近但标题不同时先不写，返回 needsResolution 与 1–2 条相近条目：确实是同一条就用那个 id 更新，确实是另一条才带 resolution="distinct" 再存。带 id 更新时没给的字段保持原值，正文整段替换，旧正文只留作内部撤回，不展示也不参与检索。条数到硬上限时把同层最久没被读的一条移进归档，结果里写明动了哪条，不拒绝新记忆；单条正文超限只报错、不截断。前置条件不同的同一标题是两条。${NOTES}`,
     parameters: SAVE_PARAMS,
     output: {
       presentationMeta: (_args, value) => ({
@@ -967,10 +1383,13 @@ export function apply(ctx, config) {
           title: { type: 'string' },
           summary: { type: 'string' },
           when: { type: 'string' },
+          summaryShortened: { type: 'boolean' },
+          fullTextInBody: { type: 'boolean' },
           revision: { type: 'integer' },
           merged: { type: 'boolean' },
           changed: { type: 'boolean' },
           scope: { type: 'string' },
+          scopeName: { type: 'string' },
           needsResolution: { type: 'boolean' },
           needsScope: { type: 'boolean' },
           reason: { type: 'string' },
@@ -988,20 +1407,30 @@ export function apply(ctx, config) {
       render: (_args, value) => [{
         type: 'text',
         text: value.needsScope
-          ? value.reason === 'unconfirmed_project'
+          ? value.reason === 'memory_disabled'
+            ? 'memory · 本项目记忆已关闭，先在面板打开'
+            : value.reason === 'unconfirmed_project'
             ? `memory · 当前目录还不能确认属于哪个项目：「${value.title}」\n先确认项目根目录，或显式 scope="global"`
             : `memory · 归属还没定：「${value.title}」\n补 memoryClass（personal_preference / project_fact / environment_fact / portable_procedure）或显式 scope；设备事实还要给设备条件`
           : value.existingId
-            ? `memory · 已有相同记忆：「${value.title}」 · ${value.existingId}（${value.existingScope}）第 ${value.revision} 版\n要改成另一条，加 resolution="distinct"`
+            ? `memory · 已有相同记忆：「${value.title}」 · ${value.existingId}（${value.existingScope}）\n要改成另一条，加 resolution="distinct"`
             : value.needsResolution
           ? `memory · 需要确认：「${value.title}」与已有条目相近${value.crossLayer ? '（在另一层）' : ''}${value.sameTopic ? '（同一主题槽位）' : ''}\n${value.similar}\n要更新它，用 id 重存；确实是另一条，加 resolution="distinct"`
           : value.changed === false
-            ? `memory · unchanged${scopeLabel(value)} "${value.title}" · ${value.id} · 第 ${value.revision} 版`
-            : `memory · ${value.merged ? 'merged' : 'saved'}${scopeLabel(value)} "${value.title}"${value.when ? `（${value.when}）` : ''} · ${value.id} · 第 ${value.revision} 版${value.similar ? ` · 相近：${value.similar}` : ''}${value.archived ? ` · 已归档「${value.archived}」腾位` : ''}`,
+            ? `memory · unchanged ${withTag(value, `"${value.title}"`)} · ${value.id}`
+            : `memory · ${value.merged ? 'merged' : 'saved'} ${withTag(value, `"${value.title}"`)}${value.when ? `（${value.when}）` : ''} · ${value.id}${value.similar ? ` · 相近：${value.similar}` : ''}${value.archived ? ` · 已归档「${value.archived}」腾位` : ''}${value.fullTextInBody ? ' · 摘要超过 60 字，完整原句已存进正文' : ''}`,
       }],
     },
     execute: async (args, execution) => {
       const projectScope = scopeOf(cwdOf(execution));
+      const projectScopeName = projectNameOf(projectScope);
+      if (!memoryEnabled(projectScope)) {
+        return {
+          id: '', title: String(args.title || ''), summary: '', when: '', revision: 0,
+          merged: false, changed: false, scope: '', needsScope: true, reason: 'memory_disabled',
+          needsResolution: false, similarIds: '', similar: '', archived: '',
+        };
+      }
       const saved = saveEntry(projectScope, { ...args, writeMode: args.mode || 'patch' });
       if (saved.needsScope) {
         return {
@@ -1031,6 +1460,7 @@ export function apply(ctx, config) {
           merged: false,
           changed: false,
           scope: saved.existing.scope,
+          scopeName: saved.existing.scope === 'global' ? '' : projectScopeName,
           needsScope: false,
           existingId: saved.existing.id,
           existingScope: saved.existing.scope,
@@ -1066,10 +1496,13 @@ export function apply(ctx, config) {
         title: saved.record.title,
         summary: saved.record.summary,
         when: saved.record.when || '',
+        summaryShortened: Boolean(saved.draft?.summaryShortened),
+        fullTextInBody: Boolean(saved.draft?.fullTextInBody),
         revision: saved.record.revision || 1,
         merged: saved.merged,
         changed: !saved.noop,
         scope: scope.key === 'global' ? 'global' : 'project',
+        scopeName: scope.key === 'global' ? '' : projectScopeName,
         needsScope: false,
         needsResolution: false,
         similarIds: saved.similarList.map((item) => item.id).join('、'),
@@ -1107,6 +1540,7 @@ export function apply(ctx, config) {
     },
     execute: async (args, execution) => {
       const scope = scopeOf(cwdOf(execution));
+      if (!memoryEnabled(scope)) return { asked: false, reason: '本项目记忆已关闭' };
       const gate = suggestionGate(scope, args);
       if (!gate.ok) return { asked: false, reason: gate.reason };
       const noted = noteSuggestion(scope, gate.target ? { ...args, targetId: gate.target.id } : args);
@@ -1121,7 +1555,7 @@ export function apply(ctx, config) {
 
   ctx.effect(() => tools.register({
     name: 'memory_search',
-    description: `按需检索已有记忆：先搜，命中再 memory_read 读正文。用户提到「记住了什么 / 上次 / 规范 / 约定 / 路径 / 凭据怎么取」，或者眼前反复出现的报错、弹窗、异常时，先查这里有没有记过解法。跨项目的通用条目以 [全局] 开头。中文长句可以直接当查询。每行带 id 与版次，更新时把 id 传回 memory_save。默认只列当前有效的；已经归档或被新版本替换的旧说法不混进来，要查历史就在参数里显式要 history。`,
+    description: `按需检索已有记忆：先搜，命中再 memory_read 读正文。用户提到「记住了什么 / 上次 / 规范 / 约定 / 路径 / 凭据怎么取」，或者眼前反复出现的报错、弹窗、异常时，先查这里有没有记过解法。跨项目的通用条目以 [global] 开头，项目条目以 [项目名] 开头。中文长句可以直接当查询。每行带 id，更新时把 id 传回 memory_save。默认只列当前有效的；已经归档或被更新替换的旧说法不混进来，要查历史就在参数里显式要 history。`,
     parameters: SEARCH_PARAMS,
     output: {
       presentationMeta: (_args, value) => ({ kind: 'memory-search', count: value.count, status: value.status || 'ok', refs: value.refs || [] }),
@@ -1132,6 +1566,7 @@ export function apply(ctx, config) {
           chars: { type: 'integer' },
           text: { type: 'string' },
           status: { type: 'string', enum: ['ok', 'budget_exhausted', 'memory_disabled', 'needs_context'] },
+          reasonCode: { type: 'string' },
           refs: {
             type: 'array',
             items: {
@@ -1142,8 +1577,9 @@ export function apply(ctx, config) {
                 scope: { type: 'string' },
                 revision: { type: 'integer' },
                 status: { type: 'string' },
+                origin: { type: 'string' },
               },
-              required: ['id', 'title', 'scope', 'revision', 'status'],
+              required: ['id', 'title', 'scope', 'revision', 'status', 'origin'],
               additionalProperties: false,
             },
           },
@@ -1165,7 +1601,7 @@ export function apply(ctx, config) {
       }],
     },
     execute: async (args, execution) => {
-      if (recallMode() === 'off') return { count: 0, chars: 0, text: '', status: 'memory_disabled', refs: [] };
+      if (recallMode() === 'off' || !memoryEnabledFor(execution)) return { count: 0, chars: 0, text: '', status: 'memory_disabled', refs: [] };
       const agent = execution?.agent;
       const win = windowOf(agent);
       if (win && !affordable(win, 0)) return { count: 0, chars: 0, text: '', status: 'budget_exhausted', refs: [] };
@@ -1177,21 +1613,50 @@ export function apply(ctx, config) {
       const resolved = resolveRequestContext(execution, contextId);
       if (!resolved.ok) return { count: 0, chars: 0, text: resolved.reason, status: resolved.status || 'needs_context', refs: [] };
       if (wantsBind) {
-        const bound = bindSelection(execution, resolved, String(args.query || ''));
+        const bound = bindSelection(execution, resolved);
         if (!bound.ok) return { count: 0, chars: 0, text: bound.reason, status: bound.status || 'needs_context', refs: [] };
       }
       const scope = resolved.scope;
       const context = resolved.context;
-      const hits = search(scope, args.query, args.limit ?? 3, {
+      /** 检索只列当前任务真能用的条目；先取全量候选，过滤后再截断，避免不可用条目挤掉后面的命中。 */
+      const limit = args.limit ?? 3;
+      const rawHits = search(scope, args.query, 50, {
         context,
         history: args.history === true,
         allowExperimental: resolved.experimental === true,
-      });
-      const shown = hits.map((item) => view.toModelView(item, 'search', { status: item.status || (item.archived ? 'archived' : 'ok') }));
+      }).filter((item) => !item.ownerProjectId || item.ownerProjectId === scope.key);
+      const hits = rawHits.filter((item) => item.archived || item.status === 'ok').slice(0, limit);
+      const withheld = rawHits.filter((item) => !item.archived && item.status !== 'ok');
+      const scopeName = scope.key === 'global' ? '' : projectNameOf(scope);
+      const shown = hits.map((item) => ({
+        ...view.toModelView(item, 'search', { status: item.status || (item.archived ? 'archived' : 'ok') }),
+        scopeName: item.scope === 'global' ? '' : scopeName,
+      }));
       const valueOf = (kept) => {
         const rendered = renderIndex(shown.slice(0, kept));
         return { count: kept, chars: rendered.chars, text: rendered.text, status: 'ok', refs: refsOf(hits.slice(0, kept)) };
       };
+      /** 有匹配但当前用不上：只说状态，不把标题、编号或旧规则递给模型，避免它被这些字面带偏。 */
+      if (!hits.length && withheld.length) {
+        const unresolved = withheld.some((item) => item.status === 'needs_context');
+        const value = {
+          count: 0,
+          chars: 0,
+          text: unresolved
+            ? '有相关的项目记忆，但适用条件还没确认。先说明当前任务，或确认这条记忆的适用范围。'
+            : '有相关的项目记忆，但当前任务明确不适用。',
+          status: unresolved ? 'needs_context' : 'ok',
+          reasonCode: unresolved ? 'applicability_unresolved' : 'not_applicable',
+          refs: [],
+        };
+        if (win) {
+          const bytes = jsonBytes(value);
+          if (!affordable(win, bytes)) return { ...value, status: 'budget_exhausted', text: '' };
+          win.bytes += bytes;
+          win.reads += 1;
+        }
+        return value;
+      }
       /** 没命中是正常结果，不是额度问题；空响应同样记一次本请求开销。 */
       if (!hits.length) {
         const empty = { count: 0, chars: 0, text: '', status: 'ok', refs: [] };
@@ -1232,6 +1697,7 @@ export function apply(ctx, config) {
           when: { type: 'string' },
           revision: { type: 'integer' },
           scope: { type: 'string' },
+          scopeName: { type: 'string' },
           origin: { type: 'string', enum: ['user_explicit', 'project_evolution'] },
           status: { type: 'string', enum: ['ok', 'archived', 'needs_context', 'not_applicable', 'gone', 'budget_exhausted', 'memory_disabled'] },
           body: { type: 'string' },
@@ -1248,10 +1714,20 @@ export function apply(ctx, config) {
           : value.status === 'memory_disabled'
             ? 'memory · 记忆检索已关闭'
             : value.repeat
-              ? `memory · 本请求已读过「${value.title}」 · ${value.id} · 第 ${value.revision} 版`
+              ? 'memory · 本请求已读过这条记忆'
               : value.body
-                ? `memory · 「${value.title}」${value.when ? `（${value.when}）` : ''} · ${value.id} · 第 ${value.revision} 版${scopeLabel(value)}${statusLabel(value.status)}\n${value.body}`
-                : `memory · 「${value.title}」的相关记忆\n${value.links || '(无)'}`,
+                ? `memory · ${withTag(value, `「${value.title}」`)}${value.when ? `（${value.when}）` : ''} · ${value.id}${statusLabel(value.status)}\n${value.body}`
+                : value.links !== undefined && value.status === 'ok'
+                  ? `memory · 「${value.title}」的相关记忆\n${value.links || '(无)'}`
+                  : value.status === 'needs_context'
+                    ? 'memory · 这条记忆的适用条件还没确认'
+                    : value.status === 'not_applicable'
+                      ? 'memory · 这条记忆不适用于当前任务'
+                      : value.status === 'archived'
+                        ? 'memory · 这条记忆已归档'
+                        : value.status === 'gone'
+                          ? 'memory · 这条记忆已不存在'
+                          : 'memory · 当前不能读这条记忆',
       }],
       presentationMeta: (_args, value) => ({
         kind: 'memory-read',
@@ -1264,10 +1740,11 @@ export function apply(ctx, config) {
       }),
     },
     execute: async (args, execution) => {
-      if (recallMode() === 'off') return { id: '', scope: '', status: 'memory_disabled' };
+      if (recallMode() === 'off' || !memoryEnabledFor(execution)) return { id: '', scope: '', status: 'memory_disabled' };
       const resolved = resolveRequestContext(execution, args.contextId);
       if (!resolved.ok) return { id: '', scope: '', status: resolved.status || 'needs_context' };
       const scope = resolved.scope;
+      const scopeName = scope.key === 'global' ? '' : projectNameOf(scope);
       const context = resolved.context;
       const allowExperimental = resolved.experimental === true;
       const agent = execution?.agent;
@@ -1275,11 +1752,22 @@ export function apply(ctx, config) {
       if (args.view === 'links') {
         const found = readLinks(scope, args.id, { context, allowExperimental });
         if (!found) throw new Error(`没有 ${args.id} 这条记忆`);
-        const rows = found.links.map((link) => (link.status === 'invalid'
+        if (found.status !== 'ok') {
+          const withheld = { id: '', scope: '', status: found.status, links: '' };
+          if (win) {
+            const bytes = jsonBytes(withheld);
+            if (!affordable(win, bytes)) return { id: '', scope: '', status: 'budget_exhausted' };
+            win.bytes += bytes;
+            win.reads += 1;
+          }
+          return withheld;
+        }
+        const rows = found.links.filter((link) => link.status === 'invalid' || link.status === 'ok')
+          .map((link) => (link.status === 'invalid'
           ? `- ${link.id} · 已失效`
-          : `- 「${link.title}」${link.scope === 'global' ? ' [全局]' : ''} · ${link.id} · 第 ${link.revision} 版`));
+          : `- ${link.scope === 'global' ? '[global] ' : (scopeName ? `[${scopeName}] ` : '')}「${link.title}」 · ${link.id}`));
         const text = rows.join('\n') || '(无)';
-        const value = { id: found.id, scope: found.scope, status: found.status, links: text };
+        const value = { id: found.id, scope: found.scope, scopeName, status: found.status, links: text };
         if (win) {
           const bytes = jsonBytes(value);
           if (!affordable(win, bytes)) return { id: '', scope: '', status: 'budget_exhausted' };
@@ -1290,16 +1778,23 @@ export function apply(ctx, config) {
       }
       const record = readEntry(scope, args.id, { context, allowExperimental });
       if (!record) throw new Error(`没有 ${args.id} 这条记忆`);
+      if (record.origin === 'project_evolution' && record.ownerProjectId && record.ownerProjectId !== scope.key) {
+        return { id: '', scope: record.scope, status: 'not_applicable', body: '' };
+      }
       if (record.origin === 'project_evolution' && !allowExperimental) {
-        return { id: record.id, title: record.title, when: record.when || '', revision: record.revision || 1, scope: record.scope, status: 'needs_context', body: '' };
+        return { id: '', scope: record.scope, status: 'needs_context', body: '' };
+      }
+      /** 暂停、过期或条件不匹配的实验条目只给状态，不给标题和正文。 */
+      if (record.origin === 'project_evolution' && !view.experimentalUsable(record)) {
+        return { id: '', scope: record.scope, status: 'needs_context', body: '' };
       }
-      /** 暂停或条件不匹配的实验条目只给状态，不给正文。 */
       const learningState = record.learning && typeof record.learning === 'object' ? record.learning : {};
       if (record.origin === 'project_evolution' && (learningState.state === 'paused' || learningState.blockedReason)) {
-        return { id: record.id, title: record.title, when: record.when || '', revision: record.revision || 1, scope: record.scope, status: 'needs_context', body: '' };
+        return { id: '', scope: record.scope, status: 'needs_context', body: '' };
       }
-      if (record.origin === 'project_evolution' && record.status !== 'ok') {
-        return { id: record.id, title: record.title, when: record.when || '', revision: record.revision || 1, scope: record.scope, status: record.status === 'needs_context' ? 'needs_context' : 'not_applicable', body: '' };
+      /** 条件未知或不适用的条目只报状态：正文和标题都不能绕过自动召回的门槛。 */
+      if (record.status !== 'ok') {
+        return { id: '', scope: record.scope, status: record.status === 'needs_context' ? 'needs_context' : 'not_applicable', body: '' };
       }
       const revision = record.revision || 1;
       const body = String(record.body ?? '');
@@ -1309,6 +1804,7 @@ export function apply(ctx, config) {
         when: record.when || '',
         revision,
         scope: record.scope,
+        scopeName,
         status: record.status,
         body,
       };
@@ -1346,20 +1842,23 @@ export function apply(ctx, config) {
           id: { type: 'string' },
           title: { type: 'string' },
           scope: { type: 'string' },
-          mode: { type: 'string', enum: ['archive', 'purged', 'needs_resolution', 'purge_pending'] },
+          scopeName: { type: 'string' },
+          mode: { type: 'string', enum: ['archive', 'purged', 'needs_resolution', 'purge_pending', 'memory_disabled'] },
         },
         required: ['id', 'mode'],
         additionalProperties: false,
       },
       render: (_args, value) => [{
         type: 'text',
-        text: value.mode === 'purged'
+        text: value.mode === 'memory_disabled'
+          ? 'memory · 本项目记忆已关闭，先在面板打开'
+          : value.mode === 'purged'
           ? `memory · forgotten "${value.title}" · ${value.id}`
           : value.mode === 'purge_pending'
             ? `memory · 清除未完成 · ${value.id}，重启后会继续`
             : value.mode === 'needs_resolution'
               ? `memory · 先确认是归档还是彻底忘掉 · ${value.id}`
-              : `memory · archived${scopeLabel(value)} "${value.title}" · ${value.id}，可找回`,
+              : `memory · archived ${withTag(value, `"${value.title}"`)} · ${value.id}，可找回`,
       }],
       presentationMeta: (_args, value) => ({
         kind: 'memory-forget',
@@ -1371,6 +1870,8 @@ export function apply(ctx, config) {
     },
     execute: async (args, execution) => {
       const scope = scopeOf(cwdOf(execution));
+      const projectScopeName = projectNameOf(scope);
+      if (!memoryEnabled(scope)) return { id: String(args.id || ''), title: '', scope: '', mode: 'memory_disabled' };
       const located = locate(scope, args.id);
       if (!located && !args.mode) throw new Error(`没有 ${args.id} 这条记忆`);
       if (!args.mode) {
@@ -1392,6 +1893,7 @@ export function apply(ctx, config) {
                 title: located ? located.record.title : '',
                 mode: 'purge_pending',
                 scope: layer.key === 'global' ? 'global' : 'project',
+                scopeName: layer.key === 'global' ? '' : projectScopeName,
               };
             }
             throw again;
@@ -1402,11 +1904,13 @@ export function apply(ctx, config) {
       }
       if (!dropped) throw new Error(`没有 ${args.id} 这条记忆`);
       const layerKey = dropped.scopeKey || (located ? located.scope.key : scope.key);
+      if (dropped.mode === 'purged') revokeLearningUse(layerKey);
       return {
         id: dropped.id,
         title: dropped.title || (located ? located.record.title : ''),
         mode: dropped.mode,
         scope: layerKey === 'global' ? 'global' : 'project',
+        scopeName: layerKey === 'global' ? '' : projectScopeName,
       };
     },
   }), 'lite-memory: memory_forget');
@@ -1445,9 +1949,23 @@ export function apply(ctx, config) {
     }), 'lite-memory: recall context');
   }
 
+  /** 执行入口再拦一次：工具若已出现在旧快照里，调用时也不放行。 */
+  if (typeof ctx.on === 'function') ctx.on('agent/created', (payload) => {
+    const agent = payload?.agent;
+    if (!agent?.ctx?.tools) return;
+    try {
+      agent.ctx.effect(() => agent.ctx.tools.guard((execution) => {
+        if (!MEMORY_TOOLS.includes(execution?.name)) return undefined;
+        return memoryOnForAgent(agent) ? undefined : '本项目记忆已关闭，先在面板打开';
+      }), 'lite-memory: tool guard');
+    } catch { /* older host without guards */ }
+    syncMemoryTools(agent);
+  });
+
   if (typeof ctx.on === 'function') ctx.on('agent/pre-step', async (payload, next) => {
     const startedAt = Date.now();
     const agent = payload?.agent;
+    syncMemoryTools(agent);
     let decision;
     try {
       decision = await next();
@@ -1488,6 +2006,10 @@ export function apply(ctx, config) {
         }
         previous.signal = signal;
         const scope = scopeOf(cwdOf({ agent }));
+        if (!memoryEnabled(scope)) {
+          clearPrepared(agent);
+          return decision;
+        }
         const fingerprint = fingerprintOf(scope);
         /** 指纹拿不到就当作已失效：不拿旧任务内容硬撑这一步。 */
         if (!fingerprint) {
@@ -1506,6 +2028,8 @@ export function apply(ctx, config) {
               previous.text = snapshot ? snapshot.text : '';
               previous.cards = snapshot ? snapshot.cards : [];
               previous.experimentText = experimentText;
+              previous.experimentParts = win && win.experiment ? (win.experiment.experimentParts || null) : null;
+              previous.validUntil = win && win.experiment ? (win.experiment.validUntil || '') : '';
               previous.fingerprint = fingerprint;
             } else {
               clearPrepared(agent);
@@ -1518,13 +2042,15 @@ export function apply(ctx, config) {
       /** 工具模式也要开额度窗口：只是不自动注入，工具调用同样受每请求预算约束。 */
       const ids = fresh.map((message) => String(message?.id ?? '')).filter(Boolean).sort();
       const win = openWindow(agent, { sessionId, turn, messageIds: ids });
+      /** 工具模式也要记下本轮真人原话：只用于核对绑定，不自动注入。 */
+      const query = view.newestUserQuery(fresh).slice(0, RECALL_QUERY_CHARS);
+      if (win && query) win.query = query;
 
       if (recallMode() !== 'adaptive') {
         clearPrepared(agent);
         return decision;
       }
 
-      const query = view.newestUserQuery(fresh).slice(0, RECALL_QUERY_CHARS);
       if (!query) {
         clearPrepared(agent);
         return decision;
@@ -1535,36 +2061,51 @@ export function apply(ctx, config) {
         return decision;
       }
       const scope = scopeOf(cwd);
+      if (!memoryEnabled(scope)) {
+        clearPrepared(agent);
+        return decision;
+      }
       const context = view.trustedContext(scope, {});
       const fingerprint = fingerprintOf(scope);
-      const experiment = experimentFor(scope, { sessionId, query, batchKey: anchor.requestBatchKey(ids), messageIds: ids, win });
+      const controlEpoch = controlStatus(scope).epoch || '';
+      const batchKey = anchor.requestBatchKey(ids);
+      dropStaleCandidate(sessionId, batchKey);
+      const experiment = experimentFor(scope, { sessionId, query, batchKey, messageIds: ids, win });
       const remembered = experiment && experiment.held
-        ? rememberFeedback(scope, sessionId, fresh, experiment.held)
+        ? rememberFeedback(scope, sessionId, fresh, experiment.held, turn)
         : null;
-      if (remembered && remembered.paused) {
+      const snapshot = projectRecall(scope, query, context, win);
+      if (generation !== generations.get(agent)) return decision;
+      /** 投影期间开关被改过：丢弃这批内容，不把关闭前的记忆交给当前请求。 */
+      if (!memoryEnabled(scope) || (controlStatus(scope).epoch || '') !== controlEpoch) {
         clearPrepared(agent);
         return decision;
       }
-      const snapshot = projectRecall(scope, query, context, win);
-      if (generation !== generations.get(agent)) return decision;
       /** 超时或被取消：这一步不留半旧卡片，下一真人请求重新投影。 */
       if (signal?.aborted || Date.now() - startedAt > RECALL_DEADLINE_MS) {
         clearPrepared(agent);
         return decision;
       }
-      if (!snapshot && !(experiment && experiment.text)) {
+      /** 实验上下文即使本轮零注入也要留着：工具绑定后同一请求还能补上规则。 */
+      if (!snapshot && !experiment) {
         clearPrepared(agent);
         return decision;
       }
+      let evolutionEpoch = '';
+      try { evolutionEpoch = String(evolutionStatus(scope).epoch || ''); } catch { evolutionEpoch = ''; }
       const state = {
         text: snapshot ? snapshot.text : '',
         experimentText: experiment ? experiment.text : '',
+        experimentParts: experiment && experiment.held ? (experiment.held.experimentParts || null) : null,
+        validUntil: experiment && experiment.held ? (experiment.held.validUntil || '') : '',
         cards: snapshot ? snapshot.cards : [],
         query,
         sessionId,
         turn,
         signal,
         fingerprint,
+        controlEpoch,
+        evolutionEpoch,
         at: Date.now(),
       };
       prepared.set(agent, state);
@@ -1586,8 +2127,19 @@ export function apply(ctx, config) {
 
   /* ---------------- 项目自进化：一次短整理，先扣频次，再走提交门禁 ---------------- */
 
-  /** 反馈只来自本轮真人消息；初始任务、工具成功、沉默都不算。 */
-  function rememberFeedback(scope, sessionId, messages, held) {
+  /** 只清不属于当前这批人类消息的旧候选：新一轮开始后，上一轮没整理完的反馈不能再落盘。 */
+  function dropStaleCandidate(sessionId, batchKey) {
+    const prior = feedbackCandidates.get(sessionId);
+    if (prior && prior.candidate && prior.candidate.batchKey !== batchKey) {
+      feedbackCandidates.delete(sessionId);
+    }
+  }
+
+  /**
+   * 反馈只来自本轮真人消息；初始任务、工具成功、沉默都不算。
+   * 解析目标由整理器完成：不在这里暂停所有已注入规则，避免一次 BGM 纠正打掉开头和字幕。
+   */
+  function rememberFeedback(scope, sessionId, messages, held, turn) {
     let candidate;
     try {
       candidate = learning.candidateFrom({
@@ -1597,21 +2149,22 @@ export function apply(ctx, config) {
     if (!candidate) return null;
     candidate.cwd = scope.cwd;
     candidate.episodeUpdatedAt = held.episodeUpdatedAt || '';
-    let paused = false;
-    const injected = Array.isArray(held.injectedIds) ? held.injectedIds.filter(Boolean).slice(0, 8) : [];
-    if (candidate.cue.negative && injected.length) {
-      try {
-        const result = pauseLearningRules(scope, injected, {
-          by: 'feedback',
-          reason: 'feedback_pending',
-          operationId: `pause_${candidate.episodeId}_${candidate.messageIds.join('_')}`.slice(0, 120),
-        });
-        paused = Boolean(result && result.ok && result.changed);
-      } catch { paused = false; }
-    }
-    feedbackCandidates.set(sessionId, { scope, candidate, held, paused, at: Date.now() });
+    candidate.batchKey = held.batchKey || '';
+    candidate.turn = String(turn || '');
+    const revision = (feedbackRevisions.get(scope.key) || 0) + 1;
+    feedbackRevisions.set(scope.key, revision);
+    candidate.feedbackRevision = revision;
+    const prior = feedbackCandidates.get(sessionId);
+    feedbackCandidates.set(sessionId, {
+      scope,
+      candidate,
+      held,
+      session: prior && prior.session ? prior.session : null,
+      queued: Boolean(prior && prior.queued),
+      at: Date.now(),
+    });
     while (feedbackCandidates.size > 8) feedbackCandidates.delete(feedbackCandidates.keys().next().value);
-    return { candidate, paused };
+    return { candidate };
   }
 
   /** 只认前台最近一次真实请求的路线；拿不到就宁可这次不整理。 */
@@ -1695,6 +2248,10 @@ export function apply(ctx, config) {
         else if (chunk && chunk.type === 'finish' && chunk.reason) finish = chunk.reason;
       }
       if (sawTool) throw new Error('整理返回了工具调用');
+      /** 运行期间用户又给了新反馈：旧结果不能覆盖新纠正，直接作废，等排队的下一次整理。 */
+      if ((feedbackRevisions.get(scope.key) || 0) !== candidate.feedbackRevision) {
+        throw new Error('反馈已更新，这次整理作废');
+      }
       const parsed = learning.parseOutput(text, { finish, refs: input.refs, rules: input.rules, ranges });
       if (!parsed.ok) throw new Error(parsed.reason);
       const commit = commitLearning(scope, {
@@ -1737,6 +2294,42 @@ export function apply(ctx, config) {
     }
   }
 
+  /** 启动一次整理；结束后再看同项目是否还排着一条候选。 */
+  function startOrganizer(scope, session, pending) {
+    const job = { controller: learningAborts.get(scope.key) || null };
+    learningJobs.set(scope.key, job);
+    void organize(scope, session, pending)
+      .catch(() => { /* 整理失败不影响会话 */ })
+      .finally(() => {
+        if (learningJobs.get(scope.key) === job) learningJobs.delete(scope.key);
+        drainOrganizer(scope.key);
+      });
+  }
+
+  /** 彻底删除后中止该层在途整理并丢掉候选：不让旧结果复活已删规则。 */
+  function revokeLearningUse(layerKey) {
+    for (const [scopeKey, controller] of learningAborts) {
+      if (layerKey !== 'global' && scopeKey !== layerKey) continue;
+      try { controller.abort(); } catch { /* already settled */ }
+    }
+    for (const [sessionId, pending] of feedbackCandidates) {
+      if (layerKey !== 'global' && pending?.scope?.key !== layerKey) continue;
+      feedbackCandidates.delete(sessionId);
+    }
+  }
+
+  /** 忙碌时保留一条最新候选，不丢用户刚说的纠正；同一项目仍只跑一个整理。 */
+  function drainOrganizer(scopeKey) {
+    if (learningJobs.has(scopeKey)) return;
+    for (const [sessionId, pending] of feedbackCandidates) {
+      if (!pending || !pending.scope || pending.scope.key !== scopeKey) continue;
+      feedbackCandidates.delete(sessionId);
+      if (!pending.session) return;
+      startOrganizer(pending.scope, pending.session, pending);
+      return;
+    }
+  }
+
   /** 只在正常完成的人类回合后调度，一次一个项目；永不阻塞事件派发。 */
   function scheduleOrganizer(session, event) {
     const reason = event && event.data ? event.data.reason : null;
@@ -1745,14 +2338,18 @@ export function apply(ctx, config) {
     if (!sessionId) return;
     const pending = feedbackCandidates.get(sessionId);
     if (!pending) return;
+    const eventTurn = event.data && event.data.turn !== undefined ? String(event.data.turn) : '';
+    if (eventTurn && pending.candidate && pending.candidate.turn && eventTurn !== pending.candidate.turn) {
+      feedbackCandidates.delete(sessionId);
+      return;
+    }
+    pending.session = session;
+    if (learningJobs.has(pending.scope.key)) {
+      pending.queued = true;
+      return;
+    }
     feedbackCandidates.delete(sessionId);
-    const scope = pending.scope;
-    if (learningJobs.has(scope.key)) return;
-    const job = { controller: learningAborts.get(scope.key) || null };
-    learningJobs.set(scope.key, job);
-    void organize(scope, session, pending)
-      .catch(() => { /* 整理失败不影响会话 */ })
-      .finally(() => { if (learningJobs.get(scope.key) === job) learningJobs.delete(scope.key); });
+    startOrganizer(pending.scope, session, pending);
   }
 
   if (typeof ctx.on === 'function') ctx.on('agent/disposed', (payload) => {
@@ -1773,6 +2370,11 @@ export function apply(ctx, config) {
     if (!signal) return;
     const agent = signalAgents.get(signal);
     if (agent) clearPrepared(agent);
+    /** 被取消或被中断的回合不保留反馈候选，下一句「谢谢」不能把没说完的纠正写进去。 */
+    if (signal.aborted === true && agent) {
+      const sessionId = String(agent?.session?.id ?? '');
+      if (sessionId) feedbackCandidates.delete(sessionId);
+    }
     signalAgents.delete(signal);
   });