dsh-lite-memory 0.18.33 → 0.18.34

package/docs/RELEASE-0.18.34.md

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

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();
@@ -1299,6 +1301,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 +1363,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 +1920,8 @@ export function apply(ctx, config) {
         const now = Date.now();
         const live = state.lines.filter((row) => !row.validUntil || now <= Date.parse(String(row.validUntil)));
         normalText = live.length ? `${RECALL_HEADER}\n${live.map((row) => row.line).join('\n')}` : '';
+        /** 真正交付的卡片才记使用：到期被撤下的、准备后被丢弃的都不算。 */
+        if (live.length && state.scope) markUsed(state.scope, live.map((row) => row.id).filter(Boolean));
         /** 投影时还在、发出时已过期：回执跟着真实输出改，别在面板上说「提醒了 2 条」而正文是空的。 */
         if (state.scope && live.length !== state.cards.length) {
           noteRecall(state.scope, state.sessionId, {
@@ -2659,6 +2665,7 @@ export function apply(ctx, config) {
       const fresh = freshHumans(sessionId, humans);
       const previous = prepared.get(agent);
       const sameSession = Boolean(previous && previous.sessionId === sessionId);
+      const sessionTask = recallTasks.get(sessionId) || null;
 
       if (fresh.length === 0) {
         /** 工具续步：内容冻结，只把快照绑到本步的 signal；盘上版本变了才重投影。 */
@@ -2701,6 +2708,32 @@ export function apply(ctx, config) {
             }
           }
         }
+        /**
+         * 工具续步里没有新的真人原话，但刚执行的动作本身就是线索。
+         * 只补一次、共用一个请求额度，补到的卡片追加到已发布快照，超出仍由预算挡。
+         */
+        const stepMessages = Array.isArray(decision.messages) ? decision.messages : [];
+        const seenAt = Number.isInteger(previous.seenMessages) ? previous.seenMessages : 0;
+        const stepActions = seenAt < stepMessages.length ? stepMessages.slice(seenAt) : [];
+        previous.seenMessages = stepMessages.length;
+        const actionQuery = previous.recalledContext && !previous.actionRetried
+          ? view.actionTerms(stepActions, { limit: 10 }).slice(0, 240) : '';
+        if (actionQuery) {
+          previous.actionRetried = true;
+          const win = windowOf(agent);
+          if (win && generation === generations.get(agent) && !signal?.aborted) {
+            const retry = projectRecall(scope, `${actionQuery} ${previous.query}`.trim().slice(0, RECALL_QUERY_CHARS), previous.recalledContext, win, previous.runtimeHeld || null);
+            const known = new Set((previous.cards || []).map((card) => card.id));
+            const added = (retry.cards || []).filter((card) => !known.has(card.id));
+            if (added.length) {
+              const addedIds = new Set(added.map((card) => card.id));
+              const extraLines = (retry.lines || []).filter((row, index) => addedIds.has(retry.cards[index] && retry.cards[index].id));
+              previous.cards = [...(previous.cards || []), ...added];
+              previous.lines = [...(previous.lines || []), ...extraLines];
+              previous.text = `${RECALL_HEADER}\n${previous.lines.map((row) => row.line).join('\n')}`;
+            }
+          }
+        }
         return decision;
       }
 
@@ -2716,9 +2749,8 @@ export function apply(ctx, config) {
       /** 工具模式也要记下本轮真人原话：只用于核对绑定，不自动注入。 */
       const said = view.newestUserQuery(fresh).slice(0, RECALL_QUERY_CHARS);
       /** 「继续」这类续说没有检索词：带上同会话上一轮原话，否则这一轮必然召回为空。 */
-      const carried = sameSession && previous?.query
-        && (view.isContinuationQuery(said) || view.isEllipticalContinuation(said))
-        ? previous.query : '';
+      const carried = (view.isContinuationQuery(said) || view.isEllipticalContinuation(said))
+        ? (previous?.query || sessionTask?.query || '') : '';
       let query = (carried ? `${said} ${carried}` : said).trim().slice(0, RECALL_QUERY_CHARS);
       if (win && query) win.query = query;
 
@@ -2766,12 +2798,22 @@ 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 : '')
+      const previousTask = (previous && previous.task) || (sessionTask && sessionTask.task) || rememberedTask;
+      const previousText = (previous && previous.query) || (sessionTask && sessionTask.query) || '';
+      const sameTask = Boolean(sameSession || sessionTask || rememberedTask)
+        && !view.isExplicitSwitch(said, previousText)
         && view.sameRecallTask(previousTask, currentTask);
+      const taskStartMessageId = sameTask && sessionTask && sessionTask.startMessageId
+        ? sessionTask.startMessageId : ids[0];
       lastTask.set(sessionId, currentTask);
+      recallTasks.set(sessionId, {
+        query,
+        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,7 +2826,11 @@ 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);
@@ -2860,10 +2906,14 @@ export function apply(ctx, config) {
         fingerprint,
         controlEpoch,
         evolutionEpoch,
+        recalledContext,
+        runtimeHeld: runtime && runtime.held ? runtime.held : null,
+        seenMessages: Array.isArray(decision.messages) ? decision.messages.length : 0,
+        actionRetried: false,
         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 +3175,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); }
   });
 
   /**

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 的旧调用才退回原句判断。
@@ -623,19 +625,30 @@ export function validateChange(change, { refs, rules, ranges, expectedTarget } =
   }
   /** 收集时固定的作用域只能沿用或收窄：整理器不能把待确认候选抬成全项目规则。 */
   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 +663,12 @@ 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);
+  }
   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.34",
   "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

@@ -2738,7 +2738,7 @@ function bindSameTopic(projectScope, ref) {
 const CONFLICT_LIMIT = 20;
 
 /** 待办里留一份可重放的草稿：面板能直接另存，不用用户回忆刚才想记什么。 */
-const CONFLICT_DRAFT_KEYS = ['title', 'summary', 'body', 'when', 'kind', 'tags', 'conditions', 'applicability', 'topicKey', 'source', 'origin'];
+const CONFLICT_DRAFT_KEYS = ['title', 'summary', 'body', 'when', 'kind', 'tags', 'conditions', 'applicability', 'selection', 'triggers', 'links', 'topicKey', 'source', 'origin'];
 function conflictDraftOf(draft) {
   const out = {};
   if (!draft || typeof draft !== 'object') return out;
@@ -2754,6 +2754,10 @@ function conflictDraftOf(draft) {
     else if (key === 'conditions') out.conditions = Array.isArray(value) ? value.slice(0, 8) : undefined;
     else if (key === 'applicability') out.applicability = value;
     else if (key === 'topicKey') out.topicKey = normalizeText(value, 80);
+    /** 适用范围、召回触发词与关联整份重放：经过待裁决不能改变语义。 */
+    else if (key === 'selection') out.selection = value && typeof value === 'object' && !Array.isArray(value) ? { ...value } : null;
+    else if (key === 'triggers') out.triggers = Array.isArray(value) ? value.slice(0, 8).map((item) => normalizeText(item, 40)).filter(Boolean) : [];
+    else if (key === 'links') out.links = Array.isArray(value) ? value.slice(0, 3).map((item) => (item && typeof item === 'object' ? { ...item } : null)).filter(Boolean) : [];
     else if (key === 'source') out.source = value;
     else if (key === 'origin') out.origin = value;
   }
@@ -2821,30 +2825,35 @@ function staleDraft(row, ref) {
 
 /** 确认另存：用队列里的草稿按 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 && 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 };
+  /** 版本检查、另存和出队必须在同一临界区：中间被新反馈改写时，旧面板不能批准新草稿。 */
+  return withLocks([scope, globalScope()], () => {
+    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 && 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, 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 };
+  return withLocks([scope, globalScope()], () => {
+    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/crossing.test.mjs

@@ -434,7 +434,32 @@ await test('S12 待裁决留可重放草稿，面板确认另存后才落库', (
   assert.equal(pendingConflictsOf(scope), 0);
   assert.equal(loadIndex(scope).entries.length, 1);
   assert.equal(loadIndex(scope).entries[0].body, '项目补充');
+  assert.equal(loadIndex(scope).entries[0].when, '本仓库', 'when 经过待裁决不能丢');
   assert.equal(dropConflict(scope, '不存在').ok, false);
 });
 
+await test('S12 经过待裁决另存不改变适用范围、触发词和关联', () => {
+  const scope = fresh('conflict-semantics');
+  const globalOne = saveEntry(globalScope(), { title: '发票抬头规则', summary: '开票信息固定', body: '全局版本', resolution: 'distinct' });
+  const linked = saveEntry(globalScope(), { title: '生效核验顺序', summary: '先验规则再验页面', body: '先验规则', resolution: 'distinct' });
+  const near = saveEntry(scope, {
+    title: '发票抬头规则', summary: '本项目发票只认这套抬头', body: '项目版本',
+    selection: { mode: 'complete', artifactKey: 'artifact-invoice-v1' },
+    triggers: ['artifact-hookword'],
+    links: [{ type: 'related', id: linked.record.id }],
+    topicKey: 'invoice',
+  });
+  assert.equal(near.needsResolution, true);
+  const [row] = conflictsOf(scope);
+  assert.deepEqual(row.draft.selection, { mode: 'complete', artifactKey: 'artifact-invoice-v1', items: [] });
+  assert.deepEqual(row.draft.triggers, ['artifact-hookword']);
+  assert.deepEqual(row.draft.links, [{ type: 'related', id: linked.record.id }]);
+  const kept = resolveConflict(scope, { id: row.id, expectedRevision: row.revision });
+  assert.equal(kept.ok, true, JSON.stringify(kept));
+  const [record] = loadIndex(scope).entries;
+  assert.deepEqual(record.selection, { mode: 'complete', artifactKey: 'artifact-invoice-v1', items: [] });
+  assert.deepEqual(record.triggers, ['artifact-hookword']);
+  assert.deepEqual(record.links, [{ type: 'related', id: linked.record.id }]);
+});
+
 console.log(`crossing.test.mjs: ${passed} passed`);

package/test/learning.test.mjs

@@ -1036,6 +1036,54 @@ test('L03d2 代码任务学到的规则不会在数据库任务里生效', () =>
   assert.equal(db.reason, 'condition_mismatch');
 });
 
+test('L03d3 空项目的第一条反馈能带上真实任务范围保存', () => {
+  const parsed = learning.parseOutput(JSON.stringify({
+    changes: [{
+      target: 'new', feedbackType: 'spec_change', topicKey: '前端边框',
+      currentText: '前端页面默认采用细边框', applicability: 'all_in_scope', evidence: ['u0'],
+    }],
+  }), {
+    finish: { kind: 'stop' }, refs: { feedback: { u0: 'm1' }, rules: {} }, rules: [],
+    ranges: { taskKinds: [], series: [], projects: ['p'] },
+    expectedTarget: { scope: 'episode', projectId: 'p', episodeId: 'ep1', taskKind: 'code', phase: 'brief' },
+  });
+  assert.equal(parsed.ok, true, parsed.reason);
+  assert.equal(parsed.changes[0].applicability, 'conditional');
+  assert.deepEqual(parsed.changes[0].conditions, [{ key: 'taskKind', value: 'code' }], '采集阶段不该锁死长期适用范围');
+});
+
+test('L03d4 模型条件与采集任务范围冲突时拒绝，不生成永不生效的规则', () => {
+  const parsed = learning.parseOutput(JSON.stringify({
+    changes: [{
+      target: 'new', feedbackType: 'spec_change', topicKey: '迁移',
+      currentText: '先跑迁移再改代码', applicability: 'conditional',
+      conditions: [{ key: 'taskKind', value: 'database' }], evidence: ['u0'],
+    }],
+  }), {
+    finish: { kind: 'stop' }, refs: { feedback: { u0: 'm1' }, rules: {} }, rules: [],
+    ranges: { ...RANGES, taskKinds: ['code', 'database'] },
+    expectedTarget: { scope: 'episode', projectId: 'p', episodeId: 'ep1', taskKind: 'code' },
+  });
+  assert.equal(parsed.ok, false);
+  assert.match(parsed.reason, /冲突/);
+});
+
+test('L03d5 同一条件键的两个值不能都留下', () => {
+  const parsed = learning.parseOutput(JSON.stringify({
+    changes: [{
+      target: 'new', feedbackType: 'spec_change', topicKey: '阶段冲突',
+      currentText: '只在脚本阶段生效', applicability: 'conditional',
+      conditions: [{ key: 'phase', value: 'script' }, { key: 'phase', value: 'brief' }], evidence: ['u0'],
+    }],
+  }), {
+    finish: { kind: 'stop' }, refs: { feedback: { u0: 'm1' }, rules: {} }, rules: [],
+    ranges: { ...RANGES },
+    expectedTarget: { scope: 'episode', projectId: 'p', episodeId: 'ep1', taskKind: 'code', phase: 'brief' },
+  });
+  assert.equal(parsed.ok, false);
+  assert.match(parsed.reason, /条件/);
+});
+
 test('L03e 先按相关性排序再截断，输入顺序不挤掉真正相关的旧规则', () => {
   const rules = [];
   for (let index = 0; index < 32; index += 1) {

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,25 @@ 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 delivered = store.readEntry(scopeUse, only.record.id, { usage: () => false });
+  assert.notEqual(delivered.lastUsed, saved.lastUsed, '真正交付后才记使用');
+}
+
 // A12：额度状态与冻结快照分开；清掉快照后重准备不重新分配。
 {
   const agent = makeAgent('agent-preserve', cwdA);
@@ -353,6 +375,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);

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;