dsh-lite-memory 0.18.30 → 0.18.31

package/anchor.js

@@ -10,6 +10,8 @@ export const TASK_LIMITS = { sessions: 8, episodes: 12, sourceMessages: 8, idleM
 
 const SWITCH_WORDS = /(改做|改为|改到|改成|换个|换一个|换成|转到|现在做|接下来做|新做|另做|开始做|去做)/;
 const CONTINUE_WORDS = /(继续|再做一期|下一期|再来一期|再开一期|续一集|再拍一期)/;
+/** 短续句只由通用动作词组成、没点名新对象：仍属于当前任务，不能当换任务。 */
+const ELLIPTICAL_CONTINUE = /^(?:继续|接着|再接着|往下)[，,、\s]*(?:把|将|再)?(?:优化|收敛|调整|完善|打磨|推进|处理|改|修|做|写|整理|检查|排查|测试|发布|跑|看看|看下|弄|试|收尾|统一|对齐|细化|补|过一遍|走一遍|一下|下)+[。.!！?？…]*$/u;
 const REVISE_WORDS = /(再改一下|改一版|再改改|调整一下|这版再|继续改)/;
 const THANKS_WORDS = /^(谢谢|多谢|谢了|辛苦了|thanks|thank\s*you)[!！。.～~\s]*$/i;
 const REFERENCE_WORDS = /(这个|这条|这次|上次|之前|刚才|上面|前面|它|这里|继续|接着|还是|同样|再改)/;
@@ -71,6 +73,7 @@ function taskTerms(value) {
 export function looksLikeNewTask(query, previousText) {
   const current = text(query, 200);
   if (!current || isThanks(current)) return false;
+  if (ELLIPTICAL_CONTINUE.test(current)) return false;
   const next = taskTerms(current);
   const previous = taskTerms(previousText);
   const cue = isContinuation(current) || REFERENCE_WORDS.test(current);

package/docs/RELEASE-0.18.31.md

@@ -0,0 +1,6 @@
+# 0.18.31
+
+- 「继续优化收敛」这类短续句不再当成换任务：句首是续说标记、其余只由通用动作词组成时，沿用当前任务与上一句原话；带新对象的「继续优化数据库连接池」仍然换任务。
+- 续句或没有具体动作的短问句，把上一轮助手的话和工具名并进同一份查询，只查一次；通用卡片不再抢先占满名额、挡住真正相关的动作线索。
+- 明确换任务（换做/改用/先别管，或点了一个上一句没有的英文对象）时不并旧动作线索，任务类型认不出也不会把旧任务记忆带进新任务。
+- 回归覆盖：短续句承接下来回、换到数据库后继续说「继续」只承接数据库、未知类型换任务不带旧工具线索、通用卡片存在时动作线索仍能命中。

package/index.js

@@ -2714,8 +2714,10 @@ export function apply(ctx, config) {
       /** 工具模式也要记下本轮真人原话：只用于核对绑定，不自动注入。 */
       const said = view.newestUserQuery(fresh).slice(0, RECALL_QUERY_CHARS);
       /** 「继续」这类续说没有检索词：带上同会话上一轮原话，否则这一轮必然召回为空。 */
-      const carried = sameSession && previous?.query && view.isContinuationQuery(said) ? previous.query : '';
-      const query = (carried ? `${said} ${carried}` : said).trim().slice(0, RECALL_QUERY_CHARS);
+      const carried = sameSession && previous?.query
+        && (view.isContinuationQuery(said) || view.isEllipticalContinuation(said))
+        ? previous.query : '';
+      let query = (carried ? `${said} ${carried}` : said).trim().slice(0, RECALL_QUERY_CHARS);
       if (win && query) win.query = query;
 
       if (!query) {
@@ -2757,37 +2759,43 @@ export function apply(ctx, config) {
       const remembered = runtime && runtime.enabled
         ? rememberFeedback(scope, sessionId, fresh, runtime.held, turn)
         : null;
-      let snapshot = projectRecall(scope, query, recalledContext, win, runtime ? runtime.held : null);
-      /**
-       * 预防型记忆约束的是「下一步动作」，词面常写在上一轮助手的话和工具调用里，用户这句话反而没提。
-       * 第一次检索一张卡都没有时，用最近的实词/工具名补一次有界查询，预算仍是同一份。
-       */
       const currentTask = {
         kind: (runtime && runtime.held && runtime.held.task && runtime.held.task.kind) || '',
         episodeId: (runtime && runtime.held && runtime.held.episodeId) || '',
       };
       const rememberedTask = lastTask.get(sessionId) || null;
       const previousTask = previous && previous.task ? previous.task : rememberedTask;
-      const sameTask = Boolean(sameSession || rememberedTask) && view.sameRecallTask(previousTask, currentTask);
+      const sameTask = Boolean(sameSession || rememberedTask)
+        && !view.isExplicitSwitch(said, previous && previous.query ? previous.query : '')
+        && view.sameRecallTask(previousTask, currentTask);
       lastTask.set(sessionId, currentTask);
       while (lastTask.size > 64) lastTask.delete(lastTask.keys().next().value);
-      if (!snapshot.cards.length && !carried && sameTask) {
-        const humanTail = (() => {
-          const messages = Array.isArray(decision.messages) ? decision.messages : [];
-          for (let i = messages.length - 1; i >= 0; i -= 1) {
-            if (messages[i]?.source?.kind === 'user') return messages.slice(0, i);
-          }
-          return messages;
-        })();
-        const trail = view.actionTerms(humanTail, { limit: 12 }).slice(0, 240);
-        if (trail) {
-          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;
-            if (win) win.query = actionQuery;
-          }
+      /**
+       * 预防型记忆约束的是「下一步动作」，词面常写在上一轮助手的话和工具调用里，用户这句话反而没提。
+       * 续句或没有具体动作的短问句，直接把最近的动作线索并进同一份查询：只查一次，不额外占预算。
+       * 明确换任务时不并，旧任务的动作历史不能给新任务找记忆。
+       */
+      const humanTail = (() => {
+        const messages = Array.isArray(decision.messages) ? decision.messages : [];
+        for (let i = messages.length - 1; i >= 0; i -= 1) {
+          if (messages[i]?.source?.kind === 'user') return messages.slice(0, i);
+        }
+        return messages;
+      })();
+      const trail = sameTask ? view.actionTerms(humanTail, { 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);
+      /** 并了动作线索仍一张卡都没有，才补一次有界查询；补到了才替换，不拿空结果盖掉原判断。 */
+      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;
+          if (win) win.query = actionQuery;
         }
       }
       /** 实验规则最后才取预算：普通卡片先占，弱相关实验不能把强相关项目规则挤出去。 */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-lite-memory",
-  "version": "0.18.30",
+  "version": "0.18.31",
   "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/test/anchor.test.mjs

@@ -344,6 +344,35 @@ test('R22 真正的续改保留原任务范围', () => {
   assert.equal(next.episode.previousEpisodeId, tasks.sessions['sess-switch'].episodeId);
 });
 
+test('R22b 短续句「继续优化收敛」不点名新对象，仍算续作', () => {
+  const tasks = activeVideoSession();
+  const next = anchor.routeTask(tasks, {
+    sessionId: 'sess-switch',
+    batchKey: 'rb_ellipse',
+    messageIds: ['m2'],
+    query: '继续优化收敛',
+    registeredSeries: ['口播'],
+    now: 2000,
+  });
+  assert.equal(next.decision.kind, 'continuation');
+  assert.equal(next.anchor.seriesId, '口播');
+  assert.equal(next.episode.previousEpisodeId, tasks.sessions['sess-switch'].episodeId);
+});
+
+test('R22c 短续句点名新对象时仍然换任务', () => {
+  const tasks = activeVideoSession();
+  const next = anchor.routeTask(tasks, {
+    sessionId: 'sess-switch',
+    batchKey: 'rb_ellipse_obj',
+    messageIds: ['m2'],
+    query: '继续优化数据库连接池',
+    registeredSeries: ['口播'],
+    now: 2000,
+  });
+  assert.equal(next.decision.kind, 'unbound');
+  assert.equal(next.decision.reason, 'new_task');
+});
+
 test('R23 只指代旧稿的局部修改不被当成换任务', () => {
   const tasks = activeVideoSession();
   const next = anchor.routeTask(tasks, {

package/test/lexical.test.mjs

@@ -51,5 +51,18 @@ for (const text of ['继续', '继续。', '然后呢？', '接着', 'go on', 'c
 for (const text of ['继续优化轻量化记忆与前端展示逻辑', '然后发布', '样式', 'next steps for release']) {
   assert.equal(view.isContinuationQuery(text), false, text);
 }
+/* 短续句只由通用动作词组成、没点名新对象：沿用上一句，但不把带对象的长句也算进来。 */
+for (const text of ['继续优化收敛', '继续打磨', '接着改', '继续看看']) {
+  assert.equal(view.isEllipticalContinuation(text), true, text);
+}
+for (const text of ['继续优化轻量化记忆与前端展示逻辑', '继续优化数据库连接池', '接着改数据库', '然后发布']) {
+  assert.equal(view.isEllipticalContinuation(text), false, text);
+}
+
+/* 明确换任务：换做/先别管，或点了一个上一句没有的英文对象。 */
+assert.equal(view.isExplicitSwitch('改用 PostgreSQL 先看连接池', '把前端按钮颜色调一下'), true);
+assert.equal(view.isExplicitSwitch('先别管这个了，帮我看看 nginx 502', '把前端按钮颜色调一下'), true);
+assert.equal(view.isExplicitSwitch('继续优化收敛', '把前端按钮颜色调一下'), false);
+assert.equal(view.isExplicitSwitch('继续优化数据库连接池', '把前端按钮颜色调一下'), false);
 
 console.log('lexical.test.mjs: all passed');

package/test/recall.test.mjs

@@ -588,6 +588,127 @@ console.log('recall.test.mjs: ok');
   assert.match(runtime.provider.text({ agent, signal: second }), /改完 client\.js 先重载宿主/, '动作侧线索要能召回预防型记忆');
 }
 
+// A25b：短续句「继续优化收敛」没有自己的检索词，要沿用上一句，不能断在上一轮。
+{
+  const cwdEllipse = mkdir('ellipse');
+  const scopeEllipse = store.scopeOf(cwdEllipse);
+  save(scopeEllipse, {
+    title: '轻量化记忆与前端展示逻辑先定召回顺序',
+    tags: ['轻量化记忆', '前端展示逻辑'],
+    summary: '先定召回顺序，再谈展示；触发机制跟着任务走',
+  });
+  const agent = makeAgent('agent-ellipse', cwdEllipse);
+  const runtime = boot();
+  const first = signal();
+  await runtime.preStep({ agent, signal: first, turn: 'e1' }, enter(human('继续优化轻量化记忆与前端展示逻辑 还有触发机制等')));
+  const second = signal();
+  await runtime.preStep({ agent, signal: second, turn: 'e2' }, enter(human('继续优化收敛')));
+  const prepared = runtime.debug.preparedOf(agent);
+  assert.ok(prepared, '短续句要准备召回');
+  assert.match(prepared.query, /轻量化记忆与前端展示逻辑/, '短续句沿用上一句原话');
+  assert.ok(prepared.cards.some((card) => /轻量化记忆/.test(card.title || card.line || '')), '同一话题的记忆要回来');
+}
+
+// A25c：上一轮有动作、这句话只有「这个怎么弄」时，通用卡片不能挡住动作线索的补查。
+{
+  const cwdGeneric = mkdir('generic');
+  const scopeGeneric = store.scopeOf(cwdGeneric);
+  save(scopeGeneric, {
+    title: '这个怎么弄时先读现有文档',
+    tags: ['怎么弄', '文档'],
+    summary: '没头绪时先读现有文档再动手',
+  });
+  save(scopeGeneric, {
+    title: '改完 client.js 先重载宿主',
+    tags: ['client.js', '重载'],
+    summary: 'client.js 一改就要重载宿主，普通刷新覆盖不到',
+  });
+  const agent = makeAgent('agent-generic', cwdGeneric);
+  const runtime = boot();
+  const first = signal();
+  await runtime.preStep({ agent, signal: first, turn: 'g1' }, enter(human('这个怎么弄')));
+  assert.match(runtime.provider.text({ agent, signal: first }), /先读现有文档/, '第一轮命中通用卡片');
+  const assistantMessage = {
+    role: 'assistant',
+    id: 'asst-generic-1',
+    content: [
+      { type: 'text', text: '我把改动写进文件了。' },
+      { type: 'tool-call', name: 'write', input: { file_path: '/tmp/generic/client.js' } },
+    ],
+  };
+  const second = signal();
+  await runtime.preStep({ agent, signal: second, turn: 'g2' }, enter(assistantMessage, human('这个怎么弄')));
+  assert.match(runtime.provider.text({ agent, signal: second }), /改完 client\.js 先重载宿主/, '通用卡片不能挡住动作线索');
+}
+
+// A25d：换到数据库任务后再说「继续」，只承接数据库这一句，不能把前端任务的记忆带回来。
+{
+  const cwdSwitch = mkdir('switch-cont');
+  const scopeSwitch = store.scopeOf(cwdSwitch);
+  save(scopeSwitch, {
+    title: '前端按钮颜色先对齐设计稿 token',
+    tags: ['前端按钮', '颜色'],
+    summary: '按钮颜色只取设计稿 token，不要另写十六进制',
+  });
+  save(scopeSwitch, {
+    title: 'PostgreSQL 连接池先查 max_connections',
+    tags: ['PostgreSQL', '连接池'],
+    summary: '连接池调大前先看 max_connections 和实际占用',
+  });
+  const agent = makeAgent('agent-switch-cont', cwdSwitch);
+  const runtime = boot();
+  const first = signal();
+  await runtime.preStep({ agent, signal: first, turn: 'sc1' }, enter(human('前端按钮颜色怎么改')));
+  assert.match(runtime.provider.text({ agent, signal: first }), /前端按钮颜色/, '第一轮命中前端任务');
+  const second = signal();
+  await runtime.preStep({ agent, signal: second, turn: 'sc2' }, enter(human('改用 PostgreSQL，先看连接池')));
+  assert.match(runtime.provider.text({ agent, signal: second }), /PostgreSQL 连接池/, '第二轮命中数据库任务');
+  const third = signal();
+  await runtime.preStep({ agent, signal: third, turn: 'sc3' }, enter(human('继续')));
+  const prepared = runtime.debug.preparedOf(agent);
+  assert.match(prepared.query, /PostgreSQL/, '续句承接的是数据库那一句');
+  assert.ok(prepared.cards.some((card) => /PostgreSQL/.test(card.title || card.line || '')), '续句仍命中数据库记忆');
+  assert.ok(!prepared.cards.some((card) => /前端按钮/.test(card.title || card.line || '')), '不把前端任务记忆带回来');
+}
+
+// A25e：认不出任务类型的明确换任务，也不能把上一轮的动作线索带过来。
+{
+  const cwdUnknown = mkdir('unknown-switch');
+  const scopeUnknown = store.scopeOf(cwdUnknown);
+  save(scopeUnknown, {
+    title: '改完 client.js 先重载宿主',
+    tags: ['client.js', '重载'],
+    summary: 'client.js 改动后必须重载宿主，普通刷新覆盖不到',
+  });
+  save(scopeUnknown, {
+    title: 'nginx 502 先看 upstream 日志',
+    tags: ['nginx', '502', 'upstream'],
+    summary: '502 先查 upstream 是否存活，再看超时配置',
+  });
+  const agent = makeAgent('agent-unknown', cwdUnknown);
+  const runtime = boot();
+  const first = signal();
+  await runtime.preStep({ agent, signal: first, turn: 'u1' }, enter(human('把前端按钮颜色调一下')));
+  const assistantMessage = {
+    role: 'assistant',
+    id: 'asst-unknown-1',
+    content: [
+      { type: 'text', text: '我把 client.js 的样式改好了。' },
+      { type: 'tool-call', name: 'write', input: { file_path: '/tmp/unknown/client.js' } },
+    ],
+  };
+  const second = signal();
+  await runtime.preStep({ agent, signal: second, turn: 'u2' }, enter(assistantMessage, human('先别管这个了，帮我看看 nginx 502')));
+  const switchedText = runtime.provider.text({ agent, signal: second });
+  assert.doesNotMatch(switchedText, /改完 client\.js 先重载宿主/, '明确换任务后不带旧动作线索');
+  assert.match(switchedText, /nginx 502/, '新任务本身能命中');
+  const third = signal();
+  await runtime.preStep({ agent, signal: third, turn: 'u3' }, enter(human('继续')));
+  const continuedText = runtime.provider.text({ agent, signal: third });
+  assert.match(continuedText, /nginx 502/, '续句承接新任务');
+  assert.doesNotMatch(continuedText, /改完 client\.js 先重载宿主/, '续句不回旧任务');
+}
+
 // A26：明确换任务后，不能拿上一轮助手的话去补查、把旧任务记忆塞进新任务。
 {
   const cwdSwitch = mkdir('switch');

package/view.js

@@ -710,9 +710,44 @@ export function isContinuationQuery(text) {
   return /^(继续|接着|然后|然后呢|还有|还有呢|往下|说下去|goon|continue|next|more)$/.test(raw);
 }
 
+/**
+ * 「继续优化收敛」这类短续句：句首是续说标记，剩下的只由通用动作词组成，
+ * 没有点名新的对象。它本身检索不出上一轮的记忆，但仍属于当前任务，要沿用上一句原话。
+ * 明确带对象（「继续优化数据库连接池」「继续优化轻量化记忆」）不算，交给换任务判断。
+ */
+const ELLIPTICAL_BODY = /^(?:把|将|再|接着|继续)?(?:优化|收敛|调整|完善|打磨|推进|处理|改|修|做|写|整理|检查|排查|测试|发布|跑|看看|看下|弄|试|收尾|统一|对齐|细化|补|过一遍|走一遍|一下|下)+[。.!！?？…]*$/u;
+export function isEllipticalContinuation(text) {
+  const raw = plain(text, 40).trim();
+  const cut = raw.replace(/^[\s\u3002\uff01\uff1f?!\uff0c,\u3001\u2026~\uff5e]+/u, '');
+  if (!cut || [...cut].length > 12) return false;
+  const match = cut.match(/^(?:继续|接着|再接着|往下)[，,、\s]*(.+)$/u);
+  if (!match) return false;
+  return ELLIPTICAL_BODY.test(match[1].trim());
+}
+
+/** 这句话有没有具体动作：只用于判断要不要把上一轮的工具线索并进这次查询。 */
+const CONCRETE_ACTION = /(改|写|修|做|建|删|新增|添加|移除|运行|跑|测试|发布|部署|提交|推送|安装|重载|重启|启动|停止|检查|排查|优化|收敛|处理|调整|配置|设置|替换|更换|上传|下载|生成|保存|读取|打开|关闭|合并|拆分|回滚|迁移|接入|修复|定位|复现)/u;
+export function hasConcreteAction(text) {
+  return CONCRETE_ACTION.test(plain(text, 400));
+}
+
+/**
+ * 明确换任务：句子里有换做/改用/先别管这类词，或点了一个上一句没有的英文对象。
+ * 认不出任务类型时，上一轮的动作线索只能靠这条规则隔开，不能因为类型为空就默认同任务。
+ */
+const SWITCH_MARK = /(换成|换个|换一个|改用|改做|改为|改到|转到|先不管|别管|先别|不弄这个|不看这个|另一个|新任务|去做|开始做)/u;
+export function isExplicitSwitch(text, previousText = '') {
+  const current = plain(text, 400);
+  if (!current) return false;
+  if (SWITCH_MARK.test(current)) return true;
+  const previous = plain(previousText, 400).toLowerCase();
+  const objects = current.match(/[A-Za-z][A-Za-z0-9_.-]{1,}|[0-9]{2,}/g) || [];
+  return objects.some((token) => !previous.includes(token.toLowerCase()));
+}
+
 /**
  * 补查只有在「还是同一个任务」时才成立：任务类型或 episode 变了，上一轮的动作历史属于旧任务，
- * 不能拿它给新任务找记忆。缺任一侧身份都按不同任务处理，宁可少补一次也不串旧话题。
+ * 不能拿它给新任务找记忆。类型缺失时保留补查，由调用方的明确换任务判断兜底。
  */
 export function sameRecallTask(previous, current) {
   if (!previous || !current) return true;