dsh-lite-memory 0.18.34 → 0.18.35

package/README.md

@@ -29,12 +29,16 @@ Lightweight memory for the DeepSeek Harness. Nothing resident: no standing promp
 
 真命中看这句话和记忆的标题（含旧标题）、标签、触发词、摘要有没有对得上的词：有就多一行「已有记忆可能相关」，最多三条标题，每条前面标归属（`[global]` 或项目目录名如 `[DSH]`）；没对上就不出现，不改命中计数，正文要 `memory_read` 才读。一条记忆写了触发词，用户说到那个词也算命中。
 
+普通记忆卡片和实验规则共用一份额度：一次最多 3 条、1200 字节，按整条准入，先到先占；自动提示只带标题和摘要，不带正文。实验短规则（正文不超过 240 字且不超过 4 行）直接带正文，更长的只给标题和用途，正文仍要 `memory_read`。
+
 | Case | Behaviour |
 | --- | --- |
 | **L0** you ask it to remember | written immediately, one confirmation line |
 | **L1** it spots something worth keeping | one muted line `memory · suggested "X" · sug_x` with a single 「保留」 button — readable before you click, nothing written unless you click, at most once per two days |
 | **L2** common sense, one-off parameters, credential values | never written |
 
+The automatic hint carries titles and summaries, never bodies. Normal cards and experimental rules share one budget: at most 3 cards / 1200 bytes per request, admitted as whole cards, first come first served. An experimental rule with a body of at most 240 characters and 4 lines is inlined; a longer one gives only its title and purpose, and the body still requires `memory_read`.
+
 Those lines belong to the turn that made them: each turn is rebuilt from its own tool results, so reopening the session shows them again and no other turn leaks in. Saving again updates an entry only when the title (or one of its earlier titles) matches exactly under the same precondition. A merely similar title writes nothing first: the result names the closest entry, so the caller either re-saves with that title or adds `resolution="distinct"`. An update keeps every field it was not given and replaces the body wholesale; the previous body is kept only for internal undo and never shown or searched. The same subject under different preconditions stays two entries.
 
 Writes land in one of two layers: the current project by default, or the global layer (warns past 200, hard ceiling 1000) when the user says the rule holds for every project. Both layers are searched together, and a `when` field separates the same subject under different preconditions.

package/bench/bench.mjs

@@ -38,7 +38,7 @@ apply(ctx);
 
 const cwd = path.join(os.tmpdir(), 'lite-memory-bench-project');
 fs.mkdirSync(cwd, { recursive: true });
-const agent = { cwd, session: { id: 'bench-session', header: { cwd } } };
+const agent = { id: 'bench-agent', cwd, session: { id: 'bench-session', header: { cwd } } };
 const exec = (name, args) => defs.get(name).execute(args, { agent });
 const save = (args) => exec('memory_save', args);
 
@@ -63,16 +63,22 @@ for (let i = 0; i < 200; i += 1) {
     resolution: 'distinct',
   });
 }
+/**
+ * 全局层用受信任写入直接种：经 memory_save 的模型提案会被降到项目层，
+ * 这里要测的是两层都在时的召回路径，不是降级路径。
+ */
+const globalScope = store.globalScope();
 for (let i = 0; i < 200; i += 1) {
-  save({
+  const saved = store.saveEntry(globalScope, {
     title: `全局条目 ${i} 交付规范`,
     summary: `全局条目 ${i} 的通用说明`,
     when: `全局场景 ${i}`,
     body: `全局正文 ${i}：交付前清零告警。`,
-    scope: 'global',
     applicability: 'all_in_scope',
+    scopeConfirmed: true,
     resolution: 'distinct',
   });
+  if (!saved || !saved.record) throw new Error(`global seed ${i} failed: ${JSON.stringify(saved).slice(0, 500)}`);
 }
 report.seedMs = Date.now() - started;
 report.entries = {
@@ -108,6 +114,19 @@ report.prepare = {
   avgContextBytes: Math.round(bytes / timings.length),
 };
 
+// Positive scenario: a normal question must actually receive budgeted memory text.
+const positiveSignal = new AbortController().signal;
+await preStep({ agent, signal: positiveSignal, turn: '9000' }, async () => ({
+  kind: 'enter',
+  messages: [{ role: 'user', id: 'bench-positive', source: { kind: 'user' }, content: [{ type: 'text', text: '全局条目 7 的交付规范是什么' }] }],
+}));
+const positiveText = recall.text({ agent, signal: positiveSignal });
+report.positive = {
+  bytes: Buffer.byteLength(positiveText, 'utf8'),
+  hasGlobalCard: /全局条目 7 交付规范/.test(positiveText),
+  underCap: Buffer.byteLength(positiveText, 'utf8') <= 1300,
+};
+
 // File reads per prepare, measured on the same path.
 let reads = 0;
 const original = fs.readFileSync;
@@ -140,6 +159,9 @@ report.afterSequence = {
   files: fs.readdirSync(store.scopeOf(cwd).dir).sort(),
 };
 report.rssEndMB = rss();
-report.ok = project.entries.length <= store.LIMITS.entries + store.LIMITS.hardEntries;
+report.ok = project.entries.length <= store.LIMITS.entries + store.LIMITS.hardEntries
+  && report.entries.project >= 200 && report.entries.global >= 200
+  && report.prepare.avgContextBytes > 0
+  && report.positive.bytes > 0 && report.positive.hasGlobalCard && report.positive.underCap;
 
 console.log(JSON.stringify(report, null, 2));

package/docs/BENCH.md

@@ -25,21 +25,22 @@ npm run bench:evolution  # 实验规则/样例/检查点/回执的存储与投
 
 ## 固定数据集性能
 
-2026-10-27，macOS arm64，Node v24.16.0，本地 SSD。数据：项目 200 条 + 全局 200 条，全部带标题、摘要、`when`、正文。
+2026-10-29，macOS arm64，Node v24.16.0，本地 SSD。数据：项目 200 条 + 全局 200 条，全部带标题、摘要、`when`、正文；另加一条正面场景，确认全局卡片真的进得来且不超预算。
 
 0.18.0 起每次保存都走「写临时文件 → fsync → rename → fsync 目录」并保留上一版，代价是单次保存多两次落盘；下面这组数是带这套持久化保证后测的。
 
 | 指标 | 数值 |
 | --- | --- |
-| 准备时延 P50 | 27.9 ms |
-| 准备时延 P95 | 31.8 ms |
-| 冷启动首次准备 | 37 ms |
-| 最慢一次 | 37 ms |
-| 每次准备上下文 | 402 B |
-| 每次准备文件读取 | 0 |
-| 120 次运行总字节 | 48 KB |
+| 准备时延 P50 | 62.3 ms |
+| 准备时延 P95 | 112.4 ms |
+| 冷启动首次准备 | 83.9 ms |
+| 最慢一次 | 136.1 ms |
+| 每次准备上下文 | 368 B |
+| 正面场景上下文 | 335 B，含 1 张全局卡片，未超 3 条 / 1200 字节 |
+| 每次准备文件读取 | 0.2 |
+| 本次数据规模 | 项目 200 条 + 全局 200 条 |
 
-本地目标改为热准备 P95 ≤ 40 ms（deadline 150 ms 不变）：每次保存都要落盘两遍才敢说没丢，30 ms 的旧目标只适用于不落盘的版本。当前 P95 31.8 ms 达标。模型 provider 在准备阶段无 I/O、无网络。
+数据翻倍到两层各 200 条后，准备时延比 0.18.0 的 200 条单层基线高；deadline 150 ms 不变，当前 P95 112.4 ms 仍在限内。模型 provider 在准备阶段无 I/O、无网络。
 
 ## 长期序列
 
@@ -49,10 +50,10 @@ npm run bench:evolution  # 实验规则/样例/检查点/回执的存储与投
 | --- | --- |
 | 项目活跃条目 | 350 |
 | 全局活跃条目 | 200 |
-| `state.json` | 338 KB（上限 2 MiB） |
+| `state.json` | 396 KB（上限 2 MiB） |
 | 层内文件 | `state.json`、`state.prev.json` 两个，不随轮数增长 |
-| RSS | 165 MB 量级（含进程内缓存与测试数据） |
-| 序列耗时 | 18.4 s（150 轮全落盘） |
+| RSS | 190 MB 量级（含进程内缓存与测试数据） |
+| 序列耗时 | 7.3 s（150 轮全落盘） |
 
 ## 实验整理成本（0.11.0）
 

package/docs/RELEASE-0.18.35.md

@@ -0,0 +1,11 @@
+# 0.18.35：召回账本能对上，跨项目写入要人点头
+
+- npm 原生凭据命令在执行前拦一次：`npm whoami` / `publish` / `login` / `token` / `config get` 会直接收到已有记忆里那条「发布一律走 dsh-npm」的正文，同一请求只提示一次，`dsh-npm` 自己的命令不受影响。
+- 自动注入只有一份预算：普通卡片与实验规则合计最多 3 条、1200 字节，按整条准入；最终交付文本的字节数和卡片数与账本一致，准备阶段被丢弃、到期撤下的条目不再记使用。
+- 任务状态和展示快照分开：第一步零命中不再丢掉请求身份；之后只有真正的执行动作（写文件、跑命令等）触发一次补查，读文件、`memory_search`/`memory_read` 的输出不花这次机会；换任务后旧动作线索不跟过来。
+- 使用记账推迟到回合收尾批量写，provider 输出路径不碰写锁；回合结束、请求替换和 agent 销毁都不会漏掉最后一轮的使用记录。
+- 跨项目写入只认真人原话：模型写进 `memory_save` 参数里的 `scope` 只是提案，自动整理产物一律留在项目层；只有本轮明确说「存到全局/所有项目/跨项目」才允许落全局，普通说「全局变量」不会误判成授权。
+- 学习条件统一校验：收集阶段带进来的 `taskKind` / `seriesId` 是可信范围，模型新提的条件仍要落在本项目已有栏目或阶段里；同一主题连续纠正收敛到一条现行版，换栏目不适用，关掉再开还是同一现行版。
+- 基准改成真实的跨层召回：200 条项目记忆 + 200 条可信全局记忆，加一条正面场景，确认全局卡片确实进得来且不超预算。
+
+验证：`npm test` 全绿；`npm run bench` 在本机固定数据集上通过。

package/index.js

@@ -1176,10 +1176,20 @@ export function apply(ctx, config) {
 
   const agentKey = (agent) => String(agent?.id ?? '');
 
+  /** 回合收尾/换请求时批量记账：一次锁，不在 provider 输出路径上。 */
+  const flushUsage = (state) => {
+    if (!state || !state.scope || !(state.deliveredIds instanceof Set) || state.deliveredIds.size === 0) return;
+    const ids = [...state.deliveredIds].filter(Boolean);
+    state.deliveredIds = new Set();
+    if (!ids.length) return;
+    try { markUsed(state.scope, ids); } catch { /* usage is best-effort */ }
+  };
+
   const clearPrepared = (agent) => {
     if (!agent) return;
     const state = prepared.get(agent);
     if (state && state.signal) signalAgents.delete(state.signal);
+    flushUsage(state);
     prepared.delete(agent);
     const key = agentKey(agent);
     const cleanup = key ? abortCleanups.get(key) : null;
@@ -1920,8 +1930,11 @@ export function apply(ctx, config) {
         const now = Date.now();
         const live = state.lines.filter((row) => !row.validUntil || now <= Date.parse(String(row.validUntil)));
         normalText = live.length ? `${RECALL_HEADER}\n${live.map((row) => row.line).join('\n')}` : '';
-        /** 真正交付的卡片才记使用：到期被撤下的、准备后被丢弃的都不算。 */
-        if (live.length && state.scope) markUsed(state.scope, live.map((row) => row.id).filter(Boolean));
+        /** 真正交付的卡片才记使用；记账推迟到回合收尾，provider 不碰写锁。 */
+        if (live.length && state.scope) {
+          if (!(state.deliveredIds instanceof Set)) state.deliveredIds = new Set();
+          for (const row of live) if (row.id) state.deliveredIds.add(row.id);
+        }
         /** 投影时还在、发出时已过期：回执跟着真实输出改，别在面板上说「提醒了 2 条」而正文是空的。 */
         if (state.scope && live.length !== state.cards.length) {
           noteRecall(state.scope, state.sessionId, {
@@ -2024,8 +2037,21 @@ export function apply(ctx, config) {
       const supersedesId = supersedes && !/^mem_[a-z0-9]+$/.test(supersedes)
         ? (() => { try { return refIdOf(projectScope, { title: supersedes }, '记忆'); } catch { return ''; } })()
         : supersedes;
-      /** 工具写入的正文由模型写，来源标成模型整理，不能冒充用户原话。 */
-      const draft = { ...args, writeMode: args.mode || 'patch', origin: 'model_drafted' };
+      /**
+       * 模型写进参数里的 scope 只是提案：只有本轮真人原话明确说「所有项目/全局」，
+       * 或面板直接确认过，才允许落到全局层。工具写入的正文由模型写，不能冒充用户原话。
+       */
+      const preparedState = prepared.get(execution && execution.agent);
+      const humanSaid = String(preparedState && preparedState.saidOnly || '');
+      const humanGlobal = humanAskedGlobal(humanSaid);
+      const draft = {
+        ...args,
+        writeMode: args.mode || 'patch',
+        origin: 'model_drafted',
+        scopeConfirmed: humanGlobal,
+        requestedScope: args.scope,
+      };
+      if (humanGlobal) draft.scope = 'global'; else delete draft.scope;
       if (supersedes) { if (supersedesId) draft.supersedes = supersedesId; else delete draft.supersedes; }
       /** 更新句柄也用标题：id 只是底层实现，模型抄标题就行。 */
       const updateTitle = String(args.updateTitle || '').trim();
@@ -2097,8 +2123,9 @@ export function apply(ctx, config) {
       /** 显式要了全局却被硬冲突挡回项目层时说清原因：否则模型只能看到 scope=project，无从纠。 */
       const scopeNote = (() => {
         if (args.scope !== 'global' || scope.key === 'global') return '';
-        if (saved.reasonCode === 'machine_bound_scope') return '按本机痕迹留在项目层：正文或依据里写了本机路径/端口，改成别的项目仍成立的通用规则再存全局；只在本机适用的流程可补 machine 条件后存全局';
-        if (saved.reasonCode === 'model_global_project_fact') return '按项目事实留在项目层：换成别的项目就不成立；确实是通用流程就改 memoryClass';
+        if (saved.reasonCode === 'machine_bound_scope' || saved.reasonCode === 'machine_bound_procedure') return '按本机痕迹留在项目层：正文或依据里写了本机路径/端口，改成别的项目仍成立的通用规则再存全局；只在本机适用的流程可补 machine 条件后存全局';
+        if (saved.reasonCode === 'model_global_project_fact' || saved.reasonCode === 'class_project_fact') return '按项目事实留在项目层：换成别的项目就不成立；确实是通用流程就改 memoryClass';
+        if (saved.reasonCode === 'model_class_project' || saved.reasonCode === 'unclassified_project') return '按当前项目保存：模型归类只是提案，要存全局得由用户明确说「所有项目都这样」';
         return '';
       })();
       if (saved.needsResolution) {
@@ -2617,14 +2644,66 @@ export function apply(ctx, config) {
     }), 'lite-memory: recall context');
   }
 
+  /**
+   * 只有人在这句话里明确要求「存到全局/所有项目」才算跨项目授权。
+   * 不能因为句子里同时出现「全局」和「保存」就放行：那可能只是在说全局变量。
+   */
+  const humanAskedGlobal = (said) => {
+    const text = String(said || '');
+    return /(?:存|记|写|放|加|保存|放到|记到|写进).{0,10}(?:全局|所有项目|跨项目)/u.test(text)
+      || /(?:全局|所有项目|跨项目).{0,10}(?:都|一律|通用|适用|记住)/u.test(text)
+      || /(?:以后|今后).{0,16}(?:所有项目|每个项目|全局|跨项目)/u.test(text);
+  };
+
+  /**
+   * npm 原生命令最容易把「没登录」误判成「没凭据」：whoami 报 ENEEDAUTH 之后，
+   * 会话常会反复试 login/token，真正该走的 dsh-npm 反而没人提。
+   * 这里只在动作发生前拦一次，把已有记忆正文直接交给模型；同一轮不重复，不产生循环。
+   */
+  const npmProbeHint = (agent, execution) => {
+    try {
+      const name = String(execution?.name || '');
+      if (!/^(bash|run_command|shell|terminal|exec)$/.test(name)) return undefined;
+      const command = String(execution?.arguments?.command || execution?.arguments?.cmd || execution?.arguments?.input || '');
+      if (!command || command.length > 4000 || !/\bnpm\b/.test(command)) return undefined;
+      if (/dsh-npm/.test(command)) return undefined;
+      if (!/(^|[;&|]\s*)(?:sudo\s+)?npm\s+(?:whoami|publish|login|adduser|add-user|token|config\s+get)\b/.test(command)) return undefined;
+      const held = prepared.get(agent);
+      if (!held || held.npmHinted) return undefined;
+      if (!memoryOnForAgent(agent)) return undefined;
+      const index = loadIndex(globalScope());
+      const row = (index.entries || []).find((entry) => {
+        if (!entry || entry.archived || entry.origin === 'project_evolution') return false;
+        /** 过期/被取代的规则不能再在动作前拦人。 */
+        if (view.lifecycleStatusOf(entry)) return false;
+        if (held.deliveredIds instanceof Set && held.deliveredIds.has(entry.id)) return false;
+        const head = `${entry.title || ''} ${entry.summary || ''} ${(entry.tags || []).join(' ')}`;
+        const body = String(entry.body || '').slice(0, 800);
+        return /npm|dsh-npm/i.test(head)
+          && /(凭据|登录|token|whoami|发布|publish|ENEEDAUTH|Keychain)/i.test(`${head} ${body}`);
+      });
+      if (!row) return undefined;
+      held.npmHinted = true;
+      /** 这条正文真的交给模型了，按交付记使用。 */
+      if (!(held.deliveredIds instanceof Set)) held.deliveredIds = new Set();
+      if (row.id) held.deliveredIds.add(row.id);
+      const body = String(row.body || row.summary || '').trim().slice(0, 600);
+      return `[lite-memory] 这条 npm 命令先别执行：它容易被登录态误导。已有记忆「${row.title}」：${body}\n按记忆改用 dsh-npm；这条提示同一轮只出现一次，直接继续，不要重复探测凭据。`;
+    } catch {
+      return undefined;
+    }
+  };
+
   /** 执行入口再拦一次：工具若已出现在旧快照里，调用时也不放行。 */
   if (typeof ctx.on === 'function') ctx.on('agent/created', (payload) => {
     const agent = payload?.agent;
     if (!agent?.ctx?.tools) return;
     try {
       agent.ctx.effect(() => agent.ctx.tools.guard((execution) => {
-        if (!MEMORY_TOOLS.includes(execution?.name)) return undefined;
-        return memoryOnForAgent(agent) ? undefined : '本项目记忆已关闭，先在面板打开';
+        if (MEMORY_TOOLS.includes(execution?.name)) {
+          return memoryOnForAgent(agent) ? undefined : '本项目记忆已关闭，先在面板打开';
+        }
+        return npmProbeHint(agent, execution);
       }), 'lite-memory: tool guard');
     } catch { /* older host without guards */ }
     syncMemoryTools(agent);
@@ -2664,6 +2743,7 @@ export function apply(ctx, config) {
         .filter((message) => message?.source?.kind === 'user');
       const fresh = freshHumans(sessionId, humans);
       const previous = prepared.get(agent);
+      if (fresh.length > 0 && previous) flushUsage(previous);
       const sameSession = Boolean(previous && previous.sessionId === sessionId);
       const sessionTask = recallTasks.get(sessionId) || null;
 
@@ -2713,24 +2793,31 @@ export function apply(ctx, config) {
          * 只补一次、共用一个请求额度，补到的卡片追加到已发布快照，超出仍由预算挡。
          */
         const stepMessages = Array.isArray(decision.messages) ? decision.messages : [];
-        const seenAt = Number.isInteger(previous.seenMessages) ? previous.seenMessages : 0;
-        const stepActions = seenAt < stepMessages.length ? stepMessages.slice(seenAt) : [];
+        const seenIds = previous.seenIds instanceof Set ? previous.seenIds : new Set(previous.seenIds || []);
+        const stepActions = stepMessages.filter((message) => {
+          const id = String(message?.id ?? '');
+          return id ? !seenIds.has(id) : false;
+        });
+        previous.seenIds = new Set([...seenIds, ...stepMessages.map((message) => String(message?.id ?? '')).filter(Boolean)].slice(-64));
         previous.seenMessages = stepMessages.length;
+        /** 只读文件、搜索、记忆工具都不算动作；一次请求最多补查一次。 */
         const actionQuery = previous.recalledContext && !previous.actionRetried
+          && view.hasEffectiveAction(stepActions)
           ? view.actionTerms(stepActions, { limit: 10 }).slice(0, 240) : '';
         if (actionQuery) {
           previous.actionRetried = true;
           const win = windowOf(agent);
           if (win && generation === generations.get(agent) && !signal?.aborted) {
-            const retry = projectRecall(scope, `${actionQuery} ${previous.query}`.trim().slice(0, RECALL_QUERY_CHARS), previous.recalledContext, win, previous.runtimeHeld || null);
-            const known = new Set((previous.cards || []).map((card) => card.id));
-            const added = (retry.cards || []).filter((card) => !known.has(card.id));
-            if (added.length) {
-              const addedIds = new Set(added.map((card) => card.id));
-              const extraLines = (retry.lines || []).filter((row, index) => addedIds.has(retry.cards[index] && retry.cards[index].id));
-              previous.cards = [...(previous.cards || []), ...added];
-              previous.lines = [...(previous.lines || []), ...extraLines];
-              previous.text = `${RECALL_HEADER}\n${previous.lines.map((row) => row.line).join('\n')}`;
+            const nextQuery = `${actionQuery} ${previous.query}`.trim().slice(0, RECALL_QUERY_CHARS);
+            const retry = projectRecall(scope, nextQuery, previous.recalledContext, win, previous.runtimeHeld || null);
+            if (retry.cards.length) {
+              /** 补查结果整体替换展示快照；账本与正文来自同一次准入。 */
+              previous.text = retry.text;
+              previous.cards = retry.cards;
+              previous.lines = retry.lines;
+              previous.query = nextQuery;
+              previous.matched = retry.matched || retry.cards.length;
+              if (win) win.query = nextQuery;
             }
           }
         }
@@ -2748,9 +2835,10 @@ export function apply(ctx, config) {
       } : null;
       /** 工具模式也要记下本轮真人原话：只用于核对绑定，不自动注入。 */
       const said = view.newestUserQuery(fresh).slice(0, RECALL_QUERY_CHARS);
+      const continuationHint = view.isContinuationQuery(said) || view.isEllipticalContinuation(said);
       /** 「继续」这类续说没有检索词：带上同会话上一轮原话，否则这一轮必然召回为空。 */
-      const carried = (view.isContinuationQuery(said) || view.isEllipticalContinuation(said))
-        ? (previous?.query || sessionTask?.query || '') : '';
+      const carried = continuationHint
+        ? (sessionTask?.taskQuery || previous?.query || sessionTask?.query || '') : '';
       let query = (carried ? `${said} ${carried}` : said).trim().slice(0, RECALL_QUERY_CHARS);
       if (win && query) win.query = query;
 
@@ -2800,14 +2888,19 @@ export function apply(ctx, config) {
       const rememberedTask = lastTask.get(sessionId) || null;
       const previousTask = (previous && previous.task) || (sessionTask && sessionTask.task) || rememberedTask;
       const previousText = (previous && previous.query) || (sessionTask && sessionTask.query) || '';
+      const previousSaid = (previous && previous.saidOnly) || (sessionTask && sessionTask.saidOnly) || '';
+      const sameQuery = Boolean(previousSaid && said && previousSaid === said);
       const sameTask = Boolean(sameSession || sessionTask || rememberedTask)
         && !view.isExplicitSwitch(said, previousText)
-        && view.sameRecallTask(previousTask, currentTask);
+        && view.sameRecallTask(previousTask, currentTask, { continuation: continuationHint, sameQuery });
       const taskStartMessageId = sameTask && sessionTask && sessionTask.startMessageId
         ? sessionTask.startMessageId : ids[0];
       lastTask.set(sessionId, currentTask);
       recallTasks.set(sessionId, {
         query,
+        saidOnly: said,
+        /** 当前任务的稳定原话：续说只拼这一份，不把上一轮的动作线索越滚越长。 */
+        taskQuery: sameTask ? (sessionTask?.taskQuery || carried || said) : said,
         task: currentTask,
         startMessageId: taskStartMessageId,
         updatedAt: Date.now(),
@@ -2837,12 +2930,16 @@ export function apply(ctx, config) {
         if (win) win.query = query;
       }
       let snapshot = projectRecall(scope, query, recalledContext, win, runtime ? runtime.held : null);
-      /** 并了动作线索仍一张卡都没有，才补一次有界查询；补到了才替换，不拿空结果盖掉原判断。 */
+      /**
+       * 并了动作线索仍一张卡都没有，才补一次有界查询。
+       * 补到就用补查结果整体替换：两批卡片各量一次会绕过 3 条 / 1200 字节的共用额度。
+       */
       if (!snapshot.cards.length && !carried && sameTask && trail && !trailInQuery) {
         const actionQuery = `${trail} ${query}`.trim().slice(0, RECALL_QUERY_CHARS);
         const retry = projectRecall(scope, actionQuery, recalledContext, win, runtime ? runtime.held : null);
         if (retry.cards.length) {
           snapshot = retry;
+          query = actionQuery;
           if (win) win.query = actionQuery;
         }
       }
@@ -2881,12 +2978,10 @@ export function apply(ctx, config) {
         clearPrepared(agent);
         return decision;
       }
-      /** 实验上下文即使本轮零注入也要留着：工具绑定后同一请求还能补上规则。 */
-      if ((!snapshot || !snapshot.cards.length) && !experiment) {
-        rollbackBudget();
-        clearPrepared(agent);
-        return decision;
-      }
+      /**
+       * 零命中也要保留请求状态：这一轮第一步没命中，下一步的动作仍可能触发一次补查。
+       * 展示快照为空即可，不把任务身份和额度窗口一起丢掉。
+       */
       let evolutionEpoch = '';
       try { evolutionEpoch = String(evolutionStatus(scope).epoch || ''); } catch { evolutionEpoch = ''; }
       const state = {
@@ -2900,6 +2995,7 @@ export function apply(ctx, config) {
         task: currentTask,
         scope,
         query,
+        saidOnly: said,
         sessionId,
         turn,
         signal,
@@ -2909,7 +3005,9 @@ export function apply(ctx, config) {
         recalledContext,
         runtimeHeld: runtime && runtime.held ? runtime.held : null,
         seenMessages: Array.isArray(decision.messages) ? decision.messages.length : 0,
+        seenIds: Array.isArray(decision.messages) ? decision.messages.map((message) => String(message?.id ?? '')).filter(Boolean).slice(-64) : [],
         actionRetried: false,
+        deliveredIds: new Set(),
         at: Date.now(),
       };
       prepared.set(agent, state);
@@ -3219,6 +3317,7 @@ export function apply(ctx, config) {
       windowOf: (agent) => windowOf(agent),
       /** 测试专用：CI 冷启动偶尔超过 150ms，逻辑测试不该被耗时上限判失败。 */
       setDeadlineMs: (ms) => { if (Number.isFinite(ms) && ms > 0) recallDeadlineMs = ms; },
+      humanAskedGlobal,
     };
     return () => {
       delete globalThis.__liteMemoryRecall;

package/learning.js

@@ -618,10 +618,6 @@ export function validateChange(change, { refs, rules, ranges, expectedTarget } =
     if (!Array.isArray(change.conditions)) return { ok: false, reason: '条件不是列表' };
     conditions = normalizeConditions(change.conditions);
     if (conditions.length !== change.conditions.length) return { ok: false, reason: '条件里有不认的键或空值' };
-    for (const condition of conditions) {
-      const allowed = conditionValueAllowed(condition, { ranges, existing });
-      if (!allowed) return { ok: false, reason: '条件值不在本项目的栏目或阶段里' };
-    }
   }
   /** 收集时固定的作用域只能沿用或收窄：整理器不能把待确认候选抬成全项目规则。 */
   const expected = expectedTarget && typeof expectedTarget === 'object' ? expectedTarget : null;
@@ -669,6 +665,17 @@ export function validateChange(change, { refs, rules, ranges, expectedTarget } =
     if (conditionKeys.has(row.key)) return { ok: false, reason: '同一条件键给了两个值' };
     conditionKeys.add(row.key);
   }
+  /**
+   * 统一校验最终条件：收集阶段带进来的 taskKind/seriesId 是可信范围，历史范围里没有也允许；
+   * 模型新提的条件仍必须落在本项目已有栏目或阶段里。
+   */
+  for (const condition of effectiveConditions) {
+    const fromCollected = expectedConditions.some((row) => row.key === condition.key && row.value === condition.value);
+    if (fromCollected) continue;
+    if (!conditionValueAllowed(condition, { ranges, existing })) {
+      return { ok: false, reason: '条件值不在本项目的栏目或阶段里' };
+    }
+  }
   if (applicability === 'all_in_scope' && effectiveConditions.length) {
     return { ok: false, reason: '全项目规则不能带条件' };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-lite-memory",
-  "version": "0.18.34",
+  "version": "0.18.35",
   "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/store.js

@@ -2595,16 +2595,16 @@ export function routeScope(draft, options = {}) {
       requiredConditions: [{ key: 'machine', value: '' }, { key: 'runtime', value: '' }],
     };
   };
-  /** 人明确点过「就存全局」才算数；模型自己提的 global 不抵消本机痕迹。 */
+  /** 人明确点过「就存全局」才算数；模型自己提的 scope 只是提案。 */
   const humanConfirmed = options.humanScope === true || source.scopeConfirmed === true;
+  /** 实验/自动整理的产物永远留在项目层：它们没有「用户要求跨项目」这层依据。 */
+  const autoOrigin = source.origin === 'project_evolution' || source.origin === 'model_drafted';
   /** 「本项目里…」是项目事实的措辞，类别写成偏好/流程也不能这样进通用层。 */
   const projectBound = projectBoundText(source);
   if (durability === 'task') return { ...base, needsScope: true, reasonCode: 'task_state' };
-  if (explicit) {
+  if (explicit && (humanConfirmed || !autoOrigin)) {
     /**
-     * 显式 scope 代表「用户这个消息里要的那一层」：这是唯一能让全局层落地的输入，
-     * 所以不能再按模型自荐降级，只有本机痕迹和项目事实两种硬冲突能改落点。
-     * 没显式 scope 时才用 memoryClass 提案，缺可搬依据的流程留在项目层。
+     * 只有人确认过的 scope 才代表「用户这个消息里要的那一层」；模型写进参数的 scope 只是提案。
      */
     if (explicit === 'global' && !humanConfirmed) {
       if (machineConflict) return fallbackToProject('machine_bound_scope');
@@ -2631,21 +2631,28 @@ export function routeScope(draft, options = {}) {
     }
     return { ...base, chosenScope: 'project', reasonCode: 'class_project_fact' };
   }
+  /**
+   * 自动归类只能决定「它像哪类」，不能决定跨项目；默认落点一律是当前项目。
+   * 具体冲突（本机痕迹、「本项目」措辞）仍按原原因报告，其余全局结论统一降级。
+   */
+  const globalOutcome = (reasonCode) => (humanConfirmed
+    ? { ...base, chosenScope: 'global', reasonCode }
+    : fallbackToProject('model_class_project'));
   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' };
+    return globalOutcome('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 (envScoped) return globalOutcome('machine_scoped_procedure');
     /** 说能搬去别的项目，就要有能搬的依据；没有就先留在本项目。 */
     if (!evidence) return fallbackToProject('unbound_evidence');
-    return { ...base, chosenScope: 'global', reasonCode: 'class_portable_procedure' };
+    return globalOutcome('class_portable_procedure');
   }
   if (projectBound) return fallbackToProject('project_bound_environment');
   const conditions = view.normalizeConditions(source.conditions) || [];
@@ -2658,7 +2665,7 @@ export function routeScope(draft, options = {}) {
       requiredConditions: [{ key: 'machine', value: '' }, { key: 'runtime', value: '' }],
     };
   }
-  return { ...base, chosenScope: 'global', reasonCode: 'class_environment_fact' };
+  return globalOutcome('class_environment_fact');
 }
 
 function locateInLayers(projectScope, id) {

package/test/contract.test.mjs

@@ -377,10 +377,15 @@ assert.equal((await call('/lite-memory/unknown', { cwd })).status, 404);
 assert.equal((await call('/lite-memory/keep', {}, { method: 'GET' })).status, 405);
 
 // ── global layer ─────────────────────────────────────────────────────────────
-const global = await exec('memory_save', { title: '回复用中文', summary: '用户要求回复用中文', scope: 'global' });
-assert.equal(global.scope, 'global');
-assert.equal(global.scopeNote, undefined, '正常落全局不该带降级说明');
-assert.match(render('memory_save', {}, global), /^memory · saved \[global\] "回复用中文"$/);
+const proposedGlobal = await exec('memory_save', { title: '回复语言模型提案', summary: '模型建议回复语言用中文', scope: 'global' });
+assert.equal(proposedGlobal.scope, 'project', '模型自填 scope 只是提案，默认落项目层');
+assert.match(proposedGlobal.scopeNote, /模型归类只是提案/, '降级要能解释');
+const global = store.saveEntry(store.globalScope(), {
+  title: '回复用中文', summary: '用户要求回复用中文', body: '回复默认用中文', scopeConfirmed: true,
+});
+assert.ok(global.record, '人明确要全局时才落全局层');
+assert.equal(global.chosenScope, 'global');
+assert.equal(exec === null, false);
 
 // 显式写 global 也不再被悄无声息地改层：本机痕迹和项目事实各有一条能解释的降级。
 const machineGlobal = await exec('memory_save', {
@@ -402,7 +407,7 @@ const factGlobal = await exec('memory_save', {
 assert.equal(factGlobal.scope, 'project');
 assert.match(factGlobal.scopeNote, /按项目事实留在项目层/);
 const globalSearch = await exec('memory_search', { query: '回复用中文' });
-assert.equal(globalSearch.count, 1);
+assert.ok(globalSearch.count >= 1, '全局层条目能被搜到');
 assert.match(render('memory_search', {}, globalSearch), /\[global\] 「/);
 assert.equal(typeof globalThis.__liteMemoryStats, 'function');
 const stats = globalThis.__liteMemoryStats(cwd);
@@ -1050,10 +1055,9 @@ await defs.get('memory_save').execute(
   { title: '发布窗口', summary: '只在周四晚上发版', body: '周四晚上再发版。', when: '周四晚上' },
   { agent: ovAgent },
 );
-await defs.get('memory_save').execute(
-  { title: '观察全局', summary: '跨项目通用说明', body: '全局正文。', scope: 'global' },
-  { agent: ovAgent },
-);
+store.saveEntry(store.globalScope(), {
+  title: '观察全局', summary: '跨项目通用说明', body: '全局正文。', scopeConfirmed: true,
+});
 const ovOther = await defs.get('memory_save').execute(
   { title: '别的项目', summary: '只在别的项目里', body: '另一层的正文。', tags: ['别的'] },
   { agent: { id: 'session-overview-other', cwd: ovOtherCwd, session: { id: 'session-overview-other', header: { cwd: ovOtherCwd } } } },
@@ -1215,7 +1219,7 @@ const cfCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-contract-confli
 sessionCwds.set('session-conflict-panel', cfCwd);
 sessionCwds.set('session-conflict-other', fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-contract-conflict-other-')));
 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 });
+store.saveEntry(store.globalScope(), { title: '发布窗口', summary: '只在周四晚上发版', body: '周四晚上再发版。', scopeConfirmed: true });
 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, '没确认前不落库');
@@ -1276,7 +1280,7 @@ const cfgCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-contract-confl
 sessionCwds.set('session-conflict-global', cfgCwd);
 const cfgAgent = { id: 'session-conflict-global', cwd: cfgCwd, session: { id: 'session-conflict-global', header: { cwd: cfgCwd } } };
 await defs.get('memory_save').execute({ title: '命名规则', summary: '项目里用短横线', body: '短横线。' }, { agent: cfgAgent });
-const cfgSave = await defs.get('memory_save').execute({ title: '命名规则', summary: '所有项目用下划线', body: '下划线。', scope: 'global' }, { agent: cfgAgent });
+const cfgSave = store.saveEntry(store.scopeOf(cfgCwd), { title: '命名规则', summary: '所有项目用下划线', body: '下划线。', scope: 'global', scopeConfirmed: true });
 assert.equal(cfgSave.needsResolution, true);
 const cfgView = await call('/lite-memory/overview', { sessionId: 'session-conflict-global', scopeKey: 'global' });
 assert.equal(cfgView.body.selected.conflicts.length, 1, '全局层也要有这条待裁决');

package/test/crossing.test.mjs

@@ -44,12 +44,18 @@ const idsOfPrev = (scope) => {
 };
 
 // ── S03 范围路由 ────────────────────────────────────────────────────────────
-await test('S03 个人偏好没有显式范围就进全局层，项目层不落副本', () => {
+await test('S03 个人偏好：模型自动归类留项目层，人明确要全局才落全局', () => {
   const scope = fresh('route-pref');
-  const saved = saveEntry(scope, { title: '回答用中文', summary: '回复语言偏好', body: '中文、简短', memoryClass: 'personal_preference' });
+  const automatic = saveEntry(scope, { title: '回答用中文（自动）', summary: '回复语言偏好', body: '中文、简短（自动）', memoryClass: 'personal_preference' });
+  assert.equal(automatic.chosenScope, 'project', '模型归类只是提案，不能自己跨项目');
+  assert.equal(automatic.reasonCode, 'model_class_project');
+  assert.equal(idsOf(scope).length, 1);
+  const saved = saveEntry(scope, {
+    title: '回答用中文', summary: '回复语言偏好', body: '中文、简短',
+    memoryClass: 'personal_preference', scopeConfirmed: true, resolution: 'distinct',
+  });
   assert.equal(saved.chosenScope, 'global');
   assert.equal(saved.reasonCode, 'class_personal_preference');
-  assert.equal(idsOf(scope).length, 0);
   assert.equal(stateOf(globalScope()).entries.filter((row) => row.current.title === '回答用中文').length, 1);
 });
 
@@ -100,7 +106,7 @@ await test('S03 设备事实没给设备条件就返回 needsScope，不落盘',
 await test('S03 设备事实带条件进全局层且是条件适用', () => {
   const scope = fresh('route-env-ok');
   const saved = saveEntry(scope, {
-    title: '本机 Node', summary: '本机 Node 版本', body: 'v24', memoryClass: 'environment_fact',
+    title: '本机 Node', summary: '本机 Node 版本', body: 'v24', memoryClass: 'environment_fact', scopeConfirmed: true,
     conditions: [{ key: 'machine', value: 'mac-mini' }],
   });
   assert.equal(saved.chosenScope, 'global');

package/test/layer-read.test.mjs

@@ -1,4 +1,4 @@
-import { fileURLToPath } from 'node:url'
+import { fileURLToPath } from 'node:url'
 import assert from 'node:assert/strict';
 import fs from 'node:fs';
 import { spawn } from 'node:child_process';
@@ -172,7 +172,7 @@ const globalDraft = store.saveEntry(store.scopeOf(projectB), {
   title: 'npm 发布凭据取用与发布后验版',
   summary: 'npm 发布用 account regrevia，发布后轮询 dist-tags 验版',
   body: '发布用 regrevia 身份；发完轮询 dist-tags.latest 判上线。',
-  memoryClass: 'personal_preference',
+  memoryClass: 'personal_preference', scope: 'global', scopeConfirmed: true,
 });
 assert.equal(globalDraft.chosenScope, 'global');
 const near = await exec('memory_save', {

package/test/learning.test.mjs

@@ -1408,4 +1408,43 @@ test('L10 整理器规则先稳定排序再取 8', () => {
   assert.equal(learning.orderOrganizerRules([], { limit: 3 }).length, 0);
 });
 
+/* 收敛：连续纠正同一主题只留一条现行规则；换栏目不适用；关掉再开还是同一现行版。 */
+test('B30 连续纠正同一规则收敛到一条现行版', () => {
+  const scope = fresh('converge');
+  enable(scope);
+  const firstEpisode = seedEpisode(scope, { sessionId: 'conv1', messageIds: ['cm1'] });
+  const firstStart = begin(scope, firstEpisode);
+  assert.equal(commitNew(scope, firstEpisode, firstStart, NEW_CHANGE).ok, true);
+  const id = ruleRows(scope)[0].id;
+  const bodies = ['开头两句内给结论。', '开头一句内给结论。'];
+  bodies.forEach((body, index) => {
+    const episode = seedEpisode(scope, { sessionId: `conv${index + 2}`, messageIds: [`cm${index + 2}`] });
+    const started = begin(scope, episode);
+    assert.equal(started.ok, true, started.reason);
+    const result = commitExisting(scope, episode, started, id, {
+      target: 'r0', feedbackType: 'spec_change', currentText: body, evidence: ['u0'],
+    });
+    assert.equal(result.ok, true, result.reason);
+  });
+  const rows = ruleRows(scope);
+  assert.equal(rows.length, 1, '同一主题不堆多份现行规则');
+  const current = rows[0];
+  assert.equal(current.id, id);
+  assert.match(current.body, /一句内给结论/);
+  assert.ok((current.versions || []).length <= 2, '旧版有上限');
+  const wrongColumn = view.eligibility(current, {
+    projectId: scope.key,
+    context: { seriesId: '字幕' },
+    task: { taskKind: 'video', seriesId: '字幕' },
+  }, 'auto');
+  assert.equal(wrongColumn.ok, false, '换栏目不适用');
+  store.setMemoryEnabled(scope, false, { operationId: 'conv-close' });
+  assert.equal(ruleRows(scope).length, 1, '关闭不清成果');
+  store.setMemoryEnabled(scope, true, { operationId: 'conv-open' });
+  const reopened = ruleOf(scope, id);
+  assert.equal(reopened.body, current.body);
+  assert.equal(reopened.revision, current.revision);
+  assert.equal(reopened.learning.state, current.learning.state);
+});
+
 console.log(`learning.test.mjs: ${passed} passed`);

package/test/recall.test.mjs

@@ -355,8 +355,11 @@ assert.notEqual(bootA.provider.text({ agent: agentB, signal: signalB }), prepare
   const preparedOnly = store.readEntry(scopeUse, only.record.id, { usage: () => false });
   assert.equal(preparedOnly.lastUsed, saved.lastUsed, '准备但没输出时不能改 lastUsed');
   assert.match(runtime.provider.text({ agent, signal: sig }), /交付才算用过的记忆/);
+  const afterProvider = store.readEntry(scopeUse, only.record.id, { usage: () => false });
+  assert.equal(afterProvider.lastUsed, saved.lastUsed, 'provider 输出路径不写使用时间');
+  runtime.handlers.get('agent/turn-stopping').at(-1)({ turn: 'u1', signal: sig });
   const delivered = store.readEntry(scopeUse, only.record.id, { usage: () => false });
-  assert.notEqual(delivered.lastUsed, saved.lastUsed, '真正交付后才记使用');
+  assert.notEqual(delivered.lastUsed, saved.lastUsed, '回合收尾只给真正交付的卡片记使用');
 }
 
 // A12：额度状态与冻结快照分开；清掉快照后重准备不重新分配。
@@ -659,7 +662,11 @@ console.log('recall.test.mjs: ok');
   };
   const second = signal();
   await runtime.preStep({ agent, signal: second, turn: 't2' }, enter(assistantMessage, human('这个怎么弄')));
-  assert.match(runtime.provider.text({ agent, signal: second }), /改完 client\.js 先重载宿主/, '动作侧线索要能召回预防型记忆');
+  const actionText = runtime.provider.text({ agent, signal: second });
+  assert.match(actionText, /改完 client\.js 先重载宿主/, '动作侧线索要能召回预防型记忆');
+  const actionWin = runtime.debug.windowOf(agent);
+  assert.equal(actionWin.autoBudget.totalBytes, Buffer.byteLength(actionText), '最终交付字节与预算账本一致');
+  assert.equal(actionWin.autoBudget.cards, runtime.debug.preparedOf(agent).cards.length, '最终卡片数与预算账本一致');
 }
 
 // A25b：短续句「继续优化收敛」没有自己的检索词，要沿用上一句，不能断在上一轮。
@@ -808,3 +815,163 @@ console.log('recall.test.mjs: ok');
   await runtime.preStep({ agent, signal: second, turn: 't2' }, enter(assistantMessage, human('开始写 PostgreSQL 迁移脚本，先建表')));
   assert.equal(runtime.provider.text({ agent, signal: second }), '', '换任务后不补查旧任务的动作线索');
 }
+
+// A27：npm 原生命令在动作发生前拦一次，把凭据用法直接交给模型；同一轮不重复。
+{
+  const cwdNpm = mkdir('npm-guard');
+  const scopeNpm = store.scopeOf(cwdNpm);
+  store.setRecallMode(scopeNpm, 'adaptive', { operationId: 'npm-guard-mode' });
+  assert.ok(store.upsert(global, {
+    title: 'npm 发布一律走 dsh-npm，ENEEDAUTH 不是缺凭据',
+    summary: '发布走 dsh-npm，不要用 npm whoami 判断凭据',
+    body: '本机 npm 凭据在 Keychain，npm whoami 常报 ENEEDAUTH；发布一律用 dsh-npm publish，不要重新登录。',
+    tags: ['npm', 'dsh-npm', '凭据'],
+    applicability: 'all_in_scope',
+  }).record);
+  const guards = [];
+  const agent = makeAgent('agent-npm-guard', cwdNpm);
+  agent.ctx = {
+    tools: { guard: (fn) => { guards.push(fn); return () => {}; } },
+    effect: (fn) => fn(),
+  };
+  const runtime = boot();
+  runtime.handlers.get('agent/created').at(-1)({ agent });
+  assert.equal(guards.length, 1, '每个 agent 装一个执行前守卫');
+  const sig = signal();
+  await runtime.preStep({ agent, signal: sig, turn: 'npm-1' }, enter(human('帮我发布这个包')));
+  const blocked = guards[0]({ name: 'bash', callId: 'call-npm-1', arguments: { command: 'npm whoami' } });
+  assert.match(String(blocked), /npm 发布一律走 dsh-npm/, '动作发生前给已有记忆正文');
+  assert.match(String(blocked), /Keychain/, '给正文而不是只给标题');
+  assert.equal(guards[0]({ name: 'bash', callId: 'call-npm-2', arguments: { command: 'npm publish' } }), undefined, '同一轮只提示一次');
+  assert.ok(scopeNpm.key, '项目层不受影响');
+}
+
+// A28：零命中的同一轮里，关键动作发生后补查一次；补到后不再重复注入。
+{
+  const cwdActionKey = mkdir('action-key');
+  const scopeActionKey = store.scopeOf(cwdActionKey);
+  store.setRecallMode(scopeActionKey, 'adaptive', { operationId: 'action-key-mode' });
+  const agent = makeAgent('agent-action-key', cwdActionKey);
+  const runtime = boot();
+  const first = signal();
+  await runtime.preStep({ agent, signal: first, turn: 'ak1' }, enter(human('这个怎么弄')));
+  assert.equal(runtime.provider.text({ agent, signal: first }), '', '第一步没有线索时不凭空命中');
+  const assistantMessage = {
+    role: 'assistant',
+    id: 'asst-action-key-1',
+    content: [
+      { type: 'text', text: '我先看一下。' },
+      { type: 'tool-call', name: 'bash', input: { command: 'npm whoami' } },
+    ],
+  };
+  const toolResult = { role: 'user', id: 'tool-action-key-1', source: { kind: 'tool' }, content: [{ type: 'text', text: '已完成' }] };
+  const second = signal();
+  await runtime.preStep({ agent, signal: second, turn: 'ak1' }, enter(assistantMessage, toolResult));
+  const text = runtime.provider.text({ agent, signal: second });
+  assert.match(text, /npm 发布一律走 dsh-npm/, '关键动作让凭据记忆在动作后补进来');
+  assert.equal(runtime.debug.preparedOf(agent).actionRetried, true, '一次请求只补查一次');
+  const actionWin = runtime.debug.windowOf(agent);
+  assert.equal(actionWin.autoBudget.totalBytes, Buffer.byteLength(text), '补查后的最终字节与账本一致');
+  assert.equal(actionWin.autoBudget.cards, runtime.debug.preparedOf(agent).cards.length, '补查后的卡片数与账本一致');
+  const third = signal();
+  await runtime.preStep({ agent, signal: third, turn: 'ak1' }, enter({
+    role: 'assistant',
+    id: 'asst-action-key-2',
+    content: [{ type: 'tool-call', name: 'bash', input: { command: 'npm publish' } }],
+  }, { role: 'user', id: 'tool-action-key-2', source: { kind: 'tool' }, content: [{ type: 'text', text: 'ERR' }] }));
+  assert.equal(runtime.provider.text({ agent, signal: third }), text, '同一请求不重复补查，也不花第二份额度');
+}
+
+// A29：没有「换任务」这类明说，但新话题已经可判定为另一件事时，旧动作线索不能跟过来。
+{
+  const cwdFree = mkdir('free-switch');
+  const scopeFree = store.scopeOf(cwdFree);
+  save(scopeFree, {
+    title: '改完 client.js 先重载宿主',
+    tags: ['client.js', '重载'],
+    summary: 'client.js 改动后必须重载宿主，普通刷新覆盖不到',
+  });
+  save(scopeFree, {
+    title: 'PostgreSQL 连接池先查 max_connections',
+    tags: ['PostgreSQL', '连接池'],
+    summary: '连接池调大前先看 max_connections 和实际占用',
+  });
+  const agent = makeAgent('agent-free-switch', cwdFree);
+  const runtime = boot();
+  const first = signal();
+  await runtime.preStep({ agent, signal: first, turn: 'f1' }, enter(human('前端按钮颜色怎么改')));
+  const assistantMessage = {
+    role: 'assistant',
+    id: 'asst-free-1',
+    content: [
+      { type: 'text', text: '我把 client.js 的样式改好了。' },
+      { type: 'tool-call', name: 'write', input: { file_path: '/tmp/free/client.js' } },
+    ],
+  };
+  const second = signal();
+  await runtime.preStep({ agent, signal: second, turn: 'f2' }, enter(assistantMessage, human('PostgreSQL 连接池满了怎么排查')));
+  const text = runtime.provider.text({ agent, signal: second });
+  assert.match(text, /PostgreSQL 连接池/, '新话题命中自己的记忆');
+  assert.doesNotMatch(text, /改完 client\.js 先重载宿主/, '旧任务线索不能进新任务');
+}
+
+// A30：只读文件、memory 工具输出不算「关键动作」，不能提前花掉一次补查机会。
+{
+  const cwdRead = mkdir('read-action');
+  const scopeRead = store.scopeOf(cwdRead);
+  store.setRecallMode(scopeRead, 'adaptive', { operationId: 'read-action-mode' });
+  save(scopeRead, {
+    title: 'npm 发布一律走 dsh-npm，ENEEDAUTH 不是缺凭据',
+    tags: ['npm', 'dsh-npm', '凭据'],
+    summary: '发布走 dsh-npm，不要用 npm whoami 判断凭据',
+    body: '本机 npm 凭据在 Keychain，npm whoami 常报 ENEEDAUTH；发布一律用 dsh-npm publish，不要重新登录。',
+  });
+  const agent = makeAgent('agent-read-action', cwdRead);
+  const runtime = boot();
+  const first = signal();
+  await runtime.preStep({ agent, signal: first, turn: 'ra1' }, enter(human('这个怎么弄')));
+  assert.equal(runtime.provider.text({ agent, signal: first }), '', '第一步没有线索时不凭空命中');
+  const passiveStep = {
+    role: 'assistant',
+    id: 'asst-read-action-1',
+    content: [
+      { type: 'text', text: '先看文档和已有记录。' },
+      { type: 'tool-call', name: 'read', input: { file_path: '/tmp/lite-memory/README.md' } },
+      { type: 'tool-call', name: 'memory_search', input: { query: 'npm 凭据怎么用' } },
+    ],
+  };
+  const readResult = { role: 'user', id: 'tool-read-action-1', source: { kind: 'tool' }, content: [{ type: 'text', text: '# README 一段普通说明' }] };
+  const second = signal();
+  await runtime.preStep({ agent, signal: second, turn: 'ra1' }, enter(passiveStep, readResult));
+  const heldAfterRead = runtime.debug.preparedOf(agent);
+  assert.equal(heldAfterRead?.actionRetried, false, '只读操作不触发补查');
+  assert.equal(runtime.provider.text({ agent, signal: second }), '', '只读操作后仍保持空快照');
+  const activeStep = {
+    role: 'assistant',
+    id: 'asst-read-action-2',
+    content: [{ type: 'tool-call', name: 'bash', input: { command: 'npm whoami' } }],
+  };
+  const activeResult = { role: 'user', id: 'tool-read-action-2', source: { kind: 'tool' }, content: [{ type: 'text', text: '已完成' }] };
+  const third = signal();
+  await runtime.preStep({ agent, signal: third, turn: 'ra1' }, enter(activeStep, activeResult));
+  const text = runtime.provider.text({ agent, signal: third });
+  assert.match(text, /npm 发布一律走 dsh-npm/, '真正关键动作仍能补查一次');
+  assert.equal(runtime.debug.preparedOf(agent).actionRetried, true);
+  const fourth = signal();
+  await runtime.preStep({ agent, signal: fourth, turn: 'ra1' }, enter({
+    role: 'assistant', id: 'asst-read-action-3', content: [{ type: 'tool-call', name: 'bash', input: { command: 'npm publish' } }],
+  }, { role: 'user', id: 'tool-read-action-3', source: { kind: 'tool' }, content: [{ type: 'text', text: 'ERR' }] }));
+  assert.equal(runtime.provider.text({ agent, signal: fourth }), text, '同一请求不重复补查');
+}
+
+// A31：只有真人明确说「存到全局/所有项目」才算跨项目授权，普通「全局变量」不能放行。
+{
+  const runtime = boot();
+  const asked = runtime.debug.humanAskedGlobal;
+  for (const text of ['以后这条存全局', '记到全局记忆里', '所有项目都按这个来', '以后所有项目都这样做']) {
+    assert.equal(asked(text), true, text);
+  }
+  for (const text of ['把全局变量保存一下', '全局搜索这个函数', '这个项目保存一下', '都改完了保存']) {
+    assert.equal(asked(text), false, text);
+  }
+}

package/test/runtime-context.test.mjs

@@ -166,6 +166,10 @@ const seedRule = (scope, { title, body, summary, conditions = [], learning = { s
   assert.ok(auto.experimentBytes <= 1200, 'experiment bytes over cap');
   assert.ok(auto.cardBytes <= 1200);
   assert.ok(Buffer.byteLength(text) <= 1300, 'rendered text exceeds budget');
+  assert.equal(auto.totalBytes, Buffer.byteLength(text), '最终交付字节与预算账本一致');
+  const held = runtime.debug.preparedOf(agent);
+  assert.equal(auto.cards, (auto.normalCards || 0) + (auto.experimentCards || 0), '卡片账本内部一致');
+  assert.equal(auto.normalCards || 0, (held?.cards || []).length, '普通卡片数与预算账本一致');
   const heads = new Set(text.split('\n').filter((line) => /口播(节奏规范|实验规则)/.test(line)).map((line) => line.trim()));
   assert.ok(heads.size <= 3, `too many cards: ${heads.size}`);
 }

package/test/store.test.mjs

@@ -1101,8 +1101,15 @@ test('归属路由：本机痕迹的「通用流程」留在项目层，干净
     title: '提交前跑测试', summary: '提交前跑测试', body: 'pnpm test',
     memoryClass: 'portable_procedure', evidenceRef: '团队 wiki 的提交流程页',
   }, { project });
-  assert.equal(withEvidence.chosenScope, 'global');
-  assert.equal(withEvidence.reasonCode, 'class_portable_procedure');
+  assert.equal(withEvidence.chosenScope, 'project', '模型自动归类即便有依据也要先留在项目层');
+  assert.equal(withEvidence.reasonCode, 'model_class_project');
+
+  const withEvidenceConfirmed = store.routeScope({
+    title: '提交前跑测试', summary: '提交前跑测试', body: 'pnpm test',
+    memoryClass: 'portable_procedure', evidenceRef: '团队 wiki 的提交流程页',
+  }, { project, humanScope: true });
+  assert.equal(withEvidenceConfirmed.chosenScope, 'global', '人确认后才按归类落全局');
+  assert.equal(withEvidenceConfirmed.reasonCode, 'class_portable_procedure');
 
   const evidencePath = store.routeScope({
     title: '提交前跑测试', summary: '提交前跑测试', body: 'pnpm test',
@@ -1133,8 +1140,17 @@ test('归属路由：本机痕迹的「通用流程」留在项目层，干净
     memoryClass: 'portable_procedure',
     conditions: [{ key: 'machine', value: 'macOS 桌面机' }],
   }, { project });
-  assert.equal(scopedProcedure.chosenScope, 'global', '声明了机器条件的本机流程可进全局层');
-  assert.equal(scopedProcedure.reasonCode, 'machine_scoped_procedure');
+  assert.equal(scopedProcedure.chosenScope, 'project', '模型自动归类不能自己搬去全局层');
+  assert.equal(scopedProcedure.reasonCode, 'model_class_project');
+
+  const scopedProcedureConfirmed = store.routeScope({
+    title: 'npm 操作走 dsh-npm', summary: '本机 npm 命令用包装脚本',
+    body: '本机 npm 一律用 dsh-npm；裸 npm 报 ENEEDAUTH 不是缺凭据',
+    memoryClass: 'portable_procedure',
+    conditions: [{ key: 'machine', value: 'macOS 桌面机' }],
+  }, { project, humanScope: true });
+  assert.equal(scopedProcedureConfirmed.chosenScope, 'global', '人确认后带机器条件的流程可进全局层');
+  assert.equal(scopedProcedureConfirmed.reasonCode, 'machine_scoped_procedure');
 
   const scopedExplicit = store.routeScope({
     title: 'npm 操作走 dsh-npm', summary: '本机 npm 命令用包装脚本',

package/view.js

@@ -755,18 +755,30 @@ export function isExplicitSwitch(text, previousText = '') {
  * 补查只有在「还是同一个任务」时才成立：任务类型或 episode 变了，上一轮的动作历史属于旧任务，
  * 不能拿它给新任务找记忆。类型缺失时保留补查，由调用方的明确换任务判断兜底。
  */
-export function sameRecallTask(previous, current) {
-  if (!previous || !current) return true;
+export function sameRecallTask(previous, current, options = {}) {
+  if (!previous || !current) return false;
+  const continuation = options.continuation === true;
   const kind = (value) => plain(value && value.kind, 40).trim().toLowerCase();
   const episode = (value) => plain(value && value.episodeId, 120).trim();
+  const previousKind = kind(previous);
+  const currentKind = kind(current);
   /** 两侧都认出了任务类型且不同：明确换任务，上一轮的动作历史不再属于当前请求。 */
-  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);
+  if (previousKind && currentKind && previousKind !== currentKind) return false;
+  const previousEpisode = episode(previous);
+  const currentEpisode = episode(current);
+  if (previousEpisode && currentEpisode) {
+    if (previousEpisode === currentEpisode) return true;
+    /** 同一句追问又出现在下一轮：episode 只是平台切的新轮次，任务没有变。 */
+    if (options.sameQuery === true && !previousKind && !currentKind) return true;
+    /** 真正的续说可能新开 episode：只有明确续说才允许跨 episode 沿用上一任务。 */
+    return continuation && (!previousKind || !currentKind || previousKind === currentKind);
   }
-  /** 认不出类型（或只有一侧有）时保留补查：这正是该机制要救的场景。 */
-  return true;
+  /**
+   * 认不出新任务类型时不能默认沿用旧任务：上一轮的动作线索只属于旧任务。
+   * 只有明确续说、或真人原话与上一轮完全相同（同一条追问的下一步）才接着用。
+   */
+  if (!previousKind && !currentKind && options.sameQuery === true) return true;
+  return continuation;
 }
 
 /**
@@ -782,6 +794,31 @@ function isMemoryNoise(name, text) {
   if (name && MEMORY_TOOL.test(String(name))) return true;
   return Boolean(text && MEMORY_TEXT.test(String(text).trimStart()));
 }
+/** 纯读取不会改变下一步动作：读 README / 搜索 / 记忆工具都不消耗唯一补查。 */
+const PASSIVE_TOOL = /^(?:read|glob|grep|list|view|fetch|web_search|web_fetch|job_output|job_list|todo_write|question|ask|memory(?:[_-].*)?)$/i;
+const EFFECTIVE_COMMAND = /(?:^|[\s;&|])(?:npm|npx|pnpm|yarn|git|gh|docker|kubectl|helm|systemctl|launchctl|make|cargo|go|python|node|curl|ssh|rsync|deploy|publish|install|test|build|migrate|reload)(?:[\s;&|]|$)/i;
+/** 动作侧是否真的发生了一个会改变状态的动作；只有这种动作才允许补查一次。 */
+export function hasEffectiveAction(messages) {
+  if (!Array.isArray(messages)) return false;
+  for (const message of messages) {
+    const content = message?.content;
+    if (!Array.isArray(content)) continue;
+    for (const part of content) {
+      if (!part || typeof part !== 'object') continue;
+      if (part.type !== 'tool-call' && part.type !== 'tool_call') continue;
+      const name = String(part.name || '');
+      if (isMemoryNoise(name, '')) continue;
+      if (!PASSIVE_TOOL.test(name)) return true;
+      const input = part.input || part.arguments || part.args;
+      if (!input || typeof input !== 'object') continue;
+      for (const value of Object.values(input)) {
+        if (typeof value === 'string' && EFFECTIVE_COMMAND.test(value)) return true;
+      }
+    }
+  }
+  return false;
+}
+
 export function actionTerms(messages, options = {}) {
   if (!Array.isArray(messages)) return '';
   const limit = Number.isInteger(options.limit) && options.limit > 0 ? options.limit : 16;
@@ -804,8 +841,12 @@ export function actionTerms(messages, options = {}) {
         if (typeof part.name === 'string') push(part.name);
         const input = part.input || part.arguments || part.args;
         if (input && typeof input === 'object') {
-          for (const value of Object.values(input)) {
-            if (typeof value === 'string' && /[./_-]/.test(value)) {
+          for (const [key, value] of Object.entries(input)) {
+            if (typeof value !== 'string' || value.length > 300) continue;
+            /** 命令参数要按空格切词，否则 `npm whoami` 只剩工具名 bash，动作线索就丢了。 */
+            const commandish = /^(?:command|cmd|script|args?|input|shell)$/i.test(key)
+              || EFFECTIVE_COMMAND.test(value);
+            if (commandish || /[./_-]/.test(value)) {
               for (const piece of value.split(/[^\p{L}\p{N}_.-]+/u)) push(piece);
             }
           }