dsh-lite-memory 0.18.27 → 0.18.29

package/client.js

@@ -2200,6 +2200,21 @@ window.__ModuleLoader__.load({
 
       React.useEffect(() => { load(); }, [sessionId]);
 
+      /** 待裁决只做两件事：把草稿另存成一条，或删掉这条待办；不在面板里悄悄合并。 */
+      const resolveQueued = (row, op) => {
+        if (!row || busy) return;
+        setBusy(true);
+        setNote('');
+        post('/lite-memory/conflict', { sessionId, scopeKey: selectedKey, title: row.title, op }).then((result) => {
+          if (!alive.current) return;
+          setBusy(false);
+          if (result.ok && result.body && result.body.ok) {
+            if (op === 'drop') setNote('已忽略这条待裁决');
+            load(selectedKey);
+          } else setNote(failure(result, '待裁决没处理成'));
+        });
+      };
+
       /** 显示设置跟着当前项目走；换项目或换范围时重新读。 */
       React.useEffect(() => {
         setDisplay(readDisplaySettings(selectedKey));
@@ -2249,6 +2264,7 @@ window.__ModuleLoader__.load({
       const selected = data ? data.selected : null;
       const records = selected && Array.isArray(selected.records) ? selected.records : EMPTY;
       const total = selected && selected.stats && Number.isInteger(selected.stats.total) ? selected.stats.total : records.length;
+      const queued = selected && Array.isArray(selected.conflicts) ? selected.conflicts : EMPTY;
       const currentKey = current ? current.key : '';
       const control = selected && selected.control
         ? selected.control
@@ -2710,12 +2726,24 @@ window.__ModuleLoader__.load({
       const memoryViewActive = viewModeOf(display, memoryView);
       const evolutionViewActive = graphViewOf(display.graph, evolutionView);
 
+      const conflictBar = queued.length === 0 ? null : h('div', {
+        style: { display: 'flex', flexDirection: 'column', gap: '3px', padding: '7px 9px 8px', borderBottom: '1px solid var(--dsw-alias-border-l1)', flex: '0 0 auto' },
+      },
+      h('div', { style: { ...PANEL_MUTED, lineHeight: '18px' } }, `${queued.length} 条保存没确认`),
+      queued.slice(0, 2).map((row) => h('div', {
+        key: row.id || row.title,
+        style: { display: 'flex', alignItems: 'center', gap: '8px', minWidth: 0 },
+      },
+      h('span', { style: { flex: 1, minWidth: 0, fontSize: '12px', lineHeight: '20px', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' } }, row.title),
+      h(Action, { disabled: busy, onClick: () => resolveQueued(row, 'keep') }, '另存'),
+      h(Action, { disabled: busy, onClick: () => resolveQueued(row, 'drop') }, '忽略'),
+      )));
       const memoryListPane = h('div', {
         style: {
           ...PANEL_CARD, padding: '2px 4px', minHeight: 0, overflowY: 'auto',
           display: 'flex', flexDirection: 'column', gap: 0,
         },
-      }, memoryList);
+      }, conflictBar, memoryList);
       const memoryGraphPane = h('div', {
         style: { ...PANEL_CARD, padding: 0, minHeight: 0, overflow: 'hidden', display: 'flex' },
       },

package/index.js

@@ -3,6 +3,7 @@ import {
   globalScope,
   upsert,
   search,
+  markUsed,
   readEntry,
   readLinks,
   forget,
@@ -12,6 +13,9 @@ import {
   runtimeLayers,
   findAnywhere,
   renderIndex,
+  conflictsOf,
+  resolveConflict,
+  dropConflict,
   loadIndex,
   saveEntry,
   move,
@@ -213,6 +217,7 @@ function keepHandler(webServer, cwdForSession) {
               : pathname === REMOTE_PATH + '/entry' ? 'entry'
               : pathname === REMOTE_PATH + '/move' ? 'move'
                 : pathname === REMOTE_PATH + '/overview' ? 'overview'
+                  : pathname === REMOTE_PATH + '/conflict' ? 'conflict'
                   : pathname === REMOTE_PATH + '/control' ? 'control'
                   : pathname === REMOTE_PATH + '/evolution' ? 'evolution'
                   : pathname === REMOTE_PATH + '/resume-move' ? 'resume-move' : '';
@@ -529,6 +534,7 @@ function keepHandler(webServer, cwdForSession) {
           evolution: selectedEvolution,
           records,
           archived,
+          conflicts: conflictsOf(selectedScope),
           stats: {
             total: records.length,
             experimental: records.filter((record) => record.experimental).length,
@@ -540,6 +546,26 @@ function keepHandler(webServer, cwdForSession) {
       });
     }
 
+    /** 待裁决：用队列里留下的草稿另存，或删掉这条待办；不预写、不替用户合并。 */
+    if (action === 'conflict') {
+      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 projectScope = scopeOf(cwd);
+      const requested = typeof body.scopeKey === 'string' ? body.scopeKey : '';
+      const target = requested === 'global' ? globalScope() : projectScope;
+      const title = typeof body.title === 'string' ? body.title.trim() : '';
+      if (!title) return sendJson(res, 400, { ok: false, reason: '缺少标题' });
+      try {
+        const outcome = body.op === 'drop' ? { ok: dropConflict(target, title) } : resolveConflict(target, title);
+        if (!outcome.ok) return sendJson(res, 409, { ok: false, reason: outcome.reason || '这条待裁决还没处理成' });
+        return sendJson(res, 200, { ok: true, remaining: conflictsOf(target).length });
+      } catch (error) {
+        return sendJson(res, 409, { ok: false, reason: error instanceof Error ? error.message : '待裁决处理失败' });
+      }
+    }
+
     /**
      * 本项目记忆总开关：关闭后这层不再召回、检索、读写、学习，也不继承全局记忆。
      * 自进化设置原样保留，但有效状态随总开关暂停。
@@ -919,7 +945,39 @@ const FORGET_PARAMS = {
   additionalProperties: false,
 };
 
-/** 对外只认标题：id 留作内部地址，模型和界面都不用碰。 */
+/**
+ * 按标题解析内部身份。对外仍只显示标题，但解析必须能说明「唯一 / 同层歧义 / 不存在」：
+ * 同层同名是正常情况（不同前置条件各一条），静默取第一条会读错、写错。
+ */
+function titleHitsIn(target, title, { includeArchived = false } = {}) {
+  let index;
+  try { index = loadIndex(target); } catch { return []; }
+  const rows = includeArchived ? (index.archived || []) : (index.entries || []);
+  return rows.filter((entry) => entry && (includeArchived || entry.status !== 'archived')
+    && String(entry.title || '').trim() === title);
+}
+
+function candidateNote(entry) {
+  const conditions = Array.isArray(entry.conditions) ? entry.conditions.filter((row) => row && row.key) : [];
+  const parts = [];
+  if (entry.when) parts.push(String(entry.when));
+  if (conditions.length) parts.push(conditions.map((row) => `${row.key}=${row.value}`).join('·'));
+  return parts.join('，');
+}
+
+/** 同层同名时把候选条件一起报出来，模型/用户才能决定改哪条或先归档哪条。 */
+function ambiguousTitleError(title, hits, label) {
+  const detail = hits.slice(0, 4).map((entry) => {
+    const note = candidateNote(entry);
+    return note ? `「${title}」（${note}）` : `「${title}」`;
+  }).join('、');
+  return `${label}「${title}」有 ${hits.length} 条同名，无法确定是哪一条：${detail}。先归档其中一条，或换一个能区分的标题再试`;
+}
+
+/**
+ * 返回 { id } 或抛出：显式层只查那一层；默认先项目后全局（别的项目不参与解析）。
+ * 同一层出现多条同名一律报歧义，绝不取第一条。
+ */
 function refIdOf(scope, args, label = '记忆') {
   const id = typeof args.id === 'string' ? args.id.trim() : '';
   if (id) return id;
@@ -928,34 +986,30 @@ function refIdOf(scope, args, label = '记忆') {
   /** 显式指定层时只解析那一层：同名条目不会被顺手改掉，项目层也不会命中全局。 */
   const explicit = args && args.scope === 'global' ? globalScope() : args && args.scope === 'project' ? scope : null;
   const sources = explicit ? [explicit] : runtimeLayers(scope);
-  /** 运行时只解析当前项目与全局：别的项目正文不进本会话。 */
+  let crossLayerHit = null;
   for (const target of sources) {
-    let index;
-    try { index = loadIndex(target); } catch { continue; }
-    const hit = (index.entries || []).find((entry) => entry && entry.status !== 'archived'
-      && String(entry.title || '').trim() === title);
-    if (hit) return hit.id;
+    const hits = titleHitsIn(target, title);
+    if (hits.length > 1) throw new Error(ambiguousTitleError(title, hits, label));
+    if (hits.length === 1 && !crossLayerHit) crossLayerHit = hits[0];
   }
+  if (crossLayerHit) return crossLayerHit.id;
   /** 忘掉已归档的条目也要能按标题解析到；归档不会因此重新参与召回。 */
   for (const target of sources) {
-    let index;
-    try { index = loadIndex(target); } catch { continue; }
-    const hit = (index.archived || []).find((entry) => entry
-      && String(entry.title || '').trim() === title);
-    if (hit) return hit.id;
+    const hits = titleHitsIn(target, title, { includeArchived: true });
+    if (hits.length > 1) throw new Error(ambiguousTitleError(title, hits, label));
+    if (hits.length === 1) return hits[0].id;
   }
-  throw new Error(`没有「${title}」这条记忆；先用 memory_search 对一下标题`);
+  throw new Error(`没有「${title}」这条${label}；先用 memory_search 对一下标题`);
 }
 
 /** 同名条目可能分布在项目层和全局层：更新前先报候选，不能先匹配。 */
 function titleCandidates(scope, title) {
   const out = [];
   for (const target of runtimeLayers(scope)) {
-    let index;
-    try { index = loadIndex(target); } catch { continue; }
-    const hit = (index.entries || []).find((entry) => entry && entry.status !== 'archived'
-      && String(entry.title || '').trim() === title);
-    if (hit) out.push({ id: hit.id, scope: target.key === 'global' ? 'global' : 'project' });
+    const hits = titleHitsIn(target, title);
+    if (!hits.length) continue;
+    if (hits.length > 1) out.push({ ambiguous: true, title, hits, scope: target.key === 'global' ? 'global' : 'project' });
+    else out.push({ id: hits[0].id, scope: target.key === 'global' ? 'global' : 'project', note: candidateNote(hits[0]) });
   }
   return out;
 }
@@ -1073,6 +1127,8 @@ export function apply(ctx, config) {
   };
   /** 已准备好的快照只挂在 Agent 上，弱引用随手回收，不跨会话串。 */
   const prepared = new WeakMap();
+  /** 最近一次请求的任务身份：本轮没注入任何内容时 prepared 会清掉，补查仍需要知道上一轮任务。 */
+  const lastTask = new Map();
   /** turn-stopping 只回 signal，不带头 agent；这里记 signal → agent 供收尾清理。 */
   const signalAgents = new Map();
   const generations = new WeakMap();
@@ -1273,7 +1329,7 @@ export function apply(ctx, config) {
         win.recallHeader = true;
       }
       lines.push(line);
-      cards.push({ revision, scope: card.scope, title: card.title });
+      cards.push({ id: card.id, revision, scope: card.scope, title: card.title });
       /** 卡片行与到期时间一起留到最后输出：中间隔了系统提示组装，不能拿投影时的判断当现在。 */
       linesMeta.push({ line, validUntil: row.record.validUntil || '' });
     }
@@ -1318,8 +1374,9 @@ export function apply(ctx, config) {
           : waiting ? 'needs_context'
             : (gateRuntime && gateRuntime.enabled ? 'no_overlap' : 'needs_context');
     const matched = ranked.length || nearMatched;
-    if (!cards.length) return { text: '', cards: [], lines: [], bytes: 0, query, reason, matched };
-    return { text: finalText, cards, lines: linesMeta, bytes: Buffer.byteLength(finalText), query, reason, matched };
+    const ids = cards.map((card) => card.id).filter(Boolean);
+    if (!cards.length) return { text: '', cards: [], lines: [], ids, bytes: 0, query, reason, matched };
+    return { text: finalText, cards, lines: linesMeta, ids, bytes: Buffer.byteLength(finalText), query, reason, matched };
   }
 
   /* ---------------- 项目自进化：任务锚点、读取决策、上下文解析 ---------------- */
@@ -1491,21 +1548,31 @@ export function apply(ctx, config) {
     const unknown = [];
     const byTopic = new Map();
     let conflict = false;
+    const now = Date.now();
+    const query = held && held.query ? String(held.query) : '';
+    const runtime = { projectId: scope.key, experimental: true, context: context || {}, task: (held && held.task) || {} };
     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;
+      const score = query ? view.matchScore(record, query).score : 0;
+      /** 生命周期、归属、学习状态、适用条件统一走 eligibility：被取代、过期、暂停都不该从实验通道溜进来。 */
+      const usable = view.eligibility(record, runtime, 'auto', now);
+      if (!usable.ok) {
+        if (usable.status === 'needs_context' && usable.reason !== 'condition_mismatch'
+          && score >= view.MATCH_FLOOR) unknown.push(record);
+        continue;
+      }
+      /**
+       * 实验规则的任务条件本身就是相关度：栏目/阶段都对上，说明这条规则就属于当前这一集。
+       * 没有声明条件的规则仍要过词面门，避免一条宽泛规则在所有请求里都出现。
+       */
+      const conditions = Array.isArray(record.conditions) ? record.conditions.filter((row) => row && row.key) : [];
+      const bound = conditions.length > 0;
+      if (!bound && score < view.MATCH_FLOOR) continue;
       const topic = record.topicKey || record.id;
       if (byTopic.has(topic) && byTopic.get(topic).body !== record.body) conflict = true;
       byTopic.set(topic, record);
-      matched.push(record);
+      matched.push({ record, score: bound ? Math.max(score, view.MATCH_FLOOR) : score });
     }
     if (conflict) {
       return chargeExperiment(win, '这些实验规则互相冲突，先按用户这次说的做，别叠加对立的规则。');
@@ -1520,15 +1587,10 @@ export function apply(ctx, config) {
       ? Math.max(0, view.CARD.bytes - Buffer.byteLength(auto.normalText || '') - 2)
       : EXPERIMENT_BYTES;
     let used = Buffer.byteLength(EXPERIMENT_RULES_HEADER) + 1;
-    /** 实验规则也要过本轮相关度：和当前问题没有交集就不占卡片，不能“来自自进化”就天然优先。 */
-    const query = held && held.query ? String(held.query) : '';
-    const relevant = query
-      ? matched.map((record) => ({ record, score: view.matchScore(record, query).score }))
-        /** 条件明确且已满足的规则按绑定注入；无条件的全项目规则必须和本轮问题有交集。 */
-        .filter((row) => row.score > 0 || (Array.isArray(row.record.conditions) && row.record.conditions.length > 0))
-        .sort((a, b) => b.score - a.score)
-        .map((row) => row.record)
-      : matched;
+    const relevant = matched
+      .slice()
+      .sort((a, b) => b.score - a.score)
+      .map((row) => row.record);
     for (const record of relevant.slice(0, cardCap)) {
       const body = String(record.body || '');
       const short = body && body.length <= EXPERIMENT_SHORT_CHARS && body.split('\n').length <= 4;
@@ -1649,6 +1711,7 @@ export function apply(ctx, config) {
       projectKey: scope.key, sessionId, batchKey, messageIds, query,
       context, task, anchor: routed.anchor, ranges, decision, epoch,
       experimental: enabled,
+      episodeId: (episode && episode.episodeId) || (routed.anchor && routed.anchor.episodeId) || '',
       episodeUpdatedAt: episode ? episode.updatedAt : '', injectedIds: [],
       at: Date.now(),
     };
@@ -1889,6 +1952,7 @@ export function apply(ctx, config) {
           archived: { type: 'string' },
           pendingConflicts: { type: 'integer' },
           error: { type: 'string' },
+          offCopy: { type: 'string' },
         },
         required: ['title', 'summary', 'when', 'revision', 'merged', 'changed', 'scope', 'needsResolution', 'archived'],
         additionalProperties: false,
@@ -1899,7 +1963,7 @@ export function apply(ctx, config) {
           ? `memory · ${value.error}`
           : value.needsScope
           ? value.reason === 'memory_disabled'
-            ? `memory · ${memoryOffCopy(projectScope)}`
+            ? `memory · ${value.offCopy || '本项目记忆已关闭，先在面板打开'}`
             : value.reason === 'unconfirmed_project'
             ? `memory · 当前目录还不能确认属于哪个项目：「${value.title}」\n先确认项目根目录，或显式 scope="global"`
             : `memory · 归属还没定：「${value.title}」\n补 memoryClass（personal_preference / project_fact / environment_fact / portable_procedure）或显式 scope；设备事实还要给设备条件`
@@ -1919,7 +1983,7 @@ export function apply(ctx, config) {
         return {
           title: String(args.title || ''), summary: '', when: '', revision: 0,
           merged: false, changed: false, scope: '', needsScope: true, reason: 'memory_disabled',
-          needsResolution: false, similarTitles: '', similar: '', archived: '',
+          needsResolution: false, similarTitles: '', similar: '', archived: '', offCopy: memoryOffCopy(projectScope),
         };
       }
       const supersedes = String(args.supersedes || '').trim();
@@ -1932,13 +1996,17 @@ export function apply(ctx, config) {
       /** 更新句柄也用标题：id 只是底层实现，模型抄标题就行。 */
       const updateTitle = String(args.updateTitle || '').trim();
       if (updateTitle) {
-        const candidates = args.scope ? [] : titleCandidates(projectScope, updateTitle);
-        if (candidates.length > 1) {
+        const candidates = titleCandidates(projectScope, updateTitle);
+        const ambiguous = candidates.find((row) => row.ambiguous);
+        /** 同层同名是允许的（不同前置条件各一条），但不能替用户挑第一条改。 */
+        if (ambiguous) return saveFailure(ambiguousTitleError(updateTitle, ambiguous.hits, '记忆'), args);
+        if (!args.scope && candidates.length > 1) {
           return saveFailure(`「${updateTitle}」在项目层和全局层各有一条：改全局加 scope="global"，改项目加 scope="project"`, args);
         }
-        const updateId = (() => { try { return refIdOf(projectScope, { title: updateTitle, scope: args.scope }, '记忆'); } catch { return ''; } })();
-        if (!updateId) return saveFailure(`没有「${updateTitle}」这条记忆；要新增就不用 updateTitle`, args);
-        draft.id = updateId;
+        const layer = args.scope === 'global' ? 'global' : args.scope === 'project' ? 'project' : '';
+        const picked = layer ? candidates.find((row) => row.scope === layer) : candidates[0];
+        if (!picked) return saveFailure(`没有「${updateTitle}」这条记忆；要新增就不用 updateTitle`, args);
+        draft.id = picked.id;
       }
       /** 关联目标同样按标题解析成内部 id 再落盘。 */
       if (Array.isArray(args.links) && args.links.length) {
@@ -1946,8 +2014,10 @@ export function apply(ctx, config) {
         for (const link of args.links) {
           const title = typeof link?.title === 'string' ? link.title.trim() : '';
           if (!title) return saveFailure('关联要写成 {type, title}：给被关联那条记忆的标题', args);
-          const targetId = (() => { try { return refIdOf(projectScope, { title }, '记忆'); } catch { return ''; } })();
-          if (!targetId) return saveFailure(`没有「${title}」这条记忆，关联没写成`, args);
+          let targetId = '';
+          try { targetId = refIdOf(projectScope, { title }, '记忆'); } catch (error) {
+            return saveFailure(String(error && error.message ? error.message : `没有「${title}」这条记忆`), args);
+          }
           resolved.push({ type: link.type || 'related', id: targetId });
         }
         draft.links = resolved;
@@ -2162,6 +2232,8 @@ export function apply(ctx, config) {
         context,
         history: args.history === true,
         allowExperimental: resolved.experimental === true,
+        /** 「用过」要等真正给了模型看再记：检索到的前 50 条不是交付。 */
+        markUsed: false,
       }).filter((item) => !item.ownerProjectId || item.ownerProjectId === scope.key)
         .filter((item) => item.archived || view.eligibility(item, gateRuntime, 'search').ok);
       const hits = rawHits.filter((item) => item.archived || item.status === 'ok').slice(0, limit);
@@ -2219,10 +2291,12 @@ export function apply(ctx, config) {
         win.toolBytes += jsonBytes(value);
         win.reads += 1;
         recordCitations(scope, sessionIdOf(execution), hits.slice(0, kept));
+        markUsed(scope, hits.slice(0, kept).map((item) => item.id));
         return value;
       }
       const value = valueOf(shown.length);
       recordCitations(scope, sessionIdOf(execution), hits);
+      markUsed(scope, hits.map((item) => item.id));
       return value;
     },
   }), 'lite-memory: memory_search');
@@ -2554,7 +2628,7 @@ export function apply(ctx, config) {
         .filter((message) => message?.source?.kind === 'user');
       const fresh = freshHumans(sessionId, humans);
       const previous = prepared.get(agent);
-      const sameSession = previous && previous.sessionId === sessionId;
+      const sameSession = Boolean(previous && previous.sessionId === sessionId);
 
       if (fresh.length === 0) {
         /** 工具续步：内容冻结，只把快照绑到本步的 signal；盘上版本变了才重投影。 */
@@ -2651,7 +2725,6 @@ export function apply(ctx, config) {
       /** 任务上下文独立于自进化开关：普通记忆按当前任务判适用，实验规则再叠一层可用性。 */
       const auto = emptyAutoBudget();
       if (win) win.autoBudget = auto;
-      const experiment = runtime ? experimentFor(scope, runtime, win) : null;
       const recalledContext = runtime ? runtime.held.context : context;
       const remembered = runtime && runtime.enabled
         ? rememberFeedback(scope, sessionId, fresh, runtime.held, turn)
@@ -2661,7 +2734,16 @@ export function apply(ctx, config) {
        * 预防型记忆约束的是「下一步动作」，词面常写在上一轮助手的话和工具调用里，用户这句话反而没提。
        * 第一次检索一张卡都没有时，用最近的实词/工具名补一次有界查询，预算仍是同一份。
        */
-      if (!snapshot.cards.length && !carried) {
+      const currentTask = {
+        kind: (runtime && runtime.held && runtime.held.task && runtime.held.task.kind) || '',
+        episodeId: (runtime && runtime.held && runtime.held.episodeId) || '',
+      };
+      const rememberedTask = lastTask.get(sessionId) || null;
+      const previousTask = previous && previous.task ? previous.task : rememberedTask;
+      const sameTask = Boolean(sameSession || rememberedTask) && view.sameRecallTask(previousTask, currentTask);
+      lastTask.set(sessionId, currentTask);
+      while (lastTask.size > 64) lastTask.delete(lastTask.keys().next().value);
+      if (!snapshot.cards.length && !carried && sameTask) {
         const humanTail = (() => {
           const messages = Array.isArray(decision.messages) ? decision.messages : [];
           for (let i = messages.length - 1; i >= 0; i -= 1) {
@@ -2680,6 +2762,8 @@ export function apply(ctx, config) {
           }
         }
       }
+      /** 实验规则最后才取预算：普通卡片先占，弱相关实验不能把强相关项目规则挤出去。 */
+      const experiment = runtime ? experimentFor(scope, runtime, win) : null;
       noteRecall(scope, sessionId, {
         reason: snapshot.reason, matched: snapshot.matched, cards: snapshot.cards.length, chars: snapshot.bytes,
       });
@@ -2729,6 +2813,7 @@ export function apply(ctx, config) {
         cards: snapshot ? snapshot.cards : [],
         lines: snapshot ? snapshot.lines : [],
         matched: snapshot ? snapshot.matched : 0,
+        task: currentTask,
         scope,
         query,
         sessionId,
@@ -2740,6 +2825,7 @@ export function apply(ctx, config) {
         at: Date.now(),
       };
       prepared.set(agent, state);
+      if (snapshot && snapshot.ids && snapshot.ids.length) markUsed(scope, snapshot.ids);
       payloadBytes.set(sessionId, win.bytes);
       while (payloadBytes.size > 64) payloadBytes.delete(payloadBytes.keys().next().value);
       if (signal) signalAgents.set(signal, agent);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-lite-memory",
-  "version": "0.18.27",
+  "version": "0.18.29",
   "description": "On-demand memory for the DeepSeek Harness: nothing resident, at most three small cards on a real hit, bodies read on demand.",
   "type": "module",
   "main": "index.js",

package/state.js

@@ -143,8 +143,8 @@ export function applyControl(draft, enabled, mode) {
     evolution.changedAt = now;
     /** 默认绑定属于已确认结果；临时锚点和在途观察不属于。 */
     evolution.tasks = { ...emptyTasks(), ...(evolution.tasks && evolution.tasks.defaults ? { defaults: evolution.tasks.defaults } : {}) };
-    /** 额度只增不减：次数与回执留着，最近观察清掉。 */
-    evolution.learning = { ...ledger, recent: [] };
+    /** 额度只增不减：次数、回执和滚动时间戳都留着，关开不能把项目额度洗掉。 */
+    evolution.learning = ledger;
   }
   return { changed: true, enabled: next, mode: nextMode, epoch: config.epoch };
 }
@@ -190,8 +190,11 @@ export function applyEvolution(draft, enabled) {
     changedAt: now,
     /** 开与关都让上一轮锚点失效；已经确认的项目默认保留，它不属于临时作品状态。 */
     tasks: { ...emptyTasks(), ...(current.tasks && current.tasks.defaults ? { defaults: current.tasks.defaults } : {}) },
-    /** 只清在途观察；已学规则的来源、版本和候选都在条目里，关开不动它们。 */
-    learning: { ...normalizeLearning(current.learning), recent: [] },
+    /** 只清在途候选与回执；额度账本 recent 是滚动时间戳，开关/重启都得留着。 */
+    learning: {
+      ...normalizeLearning(current.learning),
+      recent: (Array.isArray(current.learning && current.learning.recent) ? current.learning.recent : []).slice(-32),
+    },
   };
   draft.experimental = { ...(draft.experimental || {}), projectEvolution: config };
   /** 显式关闭自进化：试用转暂停待复核，不删除候选与证据；重新打开后可逐条恢复。 */

package/store.js

@@ -1587,13 +1587,24 @@ export function search(scope, query, limit = 4, options = {}) {
       archived: Boolean(row.archived),
     }));
   });
-  /** 锁外回写：在层锁里再抢同一层的锁会死锁。 */
-  for (const row of found) {
-    if (!row.archived) touchUsed(row.source, [row.record.id]);
+  /** 锁外回写：在层锁里再抢同一层的锁会死锁；只给真正会交付给调用方的检索默认记账。 */
+  if (options.markUsed !== false) {
+    for (const row of found) {
+      if (!row.archived) touchUsed(row.source, [row.record.id]);
+    }
   }
   return found.map((row) => row.record);
 }
 
+/** 交付后再记账：调用方只把最终真给模型看过的条目交回来。 */
+export function markUsed(scope, ids) {
+  const wanted = (Array.isArray(ids) ? ids : []).filter((id) => typeof id === 'string' && id);
+  if (!wanted.length) return;
+  for (const source of [scope, globalScope()]) {
+    try { touchUsed(source, wanted); } catch { /* lastUsed 只是提示 */ }
+  }
+}
+
 /**
  * 只读命中：给自动提示用。不改 hits / lastUsed，不落盘。
  * 标题（含旧标题）必须真跟查询有交集，否则长句里零星重合也会冒出提示。
@@ -2511,11 +2522,27 @@ const MACHINE_BOUND_PATTERNS = [
   /\b\d{1,3}(?:\.\d{1,3}){3}:\d{2,5}\b/,
 ];
 
-function machineBoundText(source) {
-  const text = [source?.title, source?.summary, source?.when, source?.body, source?.topicKey]
+function contentText(source) {
+  return [source?.title, source?.summary, source?.when, source?.body, source?.topicKey]
     .filter((value) => typeof value === 'string' && value)
     .join('\n');
-  return MACHINE_BOUND_PATTERNS.some((re) => re.test(text));
+}
+
+function machineBoundText(source) {
+  return MACHINE_BOUND_PATTERNS.some((re) => re.test(contentText(source)));
+}
+
+/** 内容自己说了「本项目 / 这个仓库」：模型给的类别标签不能把它抬到全局层。 */
+const PROJECT_BOUND_PATTERNS = [
+  /本项目|这个项目|当前项目|该项目/,
+  /本仓库|这个仓库|当前仓库/,
+  /本工程|这个工程|当前工程/,
+  /本目录|当前目录/,
+  /本项目里|我们项目/,
+];
+
+function projectBoundText(source) {
+  return PROJECT_BOUND_PATTERNS.some((re) => re.test(contentText(source)));
 }
 
 /**
@@ -2556,6 +2583,8 @@ export function routeScope(draft, options = {}) {
   };
   /** 人明确点过「就存全局」才算数；模型自己提的 global 不抵消本机痕迹。 */
   const humanConfirmed = options.humanScope === true || source.scopeConfirmed === true;
+  /** 「本项目里…」是项目事实的措辞，类别写成偏好/流程也不能这样进通用层。 */
+  const projectBound = projectBoundText(source);
   if (durability === 'task') return { ...base, needsScope: true, reasonCode: 'task_state' };
   if (explicit) {
     /**
@@ -2566,6 +2595,7 @@ export function routeScope(draft, options = {}) {
     if (explicit === 'global' && !humanConfirmed) {
       if (machineConflict) return fallbackToProject('machine_bound_scope');
       if (cls === 'project_fact') return fallbackToProject('model_global_project_fact');
+      if (projectBound) return fallbackToProject('project_bound_scope');
     }
     if (explicit === 'project' && !projectReady) {
       const reasonCode = options.project && options.project.confirmed === false ? 'unconfirmed_project' : 'no_project';
@@ -2590,16 +2620,20 @@ export function routeScope(draft, options = {}) {
   if (cls === 'personal_preference') {
     /** 偏好也分「我的习惯」和「这台机器上的习惯」：后者绑机器，不进通用层。 */
     if (machineConflict) return fallbackToProject('machine_bound_preference');
+    /** 说了「本项目」的偏好其实是项目约定，类别写错也不能跨项目。 */
+    if (projectBound) return fallbackToProject('project_bound_preference');
     return { ...base, chosenScope: 'global', reasonCode: 'class_personal_preference' };
   }
   if (cls === 'portable_procedure') {
     if (machineConflict) return fallbackToProject('machine_bound_procedure');
+    if (projectBound) return fallbackToProject('project_bound_procedure');
     /** 带适用环境条件的本机流程：条件成立时才用，换台机器自然不生效。 */
     if (envScoped) return { ...base, chosenScope: 'global', reasonCode: 'machine_scoped_procedure' };
     /** 说能搬去别的项目，就要有能搬的依据；没有就先留在本项目。 */
     if (!evidence) return fallbackToProject('unbound_evidence');
     return { ...base, chosenScope: 'global', reasonCode: 'class_portable_procedure' };
   }
+  if (projectBound) return fallbackToProject('project_bound_environment');
   const conditions = view.normalizeConditions(source.conditions) || [];
   const scoped = conditions.some((item) => ENVIRONMENT_KEYS.includes(item.key));
   if (!scoped) {
@@ -2689,6 +2723,29 @@ function bindSameTopic(projectScope, ref) {
 /** 冲突队列：只记待办，不预写记忆；最多 20 条。 */
 const CONFLICT_LIMIT = 20;
 
+/** 待办里留一份可重放的草稿：面板能直接另存，不用用户回忆刚才想记什么。 */
+const CONFLICT_DRAFT_KEYS = ['title', 'summary', 'body', 'when', 'kind', 'tags', 'conditions', 'applicability', 'topicKey', 'source', 'origin'];
+function conflictDraftOf(draft) {
+  const out = {};
+  if (!draft || typeof draft !== 'object') return out;
+  for (const key of CONFLICT_DRAFT_KEYS) {
+    const value = draft[key];
+    if (value === undefined || value === null) continue;
+    if (key === 'title') out.title = normalizeText(value, 120);
+    else if (key === 'summary') out.summary = normalizeText(value, 400);
+    else if (key === 'body') out.body = typeof value === 'string' ? value.slice(0, 8000) : '';
+    else if (key === 'when') out.when = normalizeText(value, 160);
+    else if (key === 'kind') { if (KINDS.includes(value)) out.kind = value; }
+    else if (key === 'tags') out.tags = Array.isArray(value) ? value.slice(0, 5) : undefined;
+    else if (key === 'conditions') out.conditions = Array.isArray(value) ? value.slice(0, 8) : undefined;
+    else if (key === 'applicability') out.applicability = value;
+    else if (key === 'topicKey') out.topicKey = normalizeText(value, 80);
+    else if (key === 'source') out.source = value;
+    else if (key === 'origin') out.origin = value;
+  }
+  return out;
+}
+
 function queueConflictLocked(scope, draft, candidates) {
   const index = loadIndex(scope);
   const title = normalizeText(draft && draft.title, 120);
@@ -2700,11 +2757,13 @@ function queueConflictLocked(scope, draft, candidates) {
     id: item.id, title: item.title || '', when: item.when || '', reason: item.reason || 'similar_title',
   }));
   const hit = rows.find((row) => row.title === title && row.scope === scopeKey);
+  const replay = conflictDraftOf(draft);
   if (hit) {
     hit.candidates = view;
+    hit.draft = replay;
     hit.updatedAt = now;
   } else {
-    rows.push({ id: `cf_${crypto.randomUUID().replace(/-/g, '').slice(0, 12)}`, title, scope: scopeKey, candidates: view, createdAt: now, updatedAt: now });
+    rows.push({ id: `cf_${crypto.randomUUID().replace(/-/g, '').slice(0, 12)}`, title, scope: scopeKey, candidates: view, draft: replay, createdAt: now, updatedAt: now });
   }
   index.conflicts = rows.slice(-CONFLICT_LIMIT);
   saveIndex(scope, index);
@@ -2722,6 +2781,36 @@ function clearConflictLocked(scope, title) {
   return next.length;
 }
 
+/** 面板待裁决列表：只给可重放草稿与候选，不预写记忆。 */
+export function conflictsOf(scope) {
+  const rows = loadIndex(scope).conflicts;
+  return Array.isArray(rows) ? JSON.parse(JSON.stringify(rows)) : [];
+}
+
+/** 确认另存：用队列里的草稿按 distinct 重放一次，成功后出队。 */
+export function resolveConflict(scope, title, options = {}) {
+  const rows = Array.isArray(loadIndex(scope).conflicts) ? loadIndex(scope).conflicts : [];
+  const norm = normalizeText(title, 120);
+  const row = rows.find((item) => item.title === norm && item.scope === (scope.key === 'global' ? 'global' : 'project'));
+  if (!row) return { ok: false, reason: '这条待裁决已经不在了，刷新面板看看' };
+  const draft = { ...(row.draft || {}), resolution: 'distinct', writeMode: options.writeMode === 'append' ? 'append' : 'patch' };
+  if (scope.key === 'global') draft.scope = 'global';
+  else draft.scope = 'project';
+  if (!draft.title) draft.title = row.title;
+  const result = saveEntry(scope, draft);
+  if (result.needsResolution) return { ok: false, reason: '还是相近：换一个标题或等确认', result };
+  if (result.needsScope) return { ok: false, reason: '这条记忆的适用范围还没定，先说明当前环境', result };
+  clearConflictLocked(scope, row.title);
+  return { ok: true, result };
+}
+
+/** 删掉待裁决：用户决定不再另存。 */
+export function dropConflict(scope, title) {
+  const before = pendingConflictsOf(scope);
+  clearConflictLocked(scope, title);
+  return pendingConflictsOf(scope) < before;
+}
+
 /** 当前层还有几条没处理的冲突。 */
 export function pendingConflictsOf(scope) {
   const rows = loadIndex(scope).conflicts;

package/test/contract.test.mjs

@@ -190,6 +190,23 @@ const hitText = render('memory_search', {}, hits);
 assert.match(hitText, new RegExp(`^memory · 命中 ${hits.count} 条 · 引用 ${hits.chars} 字\\n- \\[[^\\]]+\\] 「`));
 assert.doesNotMatch(hitText, /mem_[a-z0-9]{6,}/, '检索结果只给标题与适用范围');
 assert.doesNotMatch(hitText, /第 .* 版/);
+/** 用量只在真交付后才记：检索候选（尤其被预算/上限丢掉的那些）不算用过。 */
+const contractScope = store.scopeOf(cwd);
+await exec('memory_save', { title: '用量记账探针', summary: '只在交付后记 lastUsed', kind: 'note' });
+const usedRow = () => store.loadIndex(contractScope).entries.find((item) => item.title === '用量记账探针');
+const oldUse = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
+const probeId = usedRow().id;
+state.transact(contractScope, {}, (draft) => {
+  const row = draft.entries.find((item) => item.id === probeId);
+  row.maintenance.lastUsed = oldUse;
+  return { changed: true };
+});
+assert.equal(usedRow().lastUsed, oldUse);
+const silent = store.search(contractScope, '用量记账探针', 50, { markUsed: false });
+assert.ok(silent.length >= 1);
+assert.equal(usedRow().lastUsed, oldUse, '候选检索不记 usage');
+await exec('memory_search', { query: '用量记账探针' });
+assert.notEqual(usedRow().lastUsed, oldUse, '真交付给模型后才记 usage');
 /** 「发版当天」这类自由文本条件没有可信上下文，不能当成适用条目塞给模型。 */
 const miss = await exec('memory_search', { query: '完全没有出现过的主题' });
 assert.equal(miss.count, 0);
@@ -254,6 +271,41 @@ assert.ok(ambiguousSave.error, '跨层同名要报改哪一层');
 assertSchema('memory_save', ambiguousSave);
 assert.match(render('memory_save', {}, ambiguousSave), /^memory · /);
 assert.doesNotMatch(render('memory_save', {}, ambiguousSave), /undefined|saved|merged/);
+/** 同层同名不是「取第一条」：读、忘、更新都必须报歧义，按 id 仍能精确到条。 */
+const twinScope = store.scopeOf(cwd);
+const twinA = store.saveEntry(twinScope, { title: '同层重名探针', summary: '第一条', body: '正文甲', when: '机器甲', writeMode: 'patch' });
+const twinB = store.saveEntry(twinScope, { title: '同层重名探针', summary: '第二条', body: '正文乙', when: '机器乙', writeMode: 'patch' });
+const twinAId = twinA.record?.id ?? twinA.id;
+const twinBId = twinB.record?.id ?? twinB.id;
+assert.notEqual(twinAId, twinBId);
+await assert.rejects(() => exec('memory_read', { title: '同层重名探针' }), /有 2 条同名/);
+await assert.rejects(() => exec('memory_forget', { title: '同层重名探针', mode: 'archive' }), /有 2 条同名/);
+const twinUpdate = await exec('memory_save', { title: '换个标题', summary: '尝试更新同名条目', updateTitle: '同层重名探针' });
+assert.ok(twinUpdate.error, '同层同名更新要报歧义');
+assert.match(twinUpdate.error, /有 2 条同名/);
+assertSchema('memory_save', twinUpdate);
+assert.equal(store.readEntry(twinScope, twinAId).body, '正文甲', '按 id 读不能被同名条目串走');
+assert.equal(store.readEntry(twinScope, twinBId).body, '正文乙');
+
+/** 重命名后仍按原 id 定位到同一条；归档后重建同名条目也不能冒领旧 id。 */
+const renameSaved = store.saveEntry(twinScope, { title: '改名前的探针', summary: '旧身份', body: '旧正文', writeMode: 'patch' });
+const renameSeedId = renameSaved.record?.id ?? renameSaved.id;
+const renamed = await exec('memory_save', { title: '改名后的探针', summary: '旧身份', updateTitle: '改名前的探针' });
+assert.equal(renamed.changed, true);
+assert.equal(store.locateByTitle(twinScope, '改名后的探针').record.id, renameSeedId, '改名必须落在同一条记录上');
+const oldIdRead = store.readEntry(twinScope, renameSeedId);
+assert.equal(oldIdRead.title, '改名后的探针');
+assert.equal(oldIdRead.body, '旧正文');
+await exec('memory_forget', { id: renameSeedId, mode: 'archive' });
+const recreated = await exec('memory_save', { title: '改名后的探针', summary: '新身份', body: '新正文' });
+const recreatedId = store.locateByTitle(twinScope, '改名后的探针').record.id;
+assert.notEqual(recreatedId, renameSeedId, '删掉再建是新的身份');
+const staleRead = await exec('memory_read', { id: renameSeedId });
+assert.equal(staleRead.status, 'archived', '旧 id 只能读到旧条目的归档状态');
+assert.equal(staleRead.body, '');
+const freshRead = await exec('memory_read', { id: recreatedId });
+assert.equal(freshRead.body, '新正文');
+
 const missingSave = await exec('memory_save', { title: '别的标题', summary: '没有这条', updateTitle: '根本不存在的条目' });
 assert.ok(missingSave.error);
 assertSchema('memory_save', missingSave);
@@ -672,6 +724,8 @@ assert.equal(closedTool.changed, false);
 assert.equal(closedTool.reason, 'memory_disabled');
 assertSchema('memory_save', closedTool);
 assert.equal(closedTool.id, undefined);
+/** 关闭态的保存回执也要能渲染：不能等用户真去写一条才报 ReferenceError。 */
+assert.match(render('memory_save', {}, closedTool), /^memory · 本项目记忆已关闭/);
 /** 关闭状态下的读取也只报状态，不返回正文。 */
 const closedRead = await defs.get('memory_read').execute({ title: closedSeed.title }, { agent: closedAgent });
 assert.equal(closedRead.status, 'memory_disabled');
@@ -1156,4 +1210,26 @@ assert.equal(ovArchivedBody.status, 200);
 assert.equal(ovArchivedBody.body.status, 'archived');
 assert.equal(ovArchivedBody.body.body, '右侧留白。');
 
+// 待裁决：面板看得到队列，确认后按草稿另存，不预写正文
+const cfCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-contract-conflict-'));
+sessionCwds.set('session-conflict-panel', cfCwd);
+const cfAgent = { id: 'session-conflict-panel', cwd: cfCwd, session: { id: 'session-conflict-panel', header: { cwd: cfCwd } } };
+await defs.get('memory_save').execute({ title: '发布窗口', summary: '只在周四晚上发版', body: '周四晚上再发版。', scope: 'global' }, { agent: cfAgent });
+const cfSave = await defs.get('memory_save').execute({ title: '发布窗口', summary: '本项目周五发版', body: '周五发版。' }, { agent: cfAgent });
+assert.equal(cfSave.needsResolution, true);
+assert.equal(store.loadIndex(store.scopeOf(cfCwd)).entries.length, 0, '没确认前不落库');
+const cfBefore = await call('/lite-memory/overview', { sessionId: 'session-conflict-panel' });
+assert.equal(cfBefore.status, 200);
+assert.equal(cfBefore.body.selected.conflicts.length, 1);
+assert.equal(cfBefore.body.selected.conflicts[0].title, '发布窗口');
+assert.equal(cfBefore.body.selected.conflicts[0].draft.body, '周五发版。');
+const cfKeep = await call('/lite-memory/conflict', { sessionId: 'session-conflict-panel', scopeKey: cfBefore.body.selected.key, title: '发布窗口', op: 'keep' });
+assert.equal(cfKeep.status, 200);
+assert.equal(cfKeep.body.ok, true);
+const cfAfter = await call('/lite-memory/overview', { sessionId: 'session-conflict-panel' });
+assert.equal(cfAfter.body.selected.conflicts.length, 0);
+assert.ok(cfAfter.body.selected.records.some((row) => row.title === '发布窗口' && row.summary === '本项目周五发版'));
+const cfAgain = await call('/lite-memory/conflict', { sessionId: 'session-conflict-panel', scopeKey: cfBefore.body.selected.key, title: '发布窗口', op: 'keep' });
+assert.equal(cfAgain.status, 409, '队列没了就明确说，不重复落库');
+
 console.log('contract.test.mjs: all passed');

package/test/control.test.mjs

@@ -288,8 +288,11 @@ const toggle = (scope, enabled) => store.setMemoryEnabled(scope, enabled, { oper
   assert.equal(store.beginLearningAttempt(scope, { episodeId: 'ep-preserve', operationId: 'a1' }).ok, true);
   assert.equal(store.beginLearningAttempt(scope, { episodeId: 'ep-preserve', operationId: 'a2' }).ok, true);
   assert.equal(store.beginLearningAttempt(scope, { episodeId: 'ep-preserve', operationId: 'a3' }).ok, false);
+  const ledgerBefore = store.loadIndex(scope).__evolution.learning.recent.length;
+  assert.ok(ledgerBefore >= 2, '先有滚动额度记录');
   toggle(scope, false);
   toggle(scope, true);
+  assert.ok(store.loadIndex(scope).__evolution.learning.recent.length >= ledgerBefore, '关开不重置滚动额度账本');
   assert.deepEqual(store.taskState(scope).defaults, { ...defaults, confirmedBy: 'user', confirmedAt: '' });
   assert.equal(store.setEvolution(scope, true, { operationId: 'evo-quota-again' }).ok, true);
   const limited = store.beginLearningAttempt(scope, { episodeId: 'ep-preserve', operationId: 'a4' });

package/test/crossing.test.mjs

@@ -11,6 +11,7 @@ const view = await import('../view.js');
 const {
   saveEntry, routeScope, visibleRules, move, resumeMove, movePending,
   upsert, forget, readLinks, loadIndex, scopeOf, globalScope, readEntry, pendingConflictsOf,
+  conflictsOf, resolveConflict, dropConflict,
 } = store;
 
 let passed = 0;
@@ -59,6 +60,34 @@ await test('S03 项目事实留在项目层', () => {
   assert.equal(idsOf(scope).length, 1);
 });
 
+await test('S03 模型给的类别标签不能把「本项目」抬进全局层', () => {
+  const scope = fresh('route-project-bound');
+  const pref = saveEntry(scope, {
+    title: '本项目回复用中文',
+    summary: '这个项目里回复用中文',
+    body: '本项目统一中文、简短',
+    memoryClass: 'personal_preference',
+  });
+  assert.equal(pref.chosenScope, 'project');
+  assert.equal(pref.reasonCode, 'project_bound_preference');
+  assert.equal(stateOf(globalScope()).entries.filter((row) => row.current.title === '本项目回复用中文').length, 0);
+  const proc = saveEntry(scope, {
+    title: '本项目构建',
+    summary: '这个仓库构建用 pnpm',
+    body: '本仓库统一 pnpm build',
+    memoryClass: 'portable_procedure',
+    evidenceRef: 'README',
+  });
+  assert.equal(proc.chosenScope, 'project');
+  assert.equal(proc.reasonCode, 'project_bound_procedure');
+  /** 人自己确认「就存全局」时，措辞推断不能压过明确指令。 */
+  const human = routeScope({
+    title: '本项目回复用中文', body: '本项目统一中文、简短', memoryClass: 'personal_preference', scope: 'global',
+  }, { humanScope: true, project: { confirmed: true } });
+  assert.equal(human.chosenScope, 'global');
+  assert.equal(human.reasonCode, 'explicit');
+});
+
 await test('S03 设备事实没给设备条件就返回 needsScope，不落盘', () => {
   const scope = fresh('route-env');
   const saved = saveEntry(scope, { title: '本机 Node', summary: '本机 Node 版本', body: 'v24', memoryClass: 'environment_fact' });
@@ -390,4 +419,22 @@ await test('S12 相近保存进待办队列，确认 distinct 后出队', () =>
   assert.equal(pendingConflictsOf(scope), 0);
 });
 
+await test('S12 待裁决留可重放草稿，面板确认另存后才落库', () => {
+  const scope = fresh('conflict-replay');
+  saveEntry(globalScope(), { title: '提交信息格式', summary: '用一句话说清做了什么', body: '全局约定', resolution: 'distinct' });
+  const near = saveEntry(scope, { title: '提交信息格式', summary: '本项目用中文写提交信息', body: '项目补充', when: '本仓库' });
+  assert.equal(near.needsResolution, true);
+  assert.equal(loadIndex(scope).entries.length, 0, '没确认前不能预写正文');
+  const [row] = conflictsOf(scope);
+  assert.equal(row.title, '提交信息格式');
+  assert.equal(row.draft.body, '项目补充');
+  assert.equal(row.draft.when, '本仓库');
+  const kept = resolveConflict(scope, '提交信息格式');
+  assert.equal(kept.ok, true);
+  assert.equal(pendingConflictsOf(scope), 0);
+  assert.equal(loadIndex(scope).entries.length, 1);
+  assert.equal(loadIndex(scope).entries[0].body, '项目补充');
+  assert.equal(dropConflict(scope, '不存在'), false);
+});
+
 console.log(`crossing.test.mjs: ${passed} passed`);

package/test/evolution-read.test.mjs

@@ -601,3 +601,39 @@ const scopeOf = (dir) => store.scopeOf(dir);
 }
 
 console.log('evolution-read.test.mjs: all passed');
+
+/* L23：被取代 / 已过期的实验规则不再从实验通道注入正文。 */
+{
+  const dir = mkdir('lifecycle');
+  const scope = scopeOf(dir);
+  const superseded = seedRule(scope, { title: '旧开场规则', body: '旧规则正文：开场先自我介绍。', conditions: [{ key: 'seriesId', value: '口播' }] });
+  const expired = seedRule(scope, { title: '过期规则', body: '过期规则正文：开场念固定slogan。', conditions: [{ key: 'seriesId', value: '口播' }] });
+  enable(scope, { seriesId: '口播' });
+  state.transact(scope, {}, (draft) => {
+    const first = draft.entries.find((entry) => entry.id === superseded);
+    first.supersededBy = 'mem_deadbeef';
+    const second = draft.entries.find((entry) => entry.id === expired);
+    second.validUntil = new Date(Date.now() - 60_000).toISOString();
+    return { changed: true };
+  });
+  const runtime = boot();
+  const agent = makeAgent('a-lifecycle', dir);
+  const sig = signal();
+  await runtime.preStep({ agent, signal: sig, turn: 't1' }, enter(human('这期口播开场怎么改')));
+  const text = runtime.text(agent, sig);
+  assert.equal(text.includes('旧规则正文'), false, '被取代的规则不能注入');
+  assert.equal(text.includes('过期规则正文'), false, '过期规则不能注入');
+}
+
+/* L24：没有声明条件的实验规则，问题不相关时也不靠「有规则」硬注入。 */
+{
+  const dir = mkdir('unbound');
+  const scope = scopeOf(dir);
+  seedRule(scope, { title: '导出参数', body: '导出统一用 H.264。', conditions: [] });
+  enable(scope, { seriesId: '口播' });
+  const runtime = boot();
+  const agent = makeAgent('a-unbound', dir);
+  const sig = signal();
+  await runtime.preStep({ agent, signal: sig, turn: 't1' }, enter(human('这期封面标题怎么写')));
+  assert.equal(runtime.text(agent, sig).includes('导出统一用 H.264'), false, '无关问题不注入宽泛规则');
+}

package/test/recall.test.mjs

@@ -587,3 +587,29 @@ console.log('recall.test.mjs: ok');
   await runtime.preStep({ agent, signal: second, turn: 't2' }, enter(assistantMessage, human('这个怎么弄')));
   assert.match(runtime.provider.text({ agent, signal: second }), /改完 client\.js 先重载宿主/, '动作侧线索要能召回预防型记忆');
 }
+
+// A26：明确换任务后，不能拿上一轮助手的话去补查、把旧任务记忆塞进新任务。
+{
+  const cwdSwitch = mkdir('switch');
+  const scopeSwitch = store.scopeOf(cwdSwitch);
+  save(scopeSwitch, {
+    title: '口播开场先给结论',
+    tags: ['口播', '开场'],
+    summary: '口播开场三句内先给结论，别先铺垫',
+  });
+  const agent = makeAgent('agent-switch', cwdSwitch);
+  const runtime = boot();
+  const first = signal();
+  await runtime.preStep({ agent, signal: first, turn: 't1' }, enter(human('这期口播开场怎么改')));
+  const assistantMessage = {
+    role: 'assistant',
+    id: 'asst-switch-1',
+    content: [
+      { type: 'text', text: '口播开场先给结论，栏目风格保持短句。' },
+      { type: 'tool-call', name: 'write', input: { file_path: '/tmp/switch/talk.md' } },
+    ],
+  };
+  const second = signal();
+  await runtime.preStep({ agent, signal: second, turn: 't2' }, enter(assistantMessage, human('开始写 PostgreSQL 迁移脚本，先建表')));
+  assert.equal(runtime.provider.text({ agent, signal: second }), '', '换任务后不补查旧任务的动作线索');
+}

package/test/state.test.mjs

@@ -633,7 +633,7 @@ test('P0-B 坏 state 且没有 prev：报错给出损坏副本与可执行的恢
   assert.equal(fs.readFileSync(stateFile(scope), 'utf8'), broken);
 });
 
-test('D05 学习开关关掉再开，不重置已用次数和整理记录', () => {
+test('D05 学习开关关掉再开，不重置已用次数、滚动额度与整理记录', () => {
   const scope = fresh('d05-learning-budget');
   const at = new Date().toISOString();
   transact(scope, {}, (draft) => {
@@ -647,7 +647,7 @@ test('D05 学习开关关掉再开，不重置已用次数和整理记录', () =
   });
   const opened = load(scope).state.experimental.projectEvolution;
   assert.equal(opened.enabled, true);
-  assert.deepEqual(opened.learning.recent, [], '打开时清掉在途观察');
+  assert.deepEqual(opened.learning.recent, [at], '滚动额度时间戳要留着，关开不洗额度');
   assert.equal(opened.learning.receipts.length, 1, '打开不能清整理回执');
   assert.equal(opened.learning.attempts.ep_seed.count, 2, '打开不能清已用次数');
   transact(scope, {}, (draft) => state.applyEvolution(draft, false));
@@ -656,7 +656,7 @@ test('D05 学习开关关掉再开，不重置已用次数和整理记录', () =
   assert.equal(again.enabled, true);
   assert.equal(again.learning.receipts.length, 1, '关掉再开不重置整理回执');
   assert.equal(again.learning.attempts.ep_seed.count, 2, '关掉再开不重置已用次数');
-  assert.deepEqual(again.learning.recent, []);
+  assert.deepEqual(again.learning.recent, [at], '关掉再开也不能洗掉滚动额度');
 });
 
 for (const dir of dirs) fs.rmSync(dir, { recursive: true, force: true });

package/view.js

@@ -710,12 +710,37 @@ export function isContinuationQuery(text) {
   return /^(继续|接着|然后|然后呢|还有|还有呢|往下|说下去|goon|continue|next|more)$/.test(raw);
 }
 
+/**
+ * 补查只有在「还是同一个任务」时才成立：任务类型或 episode 变了，上一轮的动作历史属于旧任务，
+ * 不能拿它给新任务找记忆。缺任一侧身份都按不同任务处理，宁可少补一次也不串旧话题。
+ */
+export function sameRecallTask(previous, current) {
+  if (!previous || !current) return true;
+  const kind = (value) => plain(value && value.kind, 40).trim().toLowerCase();
+  const episode = (value) => plain(value && value.episodeId, 120).trim();
+  /** 两侧都认出了任务类型且不同：明确换任务，上一轮的动作历史不再属于当前请求。 */
+  if (kind(previous) && kind(current) && kind(previous) !== kind(current)) return false;
+  /** 同类型但是另一个 episode：同类任务的新一轮，也不沿用旧任务的动作线索。 */
+  if (kind(previous) && kind(current) && episode(previous) && episode(current)) {
+    return episode(previous) === episode(current);
+  }
+  /** 认不出类型（或只有一侧有）时保留补查：这正是该机制要救的场景。 */
+  return true;
+}
+
 /**
  * 动作侧检索词：用户这句话没提，但「刚才在动什么」往往就写在上一轮助手的话和工具名里。
  * 预防型记忆（先重载再重启、改插件后别用 Cmd+R）约束的是下一步动作，
  * 只拿用户原话查，词面永远在错的一侧。这里只取少量最近的实词和工具名，避免长文稀释命中。
  */
 const ACTION_NOISE = new Set(['const', 'function', 'return', 'import', 'export', 'from', 'async', 'await', 'true', 'false', 'null', 'undefined', 'string', 'number', 'object']);
+const MEMORY_TOOL = /^memory(?:[_-]|$)/i;
+const MEMORY_TEXT = /^(?:memory ·|已有记忆可能相关|这条记忆|有些实验规则)/u;
+/** 记忆工具的调用与记忆自身的呈现文本不能充当新召回线索：否则记忆会自己触发自己。 */
+function isMemoryNoise(name, text) {
+  if (name && MEMORY_TOOL.test(String(name))) return true;
+  return Boolean(text && MEMORY_TEXT.test(String(text).trimStart()));
+}
 export function actionTerms(messages, options = {}) {
   if (!Array.isArray(messages)) return '';
   const limit = Number.isInteger(options.limit) && options.limit > 0 ? options.limit : 16;
@@ -734,6 +759,7 @@ export function actionTerms(messages, options = {}) {
     for (const part of content) {
       if (!part || typeof part !== 'object') continue;
       if (part.type === 'tool-call' || part.type === 'tool_call') {
+        if (isMemoryNoise(part.name, '')) continue;
         if (typeof part.name === 'string') push(part.name);
         const input = part.input || part.arguments || part.args;
         if (input && typeof input === 'object') {
@@ -745,7 +771,7 @@ export function actionTerms(messages, options = {}) {
         }
         continue;
       }
-      if (part.type === 'text' && typeof part.text === 'string') text += `${part.text}\n`;
+      if (part.type === 'text' && typeof part.text === 'string' && !isMemoryNoise('', part.text)) text += `${part.text}\n`;
     }
     return text;
   };