dsh-lite-memory 0.18.33 → 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.34.md

@@ -0,0 +1,11 @@
+# 0.18.34：学到的东西能落下来，续句和审批算同一件事
+
+- 首次在空项目里学到的规则不再因为“任务范围不在本项目”整条作废：收集时的任务范围被信任并原样保留，模型自己编的范围仍要校验。
+- 条件按 key 唯一合并：同一个条件键两个值明确判冲突，不再先写成 active、再发现不适用；收集时的阶段只作上下文，不混进适用范围。
+- 待裁决另存不再丢 `selection`、`triggers`、`links`：草稿审阅看到的就是最终会写下的内容。
+- 任务身份独立于召回快照：正常轮次结束后的“继续”仍接上一次任务；上一轮零召回时，“继续”也不会把更早的记忆带回来。
+- 历史线索以任务起始消息为边界：只补本任务内发生的动作，不把上一个任务的工具调用当线索。
+- 工具动作后最多补查一次，且和首次召回共用一个请求额度。
+- 真正交付给模型的卡片才更新 `lastUsed`：准备阶段被丢弃、超出预算、已过期的卡片不再算“用过”。
+- 生命周期先于主题裁决：过期/被取代的条目不再参与同主题分组，不能把现行条目标成冲突。
+- 审批原子化：待裁决的版本检查、另存、出队在同一临界区；旧面板不能批准新草稿，也不能删掉刚更新的待裁决。

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

@@ -1157,6 +1157,8 @@ export function apply(ctx, config) {
   const prepared = new WeakMap();
   /** 最近一次请求的任务身份：本轮没注入任何内容时 prepared 会清掉，补查仍需要知道上一轮任务。 */
   const lastTask = new Map();
+  /** 任务本身也要独立于 prepared：轮次收尾只清投影，不把「刚才在做什么」一起清掉。 */
+  const recallTasks = new Map();
   /** turn-stopping 只回 signal，不带头 agent；这里记 signal → agent 供收尾清理。 */
   const signalAgents = new Map();
   const generations = new WeakMap();
@@ -1174,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;
@@ -1299,6 +1311,8 @@ export function apply(ctx, config) {
       try { index = loadIndex(source); } catch { continue; }
       for (const item of index.entries) {
         if (!item || !item.title || item.status === 'archived') continue;
+        /** 生命周期先于主题裁决：过期/被取代的条目不再参与分组，不能把现行条目标成冲突。 */
+        if (view.lifecycleStatusOf(item)) continue;
         /** 实验来源只走任务绑定后的专用读取，不混进普通自动召回。 */
         if (item.origin === 'project_evolution') continue;
         if (seen.has(item.id)) continue;
@@ -1359,7 +1373,7 @@ export function apply(ctx, config) {
       lines.push(line);
       cards.push({ id: card.id, revision, scope: card.scope, title: card.title });
       /** 卡片行与到期时间一起留到最后输出：中间隔了系统提示组装，不能拿投影时的判断当现在。 */
-      linesMeta.push({ line, validUntil: row.record.validUntil || '' });
+      linesMeta.push({ id: card.id, line, validUntil: row.record.validUntil || '' });
     }
     const finalText = `${RECALL_HEADER}\n${lines.join('\n')}`;
     if (auto) {
@@ -1916,6 +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')}` : '';
+        /** 真正交付的卡片才记使用；记账推迟到回合收尾，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, {
@@ -2018,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();
@@ -2091,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) {
@@ -2611,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);
@@ -2658,7 +2743,9 @@ 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;
 
       if (fresh.length === 0) {
         /** 工具续步：内容冻结，只把快照绑到本步的 signal；盘上版本变了才重投影。 */
@@ -2701,6 +2788,39 @@ export function apply(ctx, config) {
             }
           }
         }
+        /**
+         * 工具续步里没有新的真人原话，但刚执行的动作本身就是线索。
+         * 只补一次、共用一个请求额度，补到的卡片追加到已发布快照，超出仍由预算挡。
+         */
+        const stepMessages = Array.isArray(decision.messages) ? decision.messages : [];
+        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 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;
+            }
+          }
+        }
         return decision;
       }
 
@@ -2715,10 +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 = sameSession && previous?.query
-        && (view.isContinuationQuery(said) || view.isEllipticalContinuation(said))
-        ? previous.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;
 
@@ -2766,12 +2886,27 @@ export function apply(ctx, config) {
         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.isExplicitSwitch(said, previous && previous.query ? previous.query : '')
-        && view.sameRecallTask(previousTask, currentTask);
+      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, { 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(),
+      });
       while (lastTask.size > 64) lastTask.delete(lastTask.keys().next().value);
+      while (recallTasks.size > 64) recallTasks.delete(recallTasks.keys().next().value);
       /**
        * 预防型记忆约束的是「下一步动作」，词面常写在上一轮助手的话和工具调用里，用户这句话反而没提。
        * 续句或没有具体动作的短问句，直接把最近的动作线索并进同一份查询：只查一次，不额外占预算。
@@ -2784,19 +2919,27 @@ export function apply(ctx, config) {
         }
         return messages;
       })();
-      const trail = sameTask ? view.actionTerms(humanTail, { limit: 12 }).slice(0, 240) : '';
+      /** 只拿当前任务开始之后的消息，旧任务的工具痕迹不能混进新任务。 */
+      const taskStart = taskStartMessageId
+        ? decision.messages.findIndex((message) => String(message?.id ?? '') === taskStartMessageId) : -1;
+      const tailMessages = sameTask && taskStart >= 0 ? decision.messages.slice(taskStart + 1) : humanTail;
+      const trail = sameTask ? view.actionTerms(tailMessages, { limit: 12 }).slice(0, 240) : '';
       const trailInQuery = Boolean(trail) && (Boolean(carried) || !view.hasConcreteAction(said));
       if (trailInQuery) {
         query = `${query} ${trail}`.trim().slice(0, RECALL_QUERY_CHARS);
         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;
         }
       }
@@ -2835,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 = {
@@ -2854,16 +2995,23 @@ export function apply(ctx, config) {
         task: currentTask,
         scope,
         query,
+        saidOnly: said,
         sessionId,
         turn,
         signal,
         fingerprint,
         controlEpoch,
         evolutionEpoch,
+        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);
-      if (snapshot && snapshot.ids && snapshot.ids.length) markUsed(scope, snapshot.ids);
+      /** 真正输出给模型时才算使用；准备阶段被丢弃/中止的快照不能改 lastUsed。 */
       payloadBytes.set(sessionId, win.bytes);
       while (payloadBytes.size > 64) payloadBytes.delete(payloadBytes.keys().next().value);
       if (signal) signalAgents.set(signal, agent);
@@ -3125,7 +3273,7 @@ export function apply(ctx, config) {
     clearPrepared(agent);
     windows.delete(agentKey(agent));
     const sessionId = String(agent?.session?.id ?? '');
-    if (sessionId) seenHumans.delete(sessionId);
+    if (sessionId) { seenHumans.delete(sessionId); recallTasks.delete(sessionId); }
   });
 
   /**
@@ -3169,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

@@ -370,9 +370,11 @@ export function pendingChangeFrom(feedback = {}) {
    */
   const expected = feedback.expectedTarget && typeof feedback.expectedTarget === 'object' ? feedback.expectedTarget : null;
   const taskKind = String(feedback.cue?.taskKind || expected?.taskKind || '').trim();
-  const expectedConditions = ['taskKind', 'seriesId', 'phase']
+  /** 采集阶段是「在哪儿学到」的证据，不是长期适用范围：只把任务身份与系列带进条件。 */
+  const collectedConditions = ['taskKind', 'seriesId']
     .filter((key) => String(expected?.[key] || '').trim())
     .map((key) => ({ key, value: String(expected[key]).trim() }));
+  const expectedConditions = collectedConditions;
   /**
    * 兜底不重新推导作用域：候选收集时已经固定 expectedTarget 就照抄（只能沿用或收窄），
    * 没有 expectedTarget 的旧调用才退回原句判断。
@@ -616,26 +618,33 @@ 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;
-  const expectedConditions = ['taskKind', 'seriesId', 'phase']
+  /** 采集阶段是「在哪儿学到」的证据，不是长期适用范围：只把任务身份与系列带进条件。 */
+  const collectedConditions = ['taskKind', 'seriesId']
     .filter((key) => String(expected?.[key] || '').trim())
     .map((key) => ({ key, value: String(expected[key]).trim() }));
+  const expectedConditions = collectedConditions;
   /** 作品里学到的规范必须带上当时的任务范围：模型想写成全项目时收窄成条件规则，而不是丢掉这条反馈。 */
   const narrowToEpisode = target === 'new' && expected?.scope === 'episode' && expectedConditions.length > 0;
   if (narrowToEpisode) {
     if (applicability === undefined || applicability === 'all_in_scope') applicability = 'conditional';
     const merged = conditions !== undefined ? [...conditions] : [];
     for (const row of expectedConditions) {
-      if (merged.some((item) => item.key === row.key && item.value === row.value)) continue;
-      if (!conditionValueAllowed(row, { ranges, existing })) return { ok: false, reason: '收集时的任务范围不在本项目里' };
+      const sameKey = merged.find((item) => item.key === row.key);
+      if (sameKey) {
+        if (sameKey.value !== row.value) return { ok: false, reason: '条件与收集时的任务范围冲突' };
+        continue;
+      }
+      /** 采集条件来自已绑定的真实任务，不要求它先出现在历史规则里；模型新提的条件仍走范围校验。 */
       merged.push(row);
     }
+    const keys = new Set();
+    for (const row of merged) {
+      if (keys.has(row.key)) return { ok: false, reason: '同一条件键给了两个值' };
+      keys.add(row.key);
+    }
     conditions = merged;
   }
   const expectedApplicability = expected
@@ -650,6 +659,23 @@ export function validateChange(change, { refs, rules, ranges, expectedTarget } =
     return { ok: false, reason: '作品规则不能抬成全项目' };
   }
   const effectiveConditions = conditions !== undefined ? conditions : normalizeConditions(existing?.conditions);
+  /** 条件键必须唯一：phase=script 与 phase=brief 同时存在，规则会显示生效却永远不适用。 */
+  const conditionKeys = new Set();
+  for (const row of effectiveConditions) {
+    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.33",
+  "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",