dsh-lite-memory 0.18.26 → 0.18.28

package/docs/CONVENTIONS.md

@@ -83,9 +83,10 @@
 **范围路由**：模型给的 `scope` 是提案，不是命令。
 
 - 显式 `scope="global"` 表示「用户在这一次对话里要求存全局」，只有用户确实这么说才传；模型自己觉得通用不是理由。显式全局不再因为缺少 `evidenceRef` 被降级。
-- 仍然会拦住的两类：设备事实没有条件（`machine` / `targetOs` / `runtime` / `shell` 至少一个），以及正文或依据里出现本机路径、回环地址、端口的「通用流程」——后者换台机器/换个项目就不成立，留在项目层。
+- 仍然会拦住的两类：设备事实没有条件（`machine` / `targetOs` / `runtime` / `shell` 至少一个），以及正文或依据里写死本机路径、回环地址、端口却没声明适用环境的「通用流程」——后者换台机器/换个项目就不成立，留在项目层。
+- 声明了上述环境条件的本机流程（例如本机特有的命令包装）可以进全局层：条件不成立的机器上不会拿出来用；命令名/工具名本身不算本机痕迹。
 - `memoryClass="project_fact"` 不因写了 `global` 就变全局：项目事实换个项目本来就不成立。
-- 按类别推导（没有显式 `scope`）保持更严：`portable_procedure` 没有 `evidenceRef` 就落项目层。
+- 按类别推导（没有显式 `scope`）保持更严：`portable_procedure` 没有 `evidenceRef`、也没有环境条件时落项目层。
 - 每次降级都要能解释：只在降级时返回 `scopeNote` 一行，说明为什么没进全局、怎么改才进得去；正常落全局或落项目不带这行。
 
 **限额与腾位**：每层活跃条目软上限 200、硬上限 1000；单条正文 4096 字节；单层总字节 1 MiB。到硬上限时把最久没被读的活跃条目移进归档，并在结果里写明「已归档「标题」腾位」，不拒绝新记忆；单条正文超限只报错、不截断。

package/docs/RELEASE-0.18.27.md

@@ -0,0 +1,5 @@
+# 0.18.27
+
+- 可信上下文补上宿主真实平台（`darwin → macos`，`win32 → windows`）：条件写 `targetOs` 的规则从「永远待确认」变成按平台裁决，macOS 上写的本机流程在 macOS 上直接生效。
+- 此前全局层只能收「声明了 machine/runtime 条件」的流程，但条件无从比对；这次把能自动核验的那一维接上，条件不再只是摆设。
+- 召回夹具改用与平台无关的条件，避免 CI 与开发机行为不一致。

package/index.js

@@ -3,6 +3,7 @@ import {
   globalScope,
   upsert,
   search,
+  markUsed,
   readEntry,
   readLinks,
   forget,
@@ -919,7 +920,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 +961,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 +1102,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 +1304,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 +1349,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 +1523,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 +1562,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 +1686,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 +1927,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 +1938,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 +1958,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 +1971,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 +1989,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 +2207,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 +2266,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 +2603,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 +2700,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 +2709,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 +2737,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 +2788,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 +2800,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.26",
+  "version": "0.18.28",
   "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) {

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);
@@ -460,6 +512,8 @@ const pass = (text, id) => async () => ({
   messages: [{ role: 'user', id, source: { kind: 'user' }, content: [{ type: 'text', text }] }],
 });
 const recall = promptContexts.find((entry) => entry.name === 'lite-memory:recall');
+  /* CI 冷启动偶尔超过召回耗时上限，逻辑断言不该被「这轮先不注入」判失败。 */
+  globalThis.__liteMemoryRecall?.setDeadlineMs?.(5000);
 assert.ok(recall, 'recall context registered');
 assert.equal(recall.order, 60);
 assert.equal(recall.interpolate, false);
@@ -545,6 +599,8 @@ const evoEnter = async () => ({
 });
 await preStep({ agent: evoAgent, signal: evoSig, turn: '21' }, evoEnter);
 const evoRecall = promptContexts.find((entry) => entry.name === 'lite-memory:recall');
+  /* CI 冷启动偶尔超过召回耗时上限，逻辑断言不该被「这轮先不注入」判失败。 */
+  globalThis.__liteMemoryRecall?.setDeadlineMs?.(5000);
 assert.match(evoRecall.text({ agent: evoAgent, signal: evoSig }), /开场三句内给结论/);
 assert.equal(evoRecall.text({ agent: evoAgent, signal: evoSig }).includes('README'), false);
 
@@ -668,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');

package/test/control.test.mjs

@@ -33,6 +33,8 @@ function boot() {
   };
   apply(ctx, { mode: 'adaptive' });
   const provider = promptContexts.find((entry) => entry.name === 'lite-memory:recall');
+  /* CI 冷启动偶尔超过召回耗时上限，逻辑断言不该被「这轮先不注入」判失败。 */
+  globalThis.__liteMemoryRecall?.setDeadlineMs?.(5000);
   const exec = (name, args, agent) => defs.get(name).execute(args, { agent });
   const preStep = (payload, decision) => handlers.get('agent/pre-step').at(-1)(payload, async () => decision);
   return { exec, preStep, text: (agent, signal) => provider.text({ agent, signal }), debug: globalThis.__liteMemoryRecall };
@@ -286,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

@@ -59,6 +59,28 @@ 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');
+});
+
 await test('S03 设备事实没给设备条件就返回 needsScope，不落盘', () => {
   const scope = fresh('route-env');
   const saved = saveEntry(scope, { title: '本机 Node', summary: '本机 Node 版本', body: 'v24', memoryClass: 'environment_fact' });

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

@@ -39,6 +39,8 @@ function boot(mode = 'adaptive') {
   apply(ctx, { mode });
   const debug = globalThis.__liteMemoryRecall;
   const provider = promptContexts.find((entry) => entry.name === 'lite-memory:recall');
+  /* CI 冷启动偶尔超过召回耗时上限，逻辑断言不该被「这轮先不注入」判失败。 */
+  globalThis.__liteMemoryRecall?.setDeadlineMs?.(5000);
   assert.ok(provider, 'recall provider registered');
   assert.equal(provider.order, 60);
   assert.equal(provider.interpolate, false);
@@ -111,8 +113,8 @@ const linuxOnly = save(scopeA, {
   tags: ['插件', '构建'],
   when: '',
   applicability: 'conditional',
-  conditions: [{ key: 'targetOs', value: 'linux' }],
-  summary: '只在 Linux CI 上跑构建检查',
+  conditions: [{ key: 'machine', value: '别的机器' }],
+  summary: '只在另一台机器上跑构建检查',
 });
 const unresolved = save(scopeA, { title: '发布前要检查什么', tags: ['发布', '检查'], when: '发布前', applicability: 'unresolved' });
 const globalHot = save(global, { title: '插件改动后先热刷新', tags: ['插件', '热刷新'], summary: '全局规矩：先热刷新再谈重启' });
@@ -266,10 +268,10 @@ assert.notEqual(bootA.provider.text({ agent: agentB, signal: signalB }), prepare
   const cwdC = mkdir('c');
   const scopeC = store.scopeOf(cwdC);
   save(scopeC, {
-    title: '只在 Linux 上跑构建检查',
+    title: '只在另一台机器上跑构建检查',
     tags: ['构建'],
     applicability: 'conditional',
-    conditions: [{ key: 'targetOs', value: 'linux' }],
+    conditions: [{ key: 'machine', value: '别的机器' }],
   });
   save(scopeC, { title: '发布前检查清单', tags: ['发布'], when: '发布前', applicability: 'unresolved' });
   const agent = makeAgent('agent-cond', cwdC);
@@ -585,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/runtime-context.test.mjs

@@ -33,6 +33,8 @@ function boot(mode = 'adaptive') {
   };
   apply(ctx, { mode });
   const provider = promptContexts.find((entry) => entry.name === 'lite-memory:recall');
+  /* CI 冷启动偶尔超过召回耗时上限，逻辑断言不该被「这轮先不注入」判失败。 */
+  globalThis.__liteMemoryRecall?.setDeadlineMs?.(5000);
   assert.ok(provider, 'recall provider registered');
   const exec = (name, args, agent) => defs.get(name).execute(args, { agent });
   const preStep = (payload, decision) => handlers.get('agent/pre-step').at(-1)(payload, async () => decision);

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/test/view.test.mjs

@@ -70,7 +70,11 @@ test('条件裁决：不把不知道当不存在，也不把未解决当普遍
   const record = { id: 'mem_000000000001', applicability: 'conditional', conditions: [{ key: 'targetOs', value: 'macOS' }], when: '' };
   assert.equal(view.evaluate(record, ctxOf(null, { targetOs: 'macos' })).state, 'match');
   assert.equal(view.evaluate(record, ctxOf(null, { targetOs: 'linux' })).state, 'mismatch');
-  assert.equal(view.evaluate(record, ctxOf(null, {})).state, 'unknown');
+  assert.equal(ctxOf(null, {}).targetOs, view.hostTargetOs());
+  const hostRecord = { ...record, conditions: [{ key: 'targetOs', value: view.hostTargetOs() || 'macos' }] };
+  assert.equal(view.evaluate(hostRecord, ctxOf(null, {})).state, 'match');
+  const machineOnly = { ...record, conditions: [{ key: 'machine', value: '这台机器' }] };
+  assert.equal(view.evaluate(machineOnly, ctxOf(null, {})).state, 'unknown');
   const unresolved = { ...record, applicability: 'unresolved', conditions: [] };
   assert.equal(view.statusOf(unresolved, ctxOf(null, {})), 'needs_context');
   assert.equal(view.canAutoRecall(unresolved, ctxOf(null, {})), false);

package/view.js

@@ -152,7 +152,8 @@ export function validateApplicability(applicability, conditions, selection, when
 export function trustedContext(scope, options = {}) {
   const cwd = typeof options.cwd === 'string' && options.cwd ? options.cwd : (scope && scope.cwd) || '';
   return {
-    targetOs: options.targetOs,
+    /** 宿主的真实平台是可信上下文：条件里写 targetOs 的规则本职就是按平台生效。 */
+    targetOs: options.targetOs === undefined ? hostTargetOs() : options.targetOs,
     shell: options.shell,
     runtime: options.runtime,
     machine: options.machine,
@@ -166,6 +167,15 @@ export function trustedContext(scope, options = {}) {
   };
 }
 
+/** 只报归一化后的平台名；未知平台不硬猜，留给条件判 unknown。 */
+export function hostTargetOs() {
+  const platform = typeof process !== 'undefined' && process ? process.platform : '';
+  if (platform === 'darwin') return 'macos';
+  if (platform === 'win32') return 'windows';
+  if (platform === 'linux') return 'linux';
+  return '';
+}
+
 function sameText(left, right) {
   return plain(left, PATH_CHARS).toLowerCase() === plain(right, PATH_CHARS).toLowerCase();
 }
@@ -700,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;
@@ -724,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') {
@@ -735,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;
   };