dsh-lite-memory 0.18.33 → 0.18.35

package/test/recall.test.mjs

@@ -94,7 +94,10 @@ const patchState = (scope, id, patch) => {
   const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
   const entry = raw.payload.entries.find((row) => row.id === id);
   assert.ok(entry, `state 里没有 ${id}`);
-  Object.assign(entry, patch);
+  for (const [key, value] of Object.entries(patch)) {
+    entry[key] = value && typeof value === 'object' && !Array.isArray(value)
+      ? { ...(entry[key] || {}), ...value } : value;
+  }
   raw.checksum = `sha256:${crypto.createHash('sha256').update(JSON.stringify(raw.payload)).digest('hex')}`;
   fs.writeFileSync(file, `${JSON.stringify(raw, null, 2)}\n`);
 };
@@ -337,6 +340,28 @@ assert.notEqual(bootA.provider.text({ agent: agentB, signal: signalB }), prepare
   assert.equal(bootA.debug.windowOf(agentReads).reads, 8);
 }
 
+// A11b：准备阶段不算使用；只有真正交付给模型的卡片才更新 lastUsed。
+{
+  const cwdUse = mkdir('delivered');
+  const scopeUse = store.scopeOf(cwdUse);
+  const only = save(scopeUse, { title: '交付才算用过的记忆', tags: ['交付测试'], summary: '只看不交付不该改变使用时间' });
+  const agent = makeAgent('agent-delivered', cwdUse);
+  const runtime = boot();
+  const sig = signal();
+  patchState(scopeUse, only.record.id, { maintenance: { lastUsed: '2020-01-01T00:00:00.000Z' } });
+  const saved = store.readEntry(scopeUse, only.record.id, { usage: () => false });
+  assert.equal(saved.lastUsed, '2020-01-01T00:00:00.000Z', 'patch 生效');
+  await runtime.preStep({ agent, signal: sig, turn: 'u1' }, enter(human('交付测试怎么做')));
+  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, '回合收尾只给真正交付的卡片记使用');
+}
+
 // A12：额度状态与冻结快照分开；清掉快照后重准备不重新分配。
 {
   const agent = makeAgent('agent-preserve', cwdA);
@@ -353,6 +378,58 @@ assert.notEqual(bootA.provider.text({ agent: agentB, signal: signalB }), prepare
   assert.equal(win.bytes, used, 'same window does not re-allocate for already provided cards');
 }
 
+// A13b：轮次收尾清的是投影，不是任务；下一句「继续」仍要接上上一轮的原话。
+{
+  const agent = makeAgent('agent-after-turn', cwdA);
+  const first = signal();
+  await bootA.preStep({ agent, signal: first, turn: 'n1' }, enter(human('插件改完怎么让它生效？')));
+  assert.ok(bootA.provider.text({ agent, signal: first }));
+  bootA.handlers.get('agent/turn-stopping').at(-1)({ turn: 'n1', signal: first });
+  assert.equal(bootA.provider.text({ agent, signal: first }), '');
+  const second = signal();
+  await bootA.preStep({ agent, signal: second, turn: 'n2' }, enter(human('继续')));
+  assert.match(bootA.provider.text({ agent, signal: second }), /插件改完先试热刷新/, '收尾后「继续」仍属原任务');
+}
+
+// A13c：新任务零召回也照样记下新查询；再说「继续」不能把旧任务的记忆带回来。
+{
+  const agent = makeAgent('agent-zero-task', cwdA);
+  const first = signal();
+  await bootA.preStep({ agent, signal: first, turn: 'z1' }, enter(human('插件改完怎么让它生效？')));
+  bootA.handlers.get('agent/turn-stopping').at(-1)({ turn: 'z1', signal: first });
+  const second = signal();
+  await bootA.preStep({ agent, signal: second, turn: 'z2' }, enter(human('帮我算一下 17 乘以 23 等于多少')));
+  bootA.handlers.get('agent/turn-stopping').at(-1)({ turn: 'z2', signal: second });
+  const third = signal();
+  await bootA.preStep({ agent, signal: third, turn: 'z3' }, enter(human('继续')));
+  assert.doesNotMatch(bootA.provider.text({ agent, signal: third }), /插件改完先试热刷新/, '零召回的新任务不能被旧任务续上');
+}
+
+// A13d：工具续步没有新的真人原话，刚执行的动作可以换来一次有界补查。
+{
+  const cwdStep = mkdir('tool-step');
+  const scopeStep = store.scopeOf(cwdStep);
+  save(scopeStep, { title: '记忆插件先看状态再改', tags: ['记忆插件', '排查'], summary: '先看状态文件再动代码' });
+  save(scopeStep, { title: '改完 client.js 先重载宿主', tags: ['client.js', '重载'], summary: '普通刷新覆盖不到 client.js' });
+  const agent = makeAgent('agent-tool-step', cwdStep);
+  const runtime = boot();
+  const said = human('记忆插件怎么排查');
+  const first = signal();
+  await runtime.preStep({ agent, signal: first, turn: 's1' }, enter(said));
+  assert.match(runtime.provider.text({ agent, signal: first }), /记忆插件先看状态再改/);
+  const toolStep = {
+    role: 'assistant',
+    id: 'asst-tool-step',
+    content: [
+      { type: 'text', text: '我把改动写进文件了。' },
+      { type: 'tool-call', name: 'write', input: { file_path: '/tmp/step/client.js' } },
+    ],
+  };
+  const second = signal();
+  await runtime.preStep({ agent, signal: second, turn: 's1' }, enter(said, toolStep));
+  assert.match(runtime.provider.text({ agent, signal: second }), /改完 client\.js 先重载宿主/, '工具动作后补查一次');
+}
+
 // A14：上一轮注入过的文字不会被当成这一轮的来源；只有合成消息的新 turn 不继承。
 {
   const agent = makeAgent('agent-stale-section', cwdA);
@@ -585,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：短续句「继续优化收敛」没有自己的检索词，要沿用上一句，不能断在上一轮。
@@ -734,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

@@ -741,7 +741,7 @@ export function hasConcreteAction(text) {
  * 明确换任务：句子里有换做/改用/先别管这类词，或点了一个上一句没有的英文对象。
  * 认不出任务类型时，上一轮的动作线索只能靠这条规则隔开，不能因为类型为空就默认同任务。
  */
-const SWITCH_MARK = /(换成|换个|换一个|改用|改做|改为|改到|转到|先不管|别管|先别|不弄这个|不看这个|另一个|新任务|去做|开始做)/u;
+const SWITCH_MARK = /(换成|换个|换一个|改用|改做|改为|改到|转到|先不管|别管|先别|不弄这个|不看这个|另一个|新任务|换任务|先结束|结束刚才|结束上一个|去做|开始做)/u;
 export function isExplicitSwitch(text, previousText = '') {
   const current = plain(text, 400);
   if (!current) return false;
@@ -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);
             }
           }