dsh-lite-memory 0.18.29 → 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/client.js

@@ -2157,6 +2157,7 @@ window.__ModuleLoader__.load({
       const [display, setDisplay] = React.useState({ ...DISPLAY_DEFAULTS });
       const [hubFilter, setHubFilter] = React.useState(null);
       const [checkup, setCheckup] = React.useState(false);
+      const [expandedConflict, setExpandedConflict] = React.useState('');
       const alive = React.useRef(true);
       const generation = React.useRef(0);
       const scopeRef = React.useRef('');
@@ -2205,10 +2206,13 @@ window.__ModuleLoader__.load({
         if (!row || busy) return;
         setBusy(true);
         setNote('');
-        post('/lite-memory/conflict', { sessionId, scopeKey: selectedKey, title: row.title, op }).then((result) => {
+        post('/lite-memory/conflict', {
+          sessionId, scopeKey: selectedKey, conflictId: row.id, expectedRevision: row.revision, op,
+        }).then((result) => {
           if (!alive.current) return;
           setBusy(false);
           if (result.ok && result.body && result.body.ok) {
+            setExpandedConflict('');
             if (op === 'drop') setNote('已忽略这条待裁决');
             load(selectedKey);
           } else setNote(failure(result, '待裁决没处理成'));
@@ -2220,6 +2224,7 @@ window.__ModuleLoader__.load({
         setDisplay(readDisplaySettings(selectedKey));
         setShowSettings(false);
         setHubFilter(null);
+        setExpandedConflict('');
       }, [selectedKey]);
       React.useEffect(() => {
         setMemoryView((value) => viewModeOf(display, value));
@@ -2726,18 +2731,41 @@ window.__ModuleLoader__.load({
       const memoryViewActive = viewModeOf(display, memoryView);
       const evolutionViewActive = graphViewOf(display.graph, evolutionView);
 
+      const conflictReadOnly = !memoryOn || (!globalView && selectedKey !== currentKey);
+      const draftScope = (row) => (row.scope === 'global' ? '总记忆' : '本项目');
       const conflictBar = queued.length === 0 ? null : h('div', {
         style: { display: 'flex', flexDirection: 'column', gap: '3px', padding: '7px 9px 8px', borderBottom: '1px solid var(--dsw-alias-border-l1)', flex: '0 0 auto' },
       },
-      h('div', { style: { ...PANEL_MUTED, lineHeight: '18px' } }, `${queued.length} 条保存没确认`),
-      queued.slice(0, 2).map((row) => h('div', {
-        key: row.id || row.title,
-        style: { display: 'flex', alignItems: 'center', gap: '8px', minWidth: 0 },
-      },
-      h('span', { style: { flex: 1, minWidth: 0, fontSize: '12px', lineHeight: '20px', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' } }, row.title),
-      h(Action, { disabled: busy, onClick: () => resolveQueued(row, 'keep') }, '另存'),
-      h(Action, { disabled: busy, onClick: () => resolveQueued(row, 'drop') }, '忽略'),
-      )));
+      h('div', { style: { ...PANEL_MUTED, lineHeight: '18px' } }, `${queued.length} 条保存没确认${conflictReadOnly ? ' · 只读' : ''}`),
+      queued.slice(0, 2).map((row) => {
+        const open = expandedConflict === row.id;
+        const draft = row.draft || {};
+        return h('div', {
+          key: row.id || row.title,
+          style: { display: 'flex', flexDirection: 'column', gap: '2px', minWidth: 0 },
+        },
+        h('div', { style: { display: 'flex', alignItems: 'center', gap: '8px', minWidth: 0 } },
+          h('button', {
+            type: 'button',
+            'aria-expanded': open,
+            onClick: () => setExpandedConflict(open ? '' : row.id),
+            style: {
+              flex: 1, minWidth: 0, padding: 0, border: 0, background: 'transparent', color: 'inherit',
+              textAlign: 'left', font: 'inherit', fontSize: '12px', lineHeight: '20px',
+              overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap', cursor: 'pointer',
+            },
+          }, row.title),
+          conflictReadOnly ? null : h(Action, { disabled: busy, onClick: () => resolveQueued(row, 'keep') }, '另存'),
+          conflictReadOnly ? null : h(Action, { disabled: busy, onClick: () => resolveQueued(row, 'drop') }, '忽略'),
+        ),
+        open ? h('div', {
+          style: { ...PANEL_MUTED, padding: '2px 0 4px', lineHeight: '18px', overflowWrap: 'anywhere' },
+        },
+        h('div', null, `范围：${draftScope(row)}`),
+        draft.when ? h('div', null, `适用：${draft.when}`) : null,
+        h('div', null, String(draft.body || draft.summary || '（没有正文）').slice(0, 400)),
+        ) : null);
+      }));
       const memoryListPane = h('div', {
         style: {
           ...PANEL_CARD, padding: '2px 4px', minHeight: 0, overflowY: 'auto',

package/docs/RELEASE-0.18.30.md

@@ -0,0 +1,7 @@
+# 0.18.30
+
+- 待裁决入口按「当前会话项目 + 目标层 + 草稿版本」核验：跨项目请求直接拒绝，不再把别的 scope 静默解释成当前项目。
+- 项目记忆关闭时，本入口（含选全局层另存）一律拒绝，不绕过已有总开关。
+- 队列行增加稳定 id 与 revision；草稿被后续反馈替换后，旧面板的「另存」返回 `stale_draft`，不会保存用户没看过的新正文。
+- 面板可展开一条待裁决，看草稿正文、适用范围和目标层；关闭或跨项目浏览时显示只读，不出现操作按钮。
+- 回归覆盖：跨项目拒绝、关闭态拒绝、旧版本拒绝、全局草稿在项目关闭时拒绝。

package/docs/RELEASE-0.18.31.md

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

package/index.js

@@ -553,14 +553,42 @@ function keepHandler(webServer, cwdForSession) {
       const cwd = typeof cwdForSession === 'function' ? cwdForSession(sessionId) : '';
       if (!cwd) return sendJson(res, 409, { ok: false, reason: '这个会话还没有项目目录' });
       const projectScope = scopeOf(cwd);
+      if (!projectScope.confirmed) return sendJson(res, 409, { ok: false, reason: '项目根还没确认，先重新打开这个项目' });
+      /** 请求里的目标必须与当前会话项目一致；别的项目只读，不能借面板改过去。 */
       const requested = typeof body.scopeKey === 'string' ? body.scopeKey : '';
+      if (!requested) return sendJson(res, 400, { ok: false, reason: '缺少目标范围' });
+      if (requested !== 'global' && requested !== projectScope.key) {
+        return sendJson(res, 409, { ok: false, reason: '别的项目只读，回到那个项目里再改' });
+      }
       const target = requested === 'global' ? globalScope() : projectScope;
-      const title = typeof body.title === 'string' ? body.title.trim() : '';
-      if (!title) return sendJson(res, 400, { ok: false, reason: '缺少标题' });
+      /** 关闭的项目记忆不能从这个入口绕过；选全局时全局总开关也必须开着。 */
+      if (!memoryEnabled(projectScope)) {
+        return sendJson(res, 409, { ok: false, code: 'memory_disabled', reason: memoryOffCopy(projectScope) });
+      }
+      if (target.key === 'global' && !memoryEnabled(target)) {
+        return sendJson(res, 409, { ok: false, code: 'memory_disabled', reason: '总记忆已关闭，先在面板打开' });
+      }
+      const op = body.op;
+      if (op !== 'keep' && op !== 'drop') return sendJson(res, 400, { ok: false, reason: '不认识这个操作' });
+      const conflictId = typeof body.conflictId === 'string' ? body.conflictId.trim() : '';
+      if (!conflictId) return sendJson(res, 400, { ok: false, reason: '缺少这条待裁决' });
+      const expectedRevision = Number(body.expectedRevision);
+      if (!Number.isInteger(expectedRevision) || expectedRevision < 1) {
+        return sendJson(res, 409, { ok: false, reason: '这条待裁决的版本不清楚，先刷新再处理' });
+      }
       try {
-        const outcome = body.op === 'drop' ? { ok: dropConflict(target, title) } : resolveConflict(target, title);
-        if (!outcome.ok) return sendJson(res, 409, { ok: false, reason: outcome.reason || '这条待裁决还没处理成' });
-        return sendJson(res, 200, { ok: true, remaining: conflictsOf(target).length });
+        const ref = { id: conflictId, expectedRevision };
+        const outcome = op === 'drop' ? dropConflict(target, ref) : resolveConflict(target, ref);
+        if (!outcome.ok) {
+          return sendJson(res, outcome.reasonCode === 'stale_draft' ? 409 : 409, {
+            ok: false, code: outcome.reasonCode || '', reason: outcome.reason || '这条待裁决还没处理成',
+          });
+        }
+        return sendJson(res, 200, {
+          ok: true,
+          remaining: conflictsOf(target).length,
+          record: outcome.record ? { id: outcome.record.id, title: outcome.record.title, revision: outcome.record.revision } : null,
+        });
       } catch (error) {
         return sendJson(res, 409, { ok: false, reason: error instanceof Error ? error.message : '待裁决处理失败' });
       }
@@ -2686,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) {
@@ -2729,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.29",
+  "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/store.js

@@ -2761,20 +2761,32 @@ function queueConflictLocked(scope, draft, candidates) {
   if (hit) {
     hit.candidates = view;
     hit.draft = replay;
+    /** 草稿被后来的反馈替换过：版本必须涨，旧面板不能拿旧版直接批准。 */
+    hit.revision = (Number(hit.revision) || 1) + 1;
     hit.updatedAt = now;
   } else {
-    rows.push({ id: `cf_${crypto.randomUUID().replace(/-/g, '').slice(0, 12)}`, title, scope: scopeKey, candidates: view, draft: replay, createdAt: now, updatedAt: now });
+    rows.push({ id: `cf_${crypto.randomUUID().replace(/-/g, '').slice(0, 12)}`, title, scope: scopeKey, candidates: view, draft: replay, revision: 1, createdAt: now, updatedAt: now });
   }
   index.conflicts = rows.slice(-CONFLICT_LIMIT);
   saveIndex(scope, index);
   return index.conflicts.length;
 }
 
-function clearConflictLocked(scope, title) {
+/** 按稳定 id 找；旧调用还传标题，只为兼容已有数据与测试。 */
+function conflictRowLocked(scope, ref) {
+  const rows = Array.isArray(loadIndex(scope).conflicts) ? loadIndex(scope).conflicts : [];
+  const layer = scope.key === 'global' ? 'global' : 'project';
+  if (ref && typeof ref === 'object' && ref.id) return rows.find((row) => row.id === ref.id && row.scope === layer) || null;
+  const norm = normalizeText(typeof ref === 'string' ? ref : '', 120);
+  return rows.find((row) => row.title === norm && row.scope === layer) || null;
+}
+
+function clearConflictLocked(scope, ref) {
   const index = loadIndex(scope);
   const rows = Array.isArray(index.conflicts) ? index.conflicts : [];
-  const norm = normalizeText(title, 120);
-  const next = rows.filter((row) => !(row.title === norm && row.scope === (scope.key === 'global' ? 'global' : 'project')));
+  const id = ref && typeof ref === 'object' && ref.id ? ref.id : '';
+  const norm = id ? '' : normalizeText(typeof ref === 'string' ? ref : '', 120);
+  const next = rows.filter((row) => (id ? row.id !== id : !(row.title === norm && row.scope === (scope.key === 'global' ? 'global' : 'project'))));
   if (next.length === rows.length) return rows.length;
   index.conflicts = next;
   saveIndex(scope, index);
@@ -2787,28 +2799,38 @@ export function conflictsOf(scope) {
   return Array.isArray(rows) ? JSON.parse(JSON.stringify(rows)) : [];
 }
 
-/** 确认另存：用队列里的草稿按 distinct 重放一次，成功后出队。 */
-export function resolveConflict(scope, title, options = {}) {
-  const rows = Array.isArray(loadIndex(scope).conflicts) ? loadIndex(scope).conflicts : [];
-  const norm = normalizeText(title, 120);
-  const row = rows.find((item) => item.title === norm && item.scope === (scope.key === 'global' ? 'global' : 'project'));
+/** 版本对不上就拒绝：用户看到的草稿和现在这条不是同一版。 */
+function staleDraft(row, ref) {
+  if (!ref || typeof ref !== 'object' || ref.expectedRevision === undefined) return false;
+  return Number(ref.expectedRevision) !== (Number(row.revision) || 1);
+}
+
+/** 确认另存：用队列里的草稿按 distinct 重放一次，成功后按 id 出队。 */
+export function resolveConflict(scope, ref, options = {}) {
+  const row = conflictRowLocked(scope, ref);
   if (!row) return { ok: false, reason: '这条待裁决已经不在了，刷新面板看看' };
+  if (staleDraft(row, ref)) return { ok: false, reasonCode: 'stale_draft', reason: '这条待裁决又更新了，刷新后再处理' };
   const draft = { ...(row.draft || {}), resolution: 'distinct', writeMode: options.writeMode === 'append' ? 'append' : 'patch' };
   if (scope.key === 'global') draft.scope = 'global';
   else draft.scope = 'project';
   if (!draft.title) draft.title = row.title;
   const result = saveEntry(scope, draft);
-  if (result.needsResolution) return { ok: false, reason: '还是相近：换一个标题或等确认', result };
-  if (result.needsScope) return { ok: false, reason: '这条记忆的适用范围还没定，先说明当前环境', result };
-  clearConflictLocked(scope, row.title);
-  return { ok: true, result };
+  if (result && result.needsResolution) return { ok: false, reason: '还是相近：换一个标题或等确认', result };
+  if (result && result.needsScope) {
+    const reason = result.reasonCode === 'memory_disabled' ? '这层记忆已关闭' : '这条记忆的适用范围还没定，先说明当前环境';
+    return { ok: false, reason, result };
+  }
+  clearConflictLocked(scope, { id: row.id });
+  return { ok: true, result, record: result && result.record };
 }
 
 /** 删掉待裁决：用户决定不再另存。 */
-export function dropConflict(scope, title) {
-  const before = pendingConflictsOf(scope);
-  clearConflictLocked(scope, title);
-  return pendingConflictsOf(scope) < before;
+export function dropConflict(scope, ref) {
+  const row = conflictRowLocked(scope, ref);
+  if (!row) return { ok: false, reason: '这条待裁决已经不在了，刷新面板看看' };
+  if (staleDraft(row, ref)) return { ok: false, reasonCode: 'stale_draft', reason: '这条待裁决又更新了，刷新后再处理' };
+  clearConflictLocked(scope, { id: row.id });
+  return { ok: true };
 }
 
 /** 当前层还有几条没处理的冲突。 */

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

@@ -1213,6 +1213,7 @@ assert.equal(ovArchivedBody.body.body, '右侧留白。');
 // 待裁决：面板看得到队列，确认后按草稿另存，不预写正文
 const cfCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-contract-conflict-'));
 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 });
 const cfSave = await defs.get('memory_save').execute({ title: '发布窗口', summary: '本项目周五发版', body: '周五发版。' }, { agent: cfAgent });
@@ -1221,15 +1222,77 @@ assert.equal(store.loadIndex(store.scopeOf(cfCwd)).entries.length, 0, '没确认
 const cfBefore = await call('/lite-memory/overview', { sessionId: 'session-conflict-panel' });
 assert.equal(cfBefore.status, 200);
 assert.equal(cfBefore.body.selected.conflicts.length, 1);
-assert.equal(cfBefore.body.selected.conflicts[0].title, '发布窗口');
-assert.equal(cfBefore.body.selected.conflicts[0].draft.body, '周五发版。');
-const cfKeep = await call('/lite-memory/conflict', { sessionId: 'session-conflict-panel', scopeKey: cfBefore.body.selected.key, title: '发布窗口', op: 'keep' });
+const cfRow = cfBefore.body.selected.conflicts[0];
+assert.equal(cfRow.title, '发布窗口');
+assert.equal(cfRow.draft.body, '周五发版。');
+assert.ok(cfRow.id, '待裁决要有稳定 id');
+assert.equal(cfRow.revision, 1);
+const cfScopeKey = cfBefore.body.selected.key;
+
+// 跨项目：当前会话是 A，请求 B 的范围必须拒绝，且不能动到 A 的草稿
+const cfCross = await call('/lite-memory/conflict', {
+  sessionId: 'session-conflict-panel', scopeKey: '另一个项目', conflictId: cfRow.id, expectedRevision: 1, op: 'drop',
+});
+assert.equal(cfCross.status, 409);
+assert.match(cfCross.body.reason, /只读/);
+assert.equal(store.loadIndex(store.scopeOf(cfCwd)).conflicts.length, 1, '跨项目请求不改数据');
+
+// 关闭项目记忆后，本入口也不能落盘
+await call('/lite-memory/control', { sessionId: 'session-conflict-panel', enabled: false, operationId: 'op_cf_close' });
+const cfClosed = await call('/lite-memory/conflict', {
+  sessionId: 'session-conflict-panel', scopeKey: cfScopeKey, conflictId: cfRow.id, expectedRevision: 1, op: 'keep',
+});
+assert.equal(cfClosed.status, 409);
+assert.equal(cfClosed.body.code, 'memory_disabled');
+assert.equal(store.loadIndex(store.scopeOf(cfCwd)).entries.length, 0, '关闭状态不写记忆');
+await call('/lite-memory/control', { sessionId: 'session-conflict-panel', enabled: true, operationId: 'op_cf_reopen' });
+
+// 草稿被后来的反馈替换：旧版本点击必须拒绝
+await defs.get('memory_save').execute({ title: '发布窗口', summary: '本项目改成周六发版', body: '周六发版。' }, { agent: cfAgent });
+const cfStale = await call('/lite-memory/conflict', {
+  sessionId: 'session-conflict-panel', scopeKey: cfScopeKey, conflictId: cfRow.id, expectedRevision: 1, op: 'keep',
+});
+assert.equal(cfStale.status, 409);
+assert.equal(cfStale.body.code, 'stale_draft');
+const cfStaleView = await call('/lite-memory/overview', { sessionId: 'session-conflict-panel' });
+assert.equal(cfStaleView.body.selected.conflicts[0].revision, 2, '草稿换了版本要涨');
+assert.equal(cfStaleView.body.selected.conflicts[0].draft.body, '周六发版。');
+
+const cfKeep = await call('/lite-memory/conflict', {
+  sessionId: 'session-conflict-panel', scopeKey: cfScopeKey, conflictId: cfRow.id, expectedRevision: 2, op: 'keep',
+});
 assert.equal(cfKeep.status, 200);
 assert.equal(cfKeep.body.ok, true);
 const cfAfter = await call('/lite-memory/overview', { sessionId: 'session-conflict-panel' });
 assert.equal(cfAfter.body.selected.conflicts.length, 0);
-assert.ok(cfAfter.body.selected.records.some((row) => row.title === '发布窗口' && row.summary === '本项目周五发版'));
-const cfAgain = await call('/lite-memory/conflict', { sessionId: 'session-conflict-panel', scopeKey: cfBefore.body.selected.key, title: '发布窗口', op: 'keep' });
+assert.ok(cfAfter.body.selected.records.some((row) => row.title === '发布窗口' && row.summary === '本项目改成周六发版'));
+const cfAgain = await call('/lite-memory/conflict', {
+  sessionId: 'session-conflict-panel', scopeKey: cfScopeKey, conflictId: cfRow.id, expectedRevision: 2, op: 'keep',
+});
 assert.equal(cfAgain.status, 409, '队列没了就明确说，不重复落库');
 
+// 项目记忆关闭时，选全局待裁决也不能借这个入口落盘
+const cfgCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-contract-conflict-global-'));
+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 });
+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, '全局层也要有这条待裁决');
+const cfgRow = cfgView.body.selected.conflicts[0];
+await call('/lite-memory/control', { sessionId: 'session-conflict-global', enabled: false, operationId: 'op_cfg_close' });
+const cfgClosed = await call('/lite-memory/conflict', {
+  sessionId: 'session-conflict-global', scopeKey: 'global', conflictId: cfgRow.id, expectedRevision: cfgRow.revision, op: 'keep',
+});
+assert.equal(cfgClosed.status, 409);
+assert.equal(cfgClosed.body.code, 'memory_disabled');
+assert.equal(store.conflictsOf(store.globalScope()).length, 1, '关闭状态不批准全局草稿');
+await call('/lite-memory/control', { sessionId: 'session-conflict-global', enabled: true, operationId: 'op_cfg_reopen' });
+const cfgKeep = await call('/lite-memory/conflict', {
+  sessionId: 'session-conflict-global', scopeKey: 'global', conflictId: cfgRow.id, expectedRevision: cfgRow.revision, op: 'keep',
+});
+assert.equal(cfgKeep.status, 200);
+assert.equal(store.conflictsOf(store.globalScope()).length, 0);
+
 console.log('contract.test.mjs: all passed');

package/test/crossing.test.mjs

@@ -434,7 +434,7 @@ await test('S12 待裁决留可重放草稿，面板确认另存后才落库', (
   assert.equal(pendingConflictsOf(scope), 0);
   assert.equal(loadIndex(scope).entries.length, 1);
   assert.equal(loadIndex(scope).entries[0].body, '项目补充');
-  assert.equal(dropConflict(scope, '不存在'), false);
+  assert.equal(dropConflict(scope, '不存在').ok, false);
 });
 
 console.log(`crossing.test.mjs: ${passed} passed`);

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;