dsh-lite-memory 0.18.19 → 0.18.26

package/store.js

@@ -41,6 +41,13 @@ const LEGACY_SUMMARY_TAIL = '摘要原文：';
  * 老 ID、病史查询和关联跳转都不能把正文带出来。管理面显式传 allowExperimental。
  */
 export const EXPERIMENTAL_ORIGIN = 'project_evolution';
+/** 谁写下当前这版正文：只有这几种，别把猜测当事实。 */
+export const ORIGINS = ['user_explicit', 'model_drafted', EXPERIMENTAL_ORIGIN];
+
+function originOf(source) {
+  const value = source && (source.origin || source.source);
+  return ORIGINS.includes(value) ? value : 'user_explicit';
+}
 
 export function isExperimentalRecord(record) {
   if (!record) return false;
@@ -110,7 +117,7 @@ function toFlat(entry) {
     lastUsed: maintenance.lastUsed || entry.updatedAt || entry.createdAt || '',
     revision: Number(entry.revision) || 1,
     status: entry.status === 'archived' ? 'archived' : 'active',
-    origin: entry.origin || 'user_explicit',
+    origin: ORIGINS.includes(entry.origin) ? entry.origin : 'user_explicit',
     ownerProjectId: typeof entry.ownerProjectId === 'string' ? entry.ownerProjectId : '',
     hits: Number(maintenance.hits) || 0,
     merges: Number(maintenance.merges) || 0,
@@ -130,7 +137,7 @@ function fromFlat(record, status) {
     id: record.id,
     revision: Number(record.revision) || 1,
     status: status || (record.status === 'archived' ? 'archived' : 'active'),
-    origin: typeof record.origin === 'string' && record.origin ? record.origin : 'user_explicit',
+    origin: ORIGINS.includes(record.origin) ? record.origin : 'user_explicit',
     ownerProjectId: record.ownerProjectId || '',
     createdAt: record.created || at,
     updatedAt: at,
@@ -1113,7 +1120,7 @@ function applyDraft(scope, index, source, now, options = {}) {
       lastUsed: now,
       merges: (record.merges || 0) + 1,
       status: 'active',
-      source: record.source || (source && source.source) || 'user_explicit',
+      origin: originOf(source) === 'user_explicit' ? (ORIGINS.includes(record.origin) ? record.origin : 'user_explicit') : originOf(source),
     };
     nextRecord.maintenance = { ...(record.maintenance || {}) };
     if (summaryFull) nextRecord.maintenance.summaryFull = summaryFull;
@@ -1165,7 +1172,7 @@ function applyDraft(scope, index, source, now, options = {}) {
     lastUsed: now,
     revision: 1,
     status: 'active',
-    source: source && source.source === 'observed' ? 'observed' : 'user_explicit',
+    origin: originOf(source),
     hits: 0,
     merges: 0,
     versions: [],
@@ -1315,7 +1322,7 @@ function scoreQuery(item, grams, raw) {
 /** 项目记忆总开关：读当前层，缺字段按开启。 */
 export function controlStatus(scope) {
   const index = loadIndex(scope);
-  return { ...(index.__control || state.controlOf(null)) };
+  return index.__control ? state.controlOf({ control: index.__control }) : state.controlOf(null);
 }
 
 export function setMemoryEnabled(scope, enabled, options = {}) {
@@ -1340,6 +1347,53 @@ export function setMemoryEnabled(scope, enabled, options = {}) {
   });
 }
 
+/** 面板一次改开关和触发方式：同一把锁里落盘，不会只改一半。 */
+export function setMemoryControl(scope, options = {}, meta = {}) {
+  return withLock(scope, () => {
+    const before = loadIndex(scope);
+    const operationId = typeof meta.operationId === 'string' ? meta.operationId : '';
+    let applied = null;
+    try {
+      state.transact(scope, {
+        operationId,
+        expectCreate: !before.__exists,
+        expected: before.__exists ? { generation: before.generation, epoch: before.epoch } : null,
+      }, (draft) => {
+        applied = state.applyControl(draft, options.enabled, options.mode);
+        return applied.changed ? { changed: true } : { changed: false };
+      });
+    } catch (error) {
+      if (error && error.code === 'conflict') return { ok: false, reason: '项目状态刚被改过，重试一次', retry: true };
+      return { ok: false, reason: error instanceof Error ? error.message : '记忆设置没有改动' };
+    }
+    return { ok: true, changed: Boolean(applied && applied.changed), ...controlStatus(scope) };
+  });
+}
+
+/** 项目的触发方式：自适应 / 仅搜索 / 关闭；空值跟随插件配置，不改全局默认。 */
+export function setRecallMode(scope, mode, options = {}) {
+  if (mode !== 'adaptive' && mode !== 'tool_only' && mode !== 'off') return { ok: false, reason: '不认识这个触发方式' };
+  return withLock(scope, () => {
+    const before = loadIndex(scope);
+    const operationId = typeof options.operationId === 'string' ? options.operationId : '';
+    let applied = null;
+    try {
+      state.transact(scope, {
+        operationId,
+        expectCreate: !before.__exists,
+        expected: before.__exists ? { generation: before.generation, epoch: before.epoch } : null,
+      }, (draft) => {
+        applied = state.applyControl(draft, undefined, mode);
+        return applied.changed ? { changed: true } : { changed: false };
+      });
+    } catch (error) {
+      if (error && error.code === 'conflict') return { ok: false, reason: '项目状态刚被改过，重试一次', retry: true };
+      return { ok: false, reason: error instanceof Error ? error.message : '触发方式没有改动' };
+    }
+    return { ok: true, changed: Boolean(applied && applied.changed), ...controlStatus(scope) };
+  });
+}
+
 /**
  * 项目实验开关：权威状态里缺字段即关闭。状态只回可核验事实，不编学习分数。
  * 关闭时保留已完成成果；试用条目暂停，等新的有效反馈或明确管理动作再复核。
@@ -1707,7 +1761,7 @@ export function readLinks(scope, id, options = {}) {
         if (target) links.push({ type: link.type || 'related', ...target });
         else links.push({ type: link.type || 'related', id: link.id, status: 'invalid' });
       }
-      return { id, links, scope: source.key === 'global' ? 'global' : 'project', status: view.statusOf(record, options.context || {}) };
+      return { id, title: record.title || '', links, scope: source.key === 'global' ? 'global' : 'project', status: view.statusOf(record, options.context || {}) };
     }
     return null;
   });
@@ -2140,7 +2194,8 @@ export function acceptCandidate(scope, key, operationId = '') {
       return { ok: false, reason: '那条记忆在你确认前改过了，重新建议一次' };
     }
     /** 只把建议里真有的字段交给写入：省略表示保持，显式空正文清空；旧候选没有 has 时按有没有值回退。 */
-    const source = { title: draft.title };
+    /** 候选正文是模型起草的，人只确认要不要留；来源照实记。 */
+    const source = { title: draft.title, origin: 'model_drafted' };
     const has = draft.has && typeof draft.has === 'object' ? draft.has : null;
     if (has) {
       if (has.summary) source.summary = draft.summary;
@@ -2465,7 +2520,8 @@ function machineBoundText(source) {
 
 /**
  * 适用范围判定：内容/依据的普适性优先，模型声明的 scope 只是提案。
- * 模型说 global、但正文写死了本机路径或依据是本机文件时，先留在项目层（或问一次条件）。
+ * 写死了本机路径/端口又没有声明适用环境时留在项目层；声明了机器/系统条件的
+ * 本机流程可以进全局层——换台机器条件不成立，自然不会拿出来用。
  */
 export function routeScope(draft, options = {}) {
   const source = draft || {};
@@ -2477,6 +2533,16 @@ export function routeScope(draft, options = {}) {
   const evidence = typeof source.evidenceRef === 'string' ? source.evidenceRef.trim() : '';
   /** 依据本身是本机文件/路径的，不能算通用流程；正文里带本机痕迹同理。 */
   const machineBound = machineBoundText(source) || (evidence ? machineBoundText({ title: evidence }) : false);
+  /** 声明了机器/系统条件，本机痕迹就被这条条件收住：规则仍可搬到所有满足条件的机器上。 */
+  const envScoped = (() => {
+    try {
+      return (view.normalizeConditions(source.conditions) || []).some((item) => ENVIRONMENT_KEYS.includes(item.key));
+    } catch {
+      return false;
+    }
+  })();
+  /** 真正挡回项目层的只有「本机痕迹 + 没有声明适用环境」；只写命令名不算本机痕迹。 */
+  const machineConflict = machineBound && !envScoped;
   const base = { chosenScope: '', reasonCode: '', requiredConditions: [], needsScope: false, explicit };
   /** 通用层拿不出普适证据时：有项目就留在项目层，没有就问一次运行环境。 */
   const fallbackToProject = (reasonCode) => {
@@ -2492,11 +2558,14 @@ export function routeScope(draft, options = {}) {
   const humanConfirmed = options.humanScope === true || source.scopeConfirmed === true;
   if (durability === 'task') return { ...base, needsScope: true, reasonCode: 'task_state' };
   if (explicit) {
-    /** 模型自己填的 global 只是提案：本机痕迹、项目事实、无依据的通用流程都按提案降级。 */
+    /**
+     * 显式 scope 代表「用户这个消息里要的那一层」：这是唯一能让全局层落地的输入，
+     * 所以不能再按模型自荐降级，只有本机痕迹和项目事实两种硬冲突能改落点。
+     * 没显式 scope 时才用 memoryClass 提案，缺可搬依据的流程留在项目层。
+     */
     if (explicit === 'global' && !humanConfirmed) {
-      if (machineBound) return fallbackToProject('machine_bound_scope');
+      if (machineConflict) return fallbackToProject('machine_bound_scope');
       if (cls === 'project_fact') return fallbackToProject('model_global_project_fact');
-      if (cls === 'portable_procedure' && !evidence) return fallbackToProject('unbound_evidence');
     }
     if (explicit === 'project' && !projectReady) {
       const reasonCode = options.project && options.project.confirmed === false ? 'unconfirmed_project' : 'no_project';
@@ -2520,11 +2589,13 @@ export function routeScope(draft, options = {}) {
   }
   if (cls === 'personal_preference') {
     /** 偏好也分「我的习惯」和「这台机器上的习惯」：后者绑机器，不进通用层。 */
-    if (machineBound) return fallbackToProject('machine_bound_preference');
+    if (machineConflict) return fallbackToProject('machine_bound_preference');
     return { ...base, chosenScope: 'global', reasonCode: 'class_personal_preference' };
   }
   if (cls === 'portable_procedure') {
-    if (machineBound) return fallbackToProject('machine_bound_procedure');
+    if (machineConflict) return fallbackToProject('machine_bound_procedure');
+    /** 带适用环境条件的本机流程：条件成立时才用，换台机器自然不生效。 */
+    if (envScoped) return { ...base, chosenScope: 'global', reasonCode: 'machine_scoped_procedure' };
     /** 说能搬去别的项目，就要有能搬的依据；没有就先留在本项目。 */
     if (!evidence) return fallbackToProject('unbound_evidence');
     return { ...base, chosenScope: 'global', reasonCode: 'class_portable_procedure' };

package/test/client.test.mjs

@@ -28,7 +28,7 @@ assert.equal(panel.name, 'shell.overlay');
 assert.equal(panel.order, 30);
 
 const EMPTY_CHILDREN = [];
-const { metaOf, citationOf, citationsOfMeta, citationsOfTurn, dedupe, undoRefOf, graphOf, ruleGraphOf, processingStatusOf, currentBodyOf, historyDiffsOf, MemoryPanel, MemoryGraph, displayKeyOf, readDisplaySettings, writeDisplaySettings, graphViewOf, viewModeOf, filterRecords, projectionOf, failureStateOf, evidenceTextOf, evidenceMetaOf, MemoryPalace, palaceRoomsOf, palaceRoomPageOf, palacePageWindow, palaceToggleOf, palaceMotionOf, palaceRoomIdOf, TurnMemory, refMetaOf, explainKeyOf, explainModeOf, setExplainMode, recallLineOf, agoLabel, checkupOf, titleCountsOf, rowKeyOf, rowKeepFlags } = seen;
+const { metaOf, citationOf, citationsOfMeta, citationsOfTurn, dedupe, undoRefOf, graphOf, ruleGraphOf, processingStatusOf, currentBodyOf, historyDiffsOf, MemoryPanel, MemoryGraph, displayKeyOf, readDisplaySettings, writeDisplaySettings, graphViewOf, viewModeOf, filterRecords, projectionOf, failureStateOf, evidenceTextOf, evidenceMetaOf, MemoryPalace, palaceRoomsOf, palaceRoomPageOf, palacePageWindow, palaceToggleOf, palaceMotionOf, palaceRoomIdOf, TurnMemory, refMetaOf, explainKeyOf, explainModeOf, setExplainMode, recallLineOf, agoLabel, checkupOf, refSectionRowsOf, refDetailTitleOf, versionLine, titleCountsOf, rowKeyOf, rowKeepFlags } = seen;
 
 // 图谱只按真实数据画：共享标签成枢纽，显式关联成边，位置由 id 决定。
 const graph = graphOf([
@@ -288,6 +288,9 @@ assert.equal(refMetaOf(typedSearch), '[全局]');
 assert.equal(citationOf({ kind: 'memory-read', title: 'P', recordKind: 'procedure', scope: 'project', revision: 2 }, 'memory-read').entryKind, 'procedure');
 assert.equal(refMetaOf({ scope: 'project', origin: 'user_explicit' }), '[项目]');
 assert.equal(refMetaOf({ scope: 'global', origin: 'project_evolution' }), '[全局][自进化]');
+/** 模型整理稿只多一个信任标记，层级仍按落盘作用域。 */
+assert.equal(refMetaOf({ scope: 'project', origin: 'model_drafted' }), '[项目][模型]');
+assert.equal(citationOf({ kind: 'memory-save', title: 'M', scope: 'global', revision: 1, origin: 'model_drafted', changed: true }, 'memory-save').origin, 'model_drafted');
 /** 更新距今照旧，只是不再拼类型与「你记的」。 */
 const aged = citationOf({ kind: 'preference', title: 'C', scope: 'global', revision: 1, updated: new Date(Date.now() - 3 * 86_400_000).toISOString() }, 'memory-search');
 assert.equal(aged.entryKind, 'preference');
@@ -295,6 +298,23 @@ assert.equal(refMetaOf(aged), '[全局] · 3 天前更新');
 assert.equal(agoLabel(''), '');
 assert.equal(agoLabel(new Date(Date.now() - 40 * 86_400_000).toISOString()), '');
 
+// 会话里的正文跟着被点的那条走：点 B，正文夹在 B 与 C 之间，不甩到列表末尾。
+const inlineRefs = [
+  { key: 'a', revision: 1, title: 'A' },
+  { key: 'b', revision: 2, title: 'B' },
+  { key: 'c', revision: 3, title: 'C' },
+];
+const rowOfRef = (item) => item.key;
+const detailOfRef = () => 'detail';
+assert.deepEqual(refSectionRowsOf(inlineRefs, { key: 'b', ref: { revision: 2 } }, rowOfRef, detailOfRef), ['a', 'b', 'detail', 'c']);
+assert.deepEqual(refSectionRowsOf(inlineRefs, { key: 'a', ref: { revision: 1 } }, rowOfRef, detailOfRef), ['a', 'detail', 'b', 'c']);
+assert.deepEqual(refSectionRowsOf(inlineRefs, null, rowOfRef, detailOfRef), ['a', 'b', 'c']);
+// 抬头的永远是记忆标题；项目名只留在下一行来源里，不再单独顶一行被当成标题。
+assert.equal(refDetailTitleOf({ title: 'DSH', ref: { title: '视频预览插件重启后仍缓存旧代码' } }), '视频预览插件重启后仍缓存旧代码');
+assert.equal(refDetailTitleOf({ ref: { title: '标题' } }), '标题');
+assert.equal(versionLine({ scope: 'project', scopeLabel: 'DSH', status: 'active' }), '项目 · DSH');
+assert.equal(versionLine({ scope: 'global', status: 'active' }), '全局');
+
 // 解释模式按会话存在本机，缺省关闭；关着零命中不出提示，打开后才说原因。
 assert.equal(explainModeOf('s1'), false);
 const quietRefs = [];
@@ -335,9 +355,13 @@ assert.deepEqual(rowKeepFlags([rowKeyOf('memory_read', blockedBlock('memory · s
 // 面板要能回答「为什么这次没提醒我」：只给结论和条数，不露原因码。
 assert.equal(recallLineOf(null), '');
 assert.equal(recallLineOf({ reason: 'hit', cards: 1, matched: 1 }), '上次自动提醒 1 条');
+assert.equal(recallLineOf({ reason: 'hit', cards: 1, matched: 1, at: new Date(Date.now() - 120000).toISOString() }), '上次自动提醒 1 条 · 2 分钟前');
+assert.equal(recallLineOf({ reason: 'no_overlap', at: new Date().toISOString() }), '上次没提醒，没有匹配的记忆 · 刚刚');
 assert.equal(recallLineOf({ reason: 'budget', cards: 0, matched: 2 }), '上次没提醒，2 条相关记忆，本轮自动提醒已用满');
 assert.equal(recallLineOf({ reason: 'needs_context', cards: 0, matched: 1 }), '上次没提醒，1 条相关记忆，适用条件未确认');
+assert.equal(recallLineOf({ reason: 'conflict', cards: 0, matched: 2 }), '上次没提醒，2 条相关记忆，存在冲突的结论');
 assert.equal(recallLineOf({ reason: 'no_overlap', cards: 0, matched: 0 }), '上次没提醒，没有匹配的记忆');
+assert.equal(recallLineOf({ reason: 'expired', cards: 0, matched: 2 }), '上次没提醒，相关内容已经过期');
 assert.equal(recallLineOf({ reason: 'memory_off', cards: 0, matched: 0 }), '上次没提醒，记忆已关闭');
 assert.equal(recallLineOf({ reason: 'tools_only', cards: 0, matched: 0 }), '上次没提醒，只在你问时检索');
 assert.equal(recallLineOf({ reason: 'made_up', cards: 0, matched: 0 }), '');

package/test/contract.test.mjs

@@ -41,6 +41,29 @@ fs.mkdirSync(cwd, { recursive: true });
 const exec = (name, args) => defs.get(name).execute(args, { agent: { cwd, session: { id: 'session-contract', header: { cwd } } } });
 const render = (name, args, value) => defs.get(name).output.render(args, value)[0].text;
 
+/** 按已注册的 output.schema 校验真实 execute 结果：宿主校验失败会整条工具报错。 */
+function assertSchema(name, value) {
+  const schema = defs.get(name).output.schema;
+  const walk = (node, data, where) => {
+    if (node.type === 'object') {
+      assert.ok(data && typeof data === 'object' && !Array.isArray(data), `${where} 应为对象`);
+      for (const key of node.required || []) assert.ok(key in data, `${where} 缺少 ${key}`);
+      for (const [key, item] of Object.entries(data)) {
+        if (node.properties && node.properties[key]) walk(node.properties[key], item, `${where}.${key}`);
+        else assert.equal(node.additionalProperties, true, `${where} 多出 ${key}`);
+      }
+    } else if (node.type === 'array') {
+      assert.ok(Array.isArray(data), `${where} 应为数组`);
+      if (node.items) data.forEach((item, index) => walk(node.items, item, `${where}[${index}]`));
+    } else if (node.type === 'string') assert.equal(typeof data, 'string', `${where} 应为字符串`);
+    else if (node.type === 'boolean') assert.equal(typeof data, 'boolean', `${where} 应为布尔值`);
+    else if (node.type === 'integer') assert.ok(Number.isInteger(data), `${where} 应为整数`);
+    else if (node.type === 'number') assert.equal(typeof data, 'number', `${where} 应为数字`);
+    if (node.enum) assert.ok(node.enum.includes(data), `${where} 不在枚举里`);
+  };
+  walk(schema, value, name);
+}
+
 function call(pathname, payload, options = {}) {
   const req = new EventEmitter();
   req.method = options.method ?? 'POST';
@@ -177,7 +200,11 @@ const read = await exec('memory_read', { title: saved.title });
 assert.equal(read.status, 'needs_context');
 assert.equal(read.body, '', '条件未知时标题只能定位，不能证明适用，正文不返回');
 assert.doesNotMatch(render('memory_read', {}, read), /发版/);
+assertSchema('memory_read', read);
 const plain = await exec('memory_read', { title: distinct.title });
+/** 工具写入的来源一路带到正文回执：界面靠它标 [模型]，不靠猜。 */
+assert.equal(plain.origin, 'model_drafted');
+assertSchema('memory_read', plain);
 assert.equal(plain.body, '另一条');
 assert.equal(plain.revision, 1);
 assert.match(render('memory_read', {}, plain), /^memory · \[[^\]]+\] 「发布顺序是啥」/);
@@ -205,8 +232,42 @@ const readArchived = await exec('memory_read', { title: distinct.title });
 assert.equal(readArchived.status, 'archived');
 assert.equal(readArchived.body, '');
 assert.match(render('memory_read', { title: distinct.title }, readArchived), /^memory · 这条记忆已归档$/);
+assertSchema('memory_read', readArchived);
 assert.equal(await exec('memory_save', { title: '发布顺序是啥', summary: '发版前要按顺序做的事', body: '第三条' }).then((v) => v.merged), false);
 
+// ── 失败回执同样过输出 schema：不能再返裸 {error} 让界面渲染 undefined ──────────
+await exec('memory_save', { title: '跨层同名', summary: '项目层这一条', body: '项目正文' });
+/** 直接落全局层：正常保存有跨层相近拦截，同层/跨层同名只可能来自历史数据。 */
+store.saveEntry(store.globalScope(), { title: '跨层同名', summary: '全局层另一条', body: '全局正文', writeMode: 'patch' });
+/** 同名两层各有一条时，读哪条由 scope 决定：默认项目层，显式 global 才拿全局正文。 */
+const readTwin = await exec('memory_read', { title: '跨层同名' });
+assert.equal(readTwin.scope, 'project');
+assert.equal(readTwin.body, '项目正文');
+const readGlobalTwin = await exec('memory_read', { title: '跨层同名', scope: 'global' });
+assert.equal(readGlobalTwin.scope, 'global');
+assert.equal(readGlobalTwin.body, '全局正文');
+const readProjectTwin = await exec('memory_read', { title: '跨层同名', scope: 'project' });
+assert.equal(readProjectTwin.scope, 'project');
+assert.equal(readProjectTwin.body, '项目正文');
+const ambiguousSave = await exec('memory_save', { title: '别的标题', summary: '尝试改同名条目', updateTitle: '跨层同名' });
+assert.ok(ambiguousSave.error, '跨层同名要报改哪一层');
+assertSchema('memory_save', ambiguousSave);
+assert.match(render('memory_save', {}, ambiguousSave), /^memory · /);
+assert.doesNotMatch(render('memory_save', {}, ambiguousSave), /undefined|saved|merged/);
+const missingSave = await exec('memory_save', { title: '别的标题', summary: '没有这条', updateTitle: '根本不存在的条目' });
+assert.ok(missingSave.error);
+assertSchema('memory_save', missingSave);
+const badLink = await exec('memory_save', { title: '关联写法不对', summary: '关联要写标题', links: [{}] });
+assert.ok(badLink.error);
+assertSchema('memory_save', badLink);
+const missingLink = await exec('memory_save', { title: '关联目标不存在', summary: '目标没有落盘', links: [{ type: 'related', title: '根本没这条' }] });
+assert.ok(missingLink.error);
+assertSchema('memory_save', missingLink);
+assert.match(render('memory_save', {}, missingLink), /^memory · 没有「根本没这条」这条记忆/);
+
+// 成功回执也必须过同一份 schema
+for (const value of [saved, merged, patch, probe, distinct]) assertSchema('memory_save', value);
+
 // ── suggestion → keep → replay → reject ──────────────────────────────────────
 const suggested = await exec('memory_suggest', { title: '发布前跑文案检查', summary: '发版前先跑 ui 文案 lint', body: 'node ui-copy-lint.mjs', when: '发布前' });
 assert.equal(suggested.asked, true);
@@ -266,7 +327,28 @@ assert.equal((await call('/lite-memory/keep', {}, { method: 'GET' })).status, 40
 // ── global layer ─────────────────────────────────────────────────────────────
 const global = await exec('memory_save', { title: '回复用中文', summary: '用户要求回复用中文', scope: 'global' });
 assert.equal(global.scope, 'global');
+assert.equal(global.scopeNote, undefined, '正常落全局不该带降级说明');
 assert.match(render('memory_save', {}, global), /^memory · saved \[global\] "回复用中文"$/);
+
+// 显式写 global 也不再被悄无声息地改层：本机痕迹和项目事实各有一条能解释的降级。
+const machineGlobal = await exec('memory_save', {
+  title: '本机目录同步步骤',
+  summary: '流程里写了本机路径，写全局也会留在项目层',
+  body: '在 /Users/apple/Desktop/DSH 下改完再同步。',
+  scope: 'global',
+  memoryClass: 'portable_procedure',
+});
+assert.equal(machineGlobal.scope, 'project');
+assert.match(machineGlobal.scopeNote, /按本机痕迹留在项目层/);
+const factGlobal = await exec('memory_save', {
+  title: '发版顺序只在仓库成立',
+  summary: '项目事实换项目不成立，写全局也会留在项目层',
+  body: '这个仓库的发版顺序是先前置检查再打包。',
+  scope: 'global',
+  memoryClass: 'project_fact',
+});
+assert.equal(factGlobal.scope, 'project');
+assert.match(factGlobal.scopeNote, /按项目事实留在项目层/);
 const globalSearch = await exec('memory_search', { query: '回复用中文' });
 assert.equal(globalSearch.count, 1);
 assert.match(render('memory_search', {}, globalSearch), /\[global\] 「/);
@@ -584,8 +666,22 @@ const closedTool = await defs.get('memory_save').execute(
 );
 assert.equal(closedTool.changed, false);
 assert.equal(closedTool.reason, 'memory_disabled');
+assertSchema('memory_save', closedTool);
 assert.equal(closedTool.id, undefined);
+/** 关闭状态下的读取也只报状态，不返回正文。 */
+const closedRead = await defs.get('memory_read').execute({ title: closedSeed.title }, { agent: closedAgent });
+assert.equal(closedRead.status, 'memory_disabled');
+assert.equal(closedRead.body, undefined, '关闭时连空正文也不占位');
+assertSchema('memory_read', closedRead);
+assert.match(render('memory_read', {}, closedRead), /^memory · 记忆检索已关闭$/);
 assert.equal(Buffer.compare(closedBefore, fs.readFileSync(closedFile)), 0);
+const toolOnly = await call('/lite-memory/control', { sessionId: 'session-closed', enabled: true, mode: 'tool_only', operationId: 'op_mode_contract' });
+assert.equal(toolOnly.status, 200);
+assert.equal(toolOnly.body.enabled, true);
+assert.equal(toolOnly.body.mode, 'tool_only');
+const backToAuto = await call('/lite-memory/control', { sessionId: 'session-closed', enabled: true, mode: 'adaptive', operationId: 'op_mode_back_contract' });
+assert.equal(backToAuto.status, 200);
+assert.equal(backToAuto.body.mode, 'adaptive');
 const reopened = await call('/lite-memory/control', { sessionId: 'session-closed', enabled: true, operationId: 'op_reopen_contract' });
 assert.equal(reopened.status, 200);
 const reopenedSnapshot = await call('/lite-memory/evolution', { sessionId: 'session-closed', learningAction: 'snapshot' });
@@ -756,6 +852,11 @@ assert.ok(linkedRecord && linkedTarget);
 assert.equal(linkedRecord.links.length, 1);
 assert.equal(linkedRecord.links[0].id, linkedTarget.id);
 assert.equal(linkedRecord.links[0].type, 'related');
+/** 关联清单也要给标题：只发内部 id 会让界面显示 undefined。 */
+const linkRead = await exec2('memory_read', { title: '关联目标乙', view: 'links' });
+assert.equal(linkRead.title, '关联目标乙');
+assert.match(linkRead.links, /关联目标甲/);
+assert.doesNotMatch(render('memory_read', { title: '关联目标乙', view: 'links' }, linkRead), /undefined/);
 /** 更新句柄也是标题：抄标题改这一条，不需要任何内部编号。 */
 const retitled = await exec2('memory_save', { updateTitle: linkedA.title, title: linkedA.title, summary: '改过的摘要' });
 assert.equal(retitled.changed, true);
@@ -887,6 +988,10 @@ const ovSecond = await defs.get('memory_save').execute(
   { title: '封面留白', summary: '封面别放满', body: '右侧留白。', tags: ['封面'] },
   { agent: ovAgent },
 );
+await defs.get('memory_save').execute(
+  { title: '发布窗口', summary: '只在周四晚上发版', body: '周四晚上再发版。', when: '周四晚上' },
+  { agent: ovAgent },
+);
 await defs.get('memory_save').execute(
   { title: '观察全局', summary: '跨项目通用说明', body: '全局正文。', scope: 'global' },
   { agent: ovAgent },
@@ -908,7 +1013,7 @@ assert.equal(ov.body.selected.evolution.enabled, false);
 assert.ok(Array.isArray(ov.body.selected.evolution.rules));
 assert.ok(ov.body.selected.records.some((row) => row.title === '开场先给结论'));
 assert.equal(ov.body.selected.records.some((row) => 'body' in row), false, '列表不带正文');
-assert.equal(ov.body.selected.stats.total, 2);
+assert.equal(ov.body.selected.stats.total, 3);
 assert.equal(ov.body.selected.stats.tags, 3);
 assert.equal(JSON.stringify(ov.body).includes('"dir"'), false, '不暴露内部目录');
 assert.equal(JSON.stringify(ov.body).includes(process.env.DSH_HOME), false);
@@ -971,6 +1076,30 @@ const ovGlobalEdit = await call('/lite-memory/entry', {
 assert.equal(ovGlobalEdit.status, 409, '全局层在项目会话里只读');
 assert.equal((await call('/lite-memory/entry', { sessionId: 'session-overview', scopeKey: ov.body.current.key, id: ovRow.id, title: '', body: 'x', expectedRevision: 1 })).status, 400);
 
+// 适用范围只有两种来源：模型当时没确认，或人看过之后明确确认。面板能补后者，不替模型猜。
+const ovPendingRow = ov.body.selected.records.find((row) => row.title === '发布窗口');
+assert.equal(ovPendingRow.applicability, 'unresolved');
+const ovPendingBody = await call('/lite-memory/body', { sessionId: 'session-overview', title: '发布窗口', scopeKey: ov.body.current.key });
+assert.equal(ovPendingBody.status, 200);
+assert.equal(ovPendingBody.body.applicability, 'unresolved');
+const ovConfirmBad = await call('/lite-memory/entry', {
+  sessionId: 'session-overview', scopeKey: ov.body.current.key, id: ovPendingRow.id,
+  title: '发布窗口', body: '周四晚上再发版。', expectedRevision: ovPendingRow.revision, applicability: 'always',
+});
+assert.equal(ovConfirmBad.status, 400, '三档之外的值不能写进记忆');
+const ovConfirm = await call('/lite-memory/entry', {
+  sessionId: 'session-overview', scopeKey: ov.body.current.key, id: ovPendingRow.id,
+  title: '发布窗口', body: '周四晚上再发版。', expectedRevision: ovPendingRow.revision,
+  applicability: 'all_in_scope', conditions: [],
+});
+assert.equal(ovConfirm.status, 200);
+assert.equal(ovConfirm.body.ok, true);
+const ovPendingAfter = await call('/lite-memory/body', { sessionId: 'session-overview', title: '发布窗口', scopeKey: ov.body.current.key });
+assert.equal(ovPendingAfter.body.applicability, 'all_in_scope');
+assert.deepEqual(ovPendingAfter.body.conditions, []);
+assert.equal(store.readEntry(store.scopeOf(ovCwd), ovPendingRow.id).applicability, 'all_in_scope', '确认落到那一条上');
+assert.equal(store.readEntry(store.scopeOf(ovCwd), ovRow.id).applicability, 'all_in_scope', '别条不受影响');
+
 // 详情按服务端枚举过的 scopeKey 取；内部路径、未知键一律不放行。
 // 宫殿里点开一条只走这个只读入口：不改记忆、不记用量、不占额度。
 const ovStateFile = path.join(store.scopeOf(ovCwd).dir, 'state.json');

package/test/control.test.mjs

@@ -65,6 +65,28 @@ const seedRule = (scope, title) => {
 const scopeOf = (dir) => store.scopeOf(dir);
 const toggle = (scope, enabled) => store.setMemoryEnabled(scope, enabled, { operationId: `op-${Math.random().toString(16).slice(2)}` });
 
+/* C00：触发方式按项目存，切到「仅搜索」不改总开关，关闭时也不偷偷恢复授权。 */
+{
+  const scope = scopeOf(mkdir('mode'));
+  assert.equal(store.controlStatus(scope).enabled, true);
+  assert.equal(store.controlStatus(scope).mode, '');
+  const epochBefore = store.controlStatus(scope).epoch;
+  const searched = store.setRecallMode(scope, 'tool_only', { operationId: 'op-mode-search' });
+  assert.equal(searched.ok, true);
+  assert.equal(searched.mode, 'tool_only');
+  assert.equal(store.controlStatus(scope).enabled, true, '只改触发方式，不动总开关');
+  assert.notEqual(store.controlStatus(scope).epoch, epochBefore, '改触发方式要换掉旧回执的凭据');
+  assert.equal(store.setRecallMode(scope, '自动', { operationId: 'op-mode-bad' }).ok, false);
+  assert.equal(store.controlStatus(scope).mode, 'tool_only', '不认识的值不落盘');
+  assert.equal(toggle(scope, false).ok, true);
+  assert.equal(store.setRecallMode(scope, 'adaptive', { operationId: 'op-mode-off' }).mode, 'adaptive');
+  assert.equal(store.controlStatus(scope).enabled, false, '关闭时改触发方式不能顺手打开');
+  const combined = store.setMemoryControl(scope, { enabled: true, mode: 'tool_only' }, { operationId: 'op-mode-combined' });
+  assert.equal(combined.ok, true);
+  assert.equal(combined.enabled, true);
+  assert.equal(combined.mode, 'tool_only');
+}
+
 /* C01：总开关关闭后，自动注入、全局召回、检索、读取、写入、学习全部停。 */
 {
   const dir = mkdir('off');

package/test/evolution-read.test.mjs

@@ -35,6 +35,8 @@ function boot(mode = 'adaptive') {
   apply(ctx, { mode });
   const provider = promptContexts.find((entry) => entry.name === 'lite-memory:recall');
   assert.ok(provider, 'recall provider registered');
+  /* CI 冷启动偶尔超过召回耗时上限，逻辑断言不该被「这轮先不注入」判失败。 */
+  globalThis.__liteMemoryRecall?.setDeadlineMs?.(5000);
   const exec = (name, args, agent) => defs.get(name).execute(args, { agent });
   const preStep = (payload, decision) => handlers.get('agent/pre-step').at(-1)(payload, async () => decision);
   const text = (agent, signal) => provider.text({ agent, signal });

package/test/learning.test.mjs

@@ -965,10 +965,11 @@ test('L03b 明确长期要求整理为空时也留下规则', () => {
 test('L03c 兜底不把没说范围的要求抬成全项目规则', () => {
   const vague = learning.pendingChangeFrom({ text: '以后口播开头先给结论。', cue: { explicitLongTerm: true } });
   assert.equal(vague.applicability, 'unresolved');
+  /** 「所有口播」限定的是栏目对象，不是整个项目；没有可信栏目就留待确认，不能扩成全项目。 */
   const allLines = learning.pendingChangeFrom({ text: '以后所有口播都先给结论。', cue: { explicitLongTerm: true } });
-  assert.equal(allLines.applicability, 'all_in_scope', '「所有口播」按项目层全范围收集');
+  assert.equal(allLines.applicability, 'unresolved', '「所有口播」不能当全项目授权');
   const always = learning.pendingChangeFrom({ text: '以后一律先给结论。', cue: { explicitLongTerm: true } });
-  assert.equal(always.applicability, 'all_in_scope', '「一律」按项目层全范围收集');
+  assert.equal(always.applicability, 'unresolved', '「一律」不能单独当项目范围');
   assert.deepEqual(vague.conditions, []);
   const scoped = learning.pendingChangeFrom({ text: '以后口播开头先给结论。', cue: { explicitLongTerm: true, taskKind: 'video' } });
   assert.equal(scoped.applicability, 'conditional');

package/test/lexical.test.mjs

@@ -5,6 +5,7 @@ import path from 'node:path';
 
 process.env.DSH_HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-lexical-'));
 const store = await import('../store.js');
+const view = await import('../view.js');
 
 const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-lexical-scope-'));
 const scope = store.scopeOf(dir);
@@ -19,10 +20,15 @@ const add = (title, extra = {}) => store.upsert(scope, {
 add('digital signal 调试', { tags: ['音频'] });
 add('怎么做发布检查', { tags: ['发布'] });
 add('git 提交前跑检查', { tags: ['git'] });
+add('插件改名与合并', { tags: ['插件开发', '启动失败'], summary: '改包名要同步 factory ID，否则启动失败' });
+add('启动服务器', { tags: ['启动'] });
 
 /* 英文按整词：git 不能因为共享 gi/it 命中 digital。 */
 assert.equal(store.search(scope, 'git', 5).some((row) => row.title.includes('digital')), false);
 assert.equal(store.search(scope, 'digital', 5).some((row) => row.title.includes('digital')), true);
+/* 中英混排同样按整词：英文词没出现，中文词重合再多也不能替它作证。 */
+assert.equal(store.search(scope, '排查 git', 5).some((row) => row.title.includes('digital')), false);
+assert.equal(store.search(scope, '排查 git', 5).some((row) => row.title.includes('git 提交前跑检查')), true);
 
 /* 只重合「怎么」这类高频词不算命中。 */
 assert.equal(store.search(scope, '这个怎么弄', 5).length, 0);
@@ -30,4 +36,20 @@ assert.equal(store.search(scope, '这个怎么弄', 5).length, 0);
 /* 实词仍然命中。 */
 assert.equal(store.search(scope, '发布检查', 5).some((row) => row.title.includes('怎么做发布检查')), true);
 
+/* 「启动」只是「启动失败」的一半，不能把改包名的记忆带进自动提示。 */
+const renameRecord = store.search(scope, '插件改名与合并', 1)[0];
+const serverRecord = store.search(scope, '启动服务器', 5).find((row) => row.title === '启动服务器');
+assert.equal(view.matchScore(renameRecord, '启动服务器').score < view.MATCH_FLOOR, true);
+assert.equal(view.matchScore(serverRecord, '启动服务器').score >= view.MATCH_FLOOR, true);
+/* 两个词都落在同一个标签上才继续算命中。 */
+assert.equal(store.search(scope, '启动失败怎么查', 5).some((row) => row.title === '插件改名与合并'), true);
+
+/* 续说一句没有检索词：只有明确的「继续/然后」才沿用上一轮，别把短问题也接上去。 */
+for (const text of ['继续', '继续。', '然后呢？', '接着', 'go on', 'continue']) {
+  assert.equal(view.isContinuationQuery(text), true, text);
+}
+for (const text of ['继续优化轻量化记忆与前端展示逻辑', '然后发布', '样式', 'next steps for release']) {
+  assert.equal(view.isContinuationQuery(text), false, text);
+}
+
 console.log('lexical.test.mjs: all passed');

package/test/recall.test.mjs

@@ -157,6 +157,32 @@ assert.ok(cards.length <= 3);
 for (const line of cards) assert.match(line, CARD_LINE);
 assert.doesNotMatch(preparedText, /第 .* 版/);
 assert.equal(bootA.provider.text({ agent: agentA, signal: signalA }), preparedText, 'frozen between calls');
+/** 到期在输出前复核：投影之后过期的那条不再发给模型。 */
+const expiring = bootA.debug.preparedOf(agentA);
+assert.ok(expiring.lines.length >= 1, 'prepared cards carry their own deadline');
+const firstLine = expiring.lines[0].line;
+expiring.lines[0].validUntil = new Date(Date.now() - 1000).toISOString();
+const afterExpiry = bootA.provider.text({ agent: agentA, signal: signalA });
+assert.ok(!afterExpiry.includes(firstLine), 'expired card withheld at emit');
+assert.match(afterExpiry, /^已有记忆可能相关/);
+expiring.lines[0].validUntil = '';
+assert.equal(bootA.provider.text({ agent: agentA, signal: signalA }), preparedText, 'unexpired card still delivered');
+
+// A02b：同一会话里只说「继续」时沿用上一句的查询，短追问也能接上刚才那条记忆。
+const contAgent = makeAgent('agent-cont', cwdA);
+const contSignal = signal();
+await bootA.preStep({ agent: contAgent, signal: contSignal, turn: 'c1' }, enter(human('发布前文案检查要怎么过？')));
+const contFirst = bootA.debug.preparedOf(contAgent);
+assert.ok(contFirst && contFirst.cards.length, 'first turn recalls the publish rule');
+assert.match(contFirst.query, /发布前文案检查/);
+const contSignal2 = signal();
+await bootA.preStep({ agent: contAgent, signal: contSignal2, turn: 'c2' }, enter(human('继续')));
+const contNext = bootA.debug.preparedOf(contAgent);
+assert.ok(contNext, 'short continuation still prepares a snapshot');
+assert.match(contNext.query, /^继续 /);
+assert.match(contNext.query, /发布前文案检查/, 'continuation carries the previous query');
+assert.ok(contNext.cards.length, 'continuation still resolves cards');
+assert.ok(contNext.cards.some((card) => /文案检查/.test(card.title || card.line || '')), 'same topic comes back');
 
 // A03：provider 纯内存，不写盘、不动 hits。
 const statePath = path.join(scopeA.dir, 'state.json');
@@ -532,3 +558,30 @@ console.log('recall.test.mjs: ok');
   assert.doesNotMatch(runtime.provider.text({ agent, signal: sig }), /Digital asset catalog/);
   assert.equal(store.search(scopeEn, 'git', 5).length, 0, '手动搜索也不给这条');
 }
+
+// A25：用户这句话没提动作时，用上一轮助手的话和工具名补一次查询；补不到不盖掉原判断。
+{
+  const cwdAct = mkdir('action');
+  const scopeAct = store.scopeOf(cwdAct);
+  save(scopeAct, {
+    title: '改完 client.js 先重载宿主',
+    tags: ['client.js', '重载'],
+    summary: 'client.js 一改就要重载宿主，普通刷新覆盖不到',
+  });
+  const agent = makeAgent('agent-action', cwdAct);
+  const runtime = boot();
+  const first = signal();
+  await runtime.preStep({ agent, signal: first, turn: 't1' }, enter(human('这个怎么弄')));
+  assert.equal(runtime.provider.text({ agent, signal: first }), '', '只说「这个怎么弄」时不该凭空命中');
+  const assistantMessage = {
+    role: 'assistant',
+    id: 'asst-action-1',
+    content: [
+      { type: 'text', text: '我把改动写进文件了。' },
+      { type: 'tool-call', name: 'write', input: { file_path: '/tmp/act/client.js' } },
+    ],
+  };
+  const second = signal();
+  await runtime.preStep({ agent, signal: second, turn: 't2' }, enter(assistantMessage, human('这个怎么弄')));
+  assert.match(runtime.provider.text({ agent, signal: second }), /改完 client\.js 先重载宿主/, '动作侧线索要能召回预防型记忆');
+}