dsh-lite-memory 0.15.0 → 0.16.4

package/README.md

@@ -23,7 +23,7 @@ Lightweight memory for the DeepSeek Harness. No standing system prompt, nothing
 
 写入时分两层：默认只在这个项目生效；用户说「以后所有项目都这样」才进全局层（200 条起提示，硬上限 1000 条），检索时一起查。同一主题在不同前提下用 `when` 区分，各存一条。
 
-写入前先蒸馏：标题是结论，正文只留原则、判断规则和触发条件，不把具体尺寸、字号、层级、颜色或一次性数字记进来；需要这些值时按记忆里的指针查当前代码或文档。单条正文超过 1200 字节会被拒绝，先删细节再存。
+写入前先蒸馏：标题是结论，正文只留原则、判断规则和触发条件，不把具体尺寸、字号、层级、颜色或一次性数字记进来；需要这些值时按记忆里的指针查当前代码或文档。单条正文超过 4096 字节会被拒绝，先删细节再存；摘要超长自动截到 60 字。
 
 触发词：`记住`、`记一下`、`上次`、`规范`、`约定`、`路径`、`凭据怎么取`。
 
@@ -39,7 +39,7 @@ Those lines belong to the turn that made them: each turn is rebuilt from its own
 
 Writes land in one of two layers: the current project by default, or the global layer (warns past 200, hard ceiling 1000) when the user says the rule holds for every project. Both layers are searched together, and a `when` field separates the same subject under different preconditions.
 
-Before writing, distill: the title is the conclusion and the body keeps only the principle, decision rule and trigger condition. Concrete dimensions, font sizes, z-index, colors and one-off numbers stay out; the memory points at where to read the current value instead. A body over 1200 bytes is refused, so drop detail before saving.
+Before writing, distill: the title is the conclusion and the body keeps only the principle, decision rule and trigger condition. Concrete dimensions, font sizes, z-index, colors and one-off numbers stay out; the memory points at where to read the current value instead. A body over 4096 bytes is refused, so drop detail before saving; an over-long summary is truncated to 60 characters.
 
 ## 点一下就存 / One click, no turn
 
@@ -80,13 +80,13 @@ On the Memories tab, the search row also switches between list and graph; either
 - **0 依赖**，存储层无定时器、无监听、无网络，只有同步单文件写；写入用一把有超时的锁，别的进程正在写就明确报「忙」，不抢别人的锁。
 - 搜索最多 4 条、400 字；正文只在 `memory_read` 里出现，全文永不进上下文。
 - 普通检索只列当前有效的记录；已经归档或被更新替换的旧说法不混进来，要查历史得在 `memory_search` 里显式要 `history`。
-- 上限：单条正文 1200 字节、整库正文 512 KB、每层 1000 条、标题与摘要各 60 字；每层 200 条只当提示线。90 天未用只留 `id + 标题`。到了硬上限不拒绝新记忆：把同层最久没被读的一条移进归档，保存结果里写明是哪条（正文与完整记录都留着，可人工取回），单条本身超预算才报错；用户明确说「别记」也进归档。文件从不删除。
+- 上限：单条正文 4096 字节、整库正文 1 MB、每层 1000 条、标题与摘要各 60 字；每层 200 条只当提示线。90 天未用只留 `id + 标题`。到了硬上限不拒绝新记忆：把同层最久没被读的一条移进归档，用户固定过的规则不动，保存结果里写明是哪条（正文与完整记录都留着，可人工取回），单条本身超预算才报错；用户明确说「别记」也进归档。文件从不删除。
 - 一个项目一个目录，项目之间互相看不见。
 
 - **Zero dependencies.** The store has no timers, no listeners, no network — just synchronous single-file writes, guarded by a lock that gives up after 500 ms instead of stealing it.
 - Search returns at most 4 hits and 400 characters. Full text only appears in `memory_read`.
 - Normal search lists current entries only; archived notes and superseded wording stay out unless `memory_search` asks for `history`.
-- Limits: 1200 bytes per body, 512 KB of bodies per store, 1000 entries per layer, 60 characters per title or summary; 200 entries per layer is just a warning line. At the hard ceiling a save is never refused: the least recently read entry in the same layer moves to archive and the result names it (body and full record kept, restorable by hand); only an entry that alone exceeds the budget fails. Saying 「别记」 also archives. Files are never deleted.
+- Limits: 4096 bytes per body, 1 MB of bodies per store, 1000 entries per layer, 60 characters per title or summary; 200 entries per layer is just a warning line. At the hard ceiling a save is never refused: the least recently read entry in the same layer moves to archive (pinned rules are never evicted) and the result names it (body and full record kept, restorable by hand); only an entry that alone exceeds the budget fails. Saying 「别记」 also archives. Files are never deleted.
 - One directory per project, so projects never see each other's notes.
 
 ## 项目自进化〔实验〕 / Project self-evolution (experimental)

package/anchor.js

@@ -16,12 +16,22 @@ const REFERENCE_WORDS = /(这个|这条|这次|上次|之前|刚才|上面|前
 const TASK_STOP = new Set(['一个','一下','这个','那个','我们','你们','他们','什么','怎么','可以','需要','帮我','帮忙','请问','然后','现在','还是','就是','没有','不是','以及','关于','进行','使用','问题','任务','内容','时候','已经','如果','因为','所以','但是','而且','或者','这些','那些','这样','那样','一下','一点','一些']);
 /** 判断任务是否换了对象时，这些词只表示动作或指代，不算对象证据。 */
 const TASK_NOISE = /(继续|再做一期|下一期|再来一期|再开一期|续一集|再拍一期|接着|然后|接下来|现在|帮我|帮忙|这个|这条|这次|上次|之前|刚才|上面|前面|下面|后面|这里|还是|同样|再改|排查|处理|检查|看看|看一下|看下|修复|解决|优化|调整|修改|分析|研究|对比|评估|调研|测试|设计|实现|开发|搭建|部署|定位|复现|查一下|找一下|问题|任务|内容|一下)/g;
-const NEW_OBJECT_VERB = /(排查|检查|看看|看一下|看下|分析|研究|对比|评估|调研|测试|设计|实现|开发|搭建|部署|修复|解决|处理|定位|复现|查一下|找一下)/;
-const NEW_TASK_MARKER = /(现在|接下来|然后|下面|新任务|另一个|重新|改做|换个|换一个)/;
 /** 续接词后面还得跟一个动作，才算真正在改旧稿；单说「继续 / 这个 / 之前」不构成复用依据。 */
 const CONTINUATION_ACTION = /(继续|接着|然后|再|还是|同样)\s*(做|改|调|弄|看|写|处理|优化|调整|检查|完成)/;
+/** 明确指向刚才那一版作品的说法，是沿用旧范围的正面证据；「这版/那版」只是指示，不算旧稿。 */
+const OLD_WORK_REFERENCE = /(刚才那版|之前那版|上一版|原稿|旧稿)/;
+/** 旧稿被放下、否定或只作为话题提起时，不能因为它出现就恢复旧范围。 */
+const OLD_WORK_PAUSE = /(先放着|放着|放一边|先不|先别|别管|不用管|搁置|暂停|不做了|先不做|不用了)/;
+const OLD_WORK_ACTION = /(继续|接着|再改|改成|改一下|调整|优化|改改|开头|结尾|结构|节奏|语气|口吻|文案|措辞|细节|版本)/;
+/** 创作类与工程类任务的默认判断不同；同一主题从写口播切到排查代码，不能沿用旧栏目。 */
+const CONTENT_INTENT = /(口播|拍摄|录制|剪辑|文案|封面|字幕|直播|视频|选题|脚本|一期|栏目)/;
+const ENGINEERING_INTENT = /(代码|排查|故障|部署|调试|重构|接口|数据库|查询|报错|日志|服务|环境|依赖|测试|配置|修复)/;
+/** 这些词描述的是旧稿的某个方面，不是新对象；不该因为它们出现就撤销旧范围。 */
+const ASPECT_NOISE = /(节奏|速度|风格|语气|口吻|结构|长度|时长|篇幅|配色|字号|字体|标题|文案|措辞|逻辑|细节|开头|结尾|过渡|画面|镜头|音乐|音效|字幕|参数|格式|排版)/g;
+/** 程度、指代和虚词组成的二字片段不是对象证据。 */
+const GENERIC_CHARS = /[再更稍很太挺点些快慢多少好坏大小高低长短早晚新旧一二三四五六七八九十百千万个把的得地了着过吗呢吧啊]/;
 function taskTerms(value) {
-  const plain = text(value, 200).toLowerCase().replace(/[^\p{L}\p{N}]+/gu, ' ').replace(TASK_NOISE, ' ').replace(/\s+/g, ' ').trim();
+  const plain = text(value, 200).toLowerCase().replace(/[^\p{L}\p{N}]+/gu, ' ').replace(ASPECT_NOISE, ' ').replace(TASK_NOISE, ' ').replace(/\s+/g, ' ').trim();
   const terms = new Set();
   for (const word of plain.match(/[a-z][a-z0-9_-]{2,}/g) || []) terms.add(word);
   const runs = plain.match(/[\u4e00-\u9fff]+/g) || [];
@@ -29,7 +39,8 @@ function taskTerms(value) {
     if (TASK_STOP.has(run)) continue;
     for (let i = 0; i + 2 <= run.length; i += 1) {
       const gram = run.slice(i, i + 2);
-      if (!TASK_STOP.has(gram)) terms.add(gram);
+      if (TASK_STOP.has(gram) || GENERIC_CHARS.test(gram)) continue;
+      terms.add(gram);
     }
   }
   return terms;
@@ -37,19 +48,28 @@ function taskTerms(value) {
 /** 继承旧任务要有正面证据：新要求与本轮任务没有实质对象交集时，先按新任务处理。 */
 export function looksLikeNewTask(query, previousText) {
   const current = text(query, 200);
-  if (!current || isThanks(current) || isRevision(current)) return false;
+  if (!current || isThanks(current)) return false;
   const next = taskTerms(current);
   const previous = taskTerms(previousText);
   const cue = isContinuation(current) || REFERENCE_WORDS.test(current);
   /** 只剩指代或续接词时，必须另有动作才算续接；否则宁可换任务也不沿用旧范围。 */
   if (!next.size) return cue ? !CONTINUATION_ACTION.test(current) : false;
   if (!previous.size) return false;
+  /** 同一主题换了工作类型（口播 → 排查代码）是新任务，不靠对象词重叠判续作。 */
+  const nextKind = CONTENT_INTENT.test(current) ? (ENGINEERING_INTENT.test(current) ? '' : 'content')
+    : (ENGINEERING_INTENT.test(current) ? 'engineering' : '');
+  const previousKind = CONTENT_INTENT.test(previousText) ? (ENGINEERING_INTENT.test(previousText) ? '' : 'content')
+    : (ENGINEERING_INTENT.test(previousText) ? 'engineering' : '');
+  if (nextKind && previousKind && nextKind !== previousKind) return true;
   for (const term of next) if (previous.has(term)) return false;
-  /** 只有指代或「继续」时，还要有明确的新对象动作、转向词或新英文对象才换任务。 */
-  if (!cue) return true;
-  if (NEW_OBJECT_VERB.test(current) || NEW_TASK_MARKER.test(current)) return true;
-  for (const term of next) if (/^[a-z]/.test(term)) return true;
-  return false;
+  /** 指向旧稿还要有继续改它的动作；「旧稿先放着」「这版数据库配置怎么改」都算新任务。 */
+  if (OLD_WORK_REFERENCE.test(current) && !OLD_WORK_PAUSE.test(current) && OLD_WORK_ACTION.test(current)) return false;
+  /**
+   * 有实质对象词却跟旧任务没有任何交集：这就是新任务，不因为句首带了
+   * 「继续」「这个」就把旧范围连同正文一起搬过来。继承只认对象交集、
+   * 明确的旧稿指代，或者除动作/指代外没有新对象（上面两条）。
+   */
+  return true;
 }
 
 export function emptyTasks() {
@@ -76,6 +96,27 @@ export function isRevision(query) {
   return REVISE_WORDS.test(text(query, 160));
 }
 
+const NEGATED_SERIES = /(不要|不用|别|不按|不照|不是|并非|先不|不做|不搞|忽略|跳过|不管|别提)[^，。；！？\n]{0,10}$/;
+const MENTION_SERIES = /(日志|报错|错误|信息|提到|说到|包含|关键词|这个词|源码|代码|插件|文档|规则名|栏目名|分析)[^，。；！？\n]{0,10}$/;
+const PAUSED_SERIES = /^(先放着|先放|放一边|先不做|不做了|不用了|暂停)/;
+const PAUSED_BEFORE = /(先放着|先放|放一边|先不做|不做了|不用了|暂停)[^，。；！？\n]{0,4}$/;
+/** 提到栏目名不等于选中它：否定、引用、看源码或「先放着」都只是话题，不能建绑定。 */
+export function seriesChosenBy(query, series) {
+  const value = text(query, 400);
+  const name = text(series, 40);
+  if (!value || !name) return false;
+  let from = 0;
+  while (from <= value.length) {
+    const at = value.indexOf(name, from);
+    if (at < 0) return false;
+    const before = value.slice(Math.max(0, at - 14), at);
+    const after = value.slice(at + name.length);
+    if (!NEGATED_SERIES.test(before) && !MENTION_SERIES.test(before) && !PAUSED_BEFORE.test(before) && !PAUSED_SERIES.test(after)) return true;
+    from = at + name.length;
+  }
+  return false;
+}
+
 export function requestBatchKey(messageIds) {
   const ids = [...new Set((Array.isArray(messageIds) ? messageIds : []).map((id) => String(id || '')).filter(Boolean))].sort();
   if (!ids.length) return '';
@@ -271,7 +312,7 @@ export function routeTask(tasksInput, input = {}) {
   }
   const registered = (Array.isArray(input.registeredSeries) ? input.registeredSeries : []).map((item) => text(item, 40)).filter(Boolean);
   /** 用户在这句话里点名的栏目优先于旧栏目和项目默认值。 */
-  const namedSeries = registered.find((series) => series && query.includes(series)) || '';
+  const namedSeries = registered.find((series) => seriesChosenBy(query, series)) || '';
   const changedSeries = current && namedSeries && namedSeries !== (current.seriesId || '') ? namedSeries : '';
   const fallbackKind = (currentEpisode && currentEpisode.taskKind)
     || (input.defaults && input.defaults.taskKind) || '';
@@ -311,9 +352,10 @@ export function routeTask(tasksInput, input = {}) {
     return { tasks, anchor: current, episode: currentEpisode, decision: { kind: 'none', reason: 'thanks', pointer: true }, changed: false };
   }
 
-  /** 先认新对象，再认续作：带「继续 / 这个」但换了对象，也必须撤销旧范围。 */
+  /** 先认新对象，再认续作：带「继续 / 这个」但换了对象，也必须撤销旧范围。
+   *  本句点名了已登记栏目（「再做一期口播」）就是明确的对象证据，不算换任务。 */
   if (current && currentEpisode && currentEpisode.status !== 'unbound'
-    && !SWITCH_WORDS.test(query) && !changedSeries
+    && !SWITCH_WORDS.test(query) && !changedSeries && !namedSeries
     && looksLikeNewTask(query, currentEpisode.taskText || '')) {
     const transitionId = transitionIdFor(batchKey, tasks.revision);
     const existing = Object.values(tasks.episodes).find((episode) => episode.transitionId === transitionId);

package/client.js

@@ -315,6 +315,7 @@ window.__ModuleLoader__.load({
       return h('div', { 'data-tool': props.toolName, style: ROW }, h('span', { style: DOT }, '·'), h('span', { style: LABEL }, label), button);
     };
 
+    const scopeTag = (scope) => (scope === 'global' ? '[全局]' : '[项目]');
     const versionLine = (shown) => {
       const scope = shown.scopeLabel || (shown.scope === 'global' ? '全局' : '项目');
       const archived = shown.status === 'archived' ? ' · 已归档' : '';
@@ -389,7 +390,7 @@ window.__ModuleLoader__.load({
         'aria-label': `查看记忆 ${item.title || item.id}`,
         title: item.title || item.id,
         style: ITEM, // ui-copy-ignore
-      }, `${item.title || item.id}${item.origin === 'project_evolution' ? ' · 实验' : ''}`)) : [];
+      }, `${scopeTag(item.scope)} ${item.title || item.id}${item.origin === 'project_evolution' ? ' · 实验' : ''}`)) : [];
       const detail = shown && shown.ref && items.some((item) => item.id === shown.id && item.revision === shown.ref.revision)
         ? h('div', { style: BODY },
           shown.loading ? '读取中' : null,
@@ -686,8 +687,10 @@ window.__ModuleLoader__.load({
       const primaryKind = props.primaryKind || 'memory';
       const graph = React.useMemo(() => (props.graphOf || graphOf)(props.records), [props.records, props.graphOf]);
       const [zoom, setZoom] = React.useState(1);
+      const [hoveredId, setHoveredId] = React.useState('');
       const selectedId = props.selectedId;
-      const labelSet = graph.people <= 10;
+      const labelSet = graph.people <= 40;
+      const pickHub = props.onPickHub;
       const stepZoom = (delta) => setZoom((value) => Math.min(2.5, Math.max(0.75, Math.round((value + delta) * 100) / 100)));
       const frame = React.useMemo(() => {
         const list = graph.nodes;
@@ -765,26 +768,48 @@ window.__ModuleLoader__.load({
         h('g', null, graph.nodes.map((node) => {
           const isPrimary = node.kind === primaryKind;
           const active = node.id === selectedId;
+          const hovered = node.id === hoveredId;
+          const pick = isPrimary ? props.onPick : (pickHub || undefined);
           const fill = !isPrimary ? 'var(--dsw-alias-label-secondary)'
             : node.state ? (STAGE_TONE[node.state] || 'var(--dsw-alias-brand-primary)')
               : node.experimental ? 'var(--dsw-alias-state-warn-primary)' : 'var(--dsw-alias-brand-primary)';
-          const showLabel = active || (isPrimary && labelSet) || !isPrimary;
+          const showLabel = active || hovered || (isPrimary && labelSet) || !isPrimary;
+          const nameChars = active || hovered ? 14 : isPrimary ? 7 : 10;
           return h('g', {
             key: node.id,
             transform: `translate(${node.x} ${node.y})`,
-            onClick: isPrimary ? () => props.onPick(node) : undefined,
-            style: { cursor: isPrimary ? 'pointer' : 'default' },
+            onClick: pick ? () => pick(node) : undefined,
+            onMouseEnter: () => setHoveredId(node.id),
+            onMouseLeave: () => setHoveredId((value) => (value === node.id ? '' : value)),
+            style: { cursor: pick ? 'pointer' : 'default' },
           },
+          h('circle', { r: Math.max(12, node.radius + 6), fill: 'transparent' }),
           active ? h('circle', { r: node.radius + 5, fill: 'none', stroke: 'var(--dsw-alias-brand-primary)', strokeWidth: 1.4, opacity: 0.5 }) : null,
-          h('circle', { r: node.radius, fill, opacity: isPrimary ? 0.9 : 0.5 }),
+          h('circle', {
+            r: node.radius, fill,
+            opacity: active ? 1 : isPrimary ? 0.9 : 0.5,
+            stroke: hovered ? 'var(--dsw-alias-brand-primary)' : 'none',
+            strokeWidth: hovered ? 1.2 : 0,
+          }),
           showLabel ? h('text', {
             y: node.radius + 12, textAnchor: 'middle',
             fill: active ? 'var(--dsw-alias-label-primary)' : 'var(--dsw-alias-label-secondary)',
-            fontSize: isPrimary ? 10 : 8.5, opacity: active ? 0.95 : 0.68,
-          }, SHORT(node.label, isPrimary ? 9 : 10)) : null,
+            fontSize: isPrimary ? 9.5 : 8.5, opacity: active ? 0.95 : 0.72,
+            paintOrder: 'stroke', stroke: 'var(--dsw-alias-bg-layer-1)', strokeWidth: 3,
+            strokeLinejoin: 'round',
+          }, SHORT(node.label, nameChars)) : null,
           h('title', null, node.title || node.label),
           );
         }))),
+        h('div', {
+          style: {
+            position: 'absolute', left: '10px', bottom: '8px', zIndex: 1,
+            maxWidth: 'calc(100% - 60px)', padding: '2px 6px', borderRadius: '6px',
+            background: 'var(--dsw-alias-bg-layer-1)',
+            color: 'var(--dsw-alias-label-secondary)', fontSize: '11px', lineHeight: '1.5',
+            pointerEvents: 'none',
+          },
+        }, props.legend || '圆点 记忆 · 小点 标签/主题 · 虚线 关联'),
       );
     };
 
@@ -852,7 +877,7 @@ window.__ModuleLoader__.load({
       const unresolved = rule.applicability === 'unresolved'
         || (rule.applicability === 'conditional' && (!Array.isArray(rule.conditions) || rule.conditions.length === 0));
       if (unresolved) return '适用范围待确认，暂不参与回答。';
-      if (rule.state === 'pending') return '尚未参与回答，确认后才会试用。';
+      if (rule.state === 'pending') return '还没生效，采纳后才参与回答。';
       if (rule.state === 'trial') return '在条件匹配的任务中参与参考，到期后暂停。';
       if (rule.state === 'active') return '在适用任务中作为默认参考，当前明确要求优先。';
       return '';
@@ -865,7 +890,7 @@ window.__ModuleLoader__.load({
         if (conditions.length === 0) return '待确认';
         return conditions.map((item) => `${CONDITION_LABEL[item.key] || item.key} ${item.value}`).join('、');
       }
-      return '所有项目';
+      return '本项目内';
     };
 
     const evidenceTextOf = (row) => {
@@ -1126,6 +1151,11 @@ window.__ModuleLoader__.load({
       const changedCount = activity && typeof activity === 'object' && Number.isInteger(activity.changed)
         ? activity.changed
         : (Number.isInteger(activity && activity.count) ? activity.count : null);
+      const activityReason = activity && typeof activity === 'object' && typeof activity.reason === 'string'
+        ? activity.reason
+        : (latestReceipt && typeof latestReceipt.reason === 'string' ? latestReceipt.reason : '');
+      const staleLearning = /没采用|作废|已更新|换到别的作品/.test(activityReason);
+      const activityReasonText = staleLearning ? '整理过程中反馈或作品变了，这轮结果没采用。' : activityReason;
       let activityText = '';
       if (!evolution && memoryOn) {
         activityText = '读不到自进化状态';
@@ -1142,7 +1172,7 @@ window.__ModuleLoader__.load({
       } else if (activityCode === 'quota' || activityCode === 'exhausted') {
         activityText = '本轮整理额度已用完';
       } else if (activityCode === 'failed' || activityCode === 'error') {
-        activityText = '最近整理失败，可查看原因';
+        activityText = staleLearning ? '这轮整理没采用' : '最近整理失败，可查看原因';
       } else if (activityCode === 'waiting' || activityCode === 'idle' || activityCode === 'empty') {
         activityText = '等待可学习的反馈';
       }
@@ -1155,16 +1185,12 @@ window.__ModuleLoader__.load({
         else if (rules.length === 0) activityText = countsUnknown ? '等待可学习的反馈' : '还没有整理出经验';
         else activityText = '暂无整理记录';
       }
-      const activityReason = activity && typeof activity === 'object' && typeof activity.reason === 'string'
-        ? activity.reason
-        : (latestReceipt && typeof latestReceipt.reason === 'string' ? latestReceipt.reason : '');
-
       const filtered = React.useMemo(() => {
         const needle = query.trim().toLowerCase();
         if (!needle) return records;
         return records.filter((record) => {
           const tags = Array.isArray(record.tags) ? record.tags.join(' ') : '';
-          return `${record.title} ${record.summary} ${tags} ${KIND_LABEL[record.kind] || ''}`.toLowerCase().includes(needle);
+          return `${record.title} ${record.summary} ${tags} ${record.topicKey || ''} ${KIND_LABEL[record.kind] || ''}`.toLowerCase().includes(needle);
         });
       }, [records, query]);
       const filteredRules = React.useMemo(() => {
@@ -1267,7 +1293,7 @@ window.__ModuleLoader__.load({
           h(Toggle, { ariaLabel: '自进化', on: Boolean(memoryOn && evolution && evolution.enabled === true), busy: busy || !evolution || !canToggle || !memoryOn, onClick: canToggle && memoryOn ? toggleEvolution : undefined }),
         ),
         h('div', { style: PANEL_MUTED }, '从反馈中整理经验，按需使用'), // ui-copy-ignore 用户指定文案
-        h('div', { style: PANEL_MUTED }, '实验功能'), // ui-copy-ignore 用户指定文案
+        h('div', { style: PANEL_MUTED }, '实验功能，会增加 token 消耗'), // ui-copy-ignore 用户指定文案
       );
       const switchBar = h('div', { style: { display: 'flex', alignItems: 'stretch', gap: '10px', flexWrap: 'wrap', padding: '12px 18px', borderBottom: '1px solid var(--dsw-alias-border-l1)', flex: '0 0 auto' } },
         globalView ? h('div', { style: { ...PANEL_MUTED, padding: '2px 0' } }, '全局记忆只读') : memorySwitch,
@@ -1355,7 +1381,15 @@ window.__ModuleLoader__.load({
       const memoryGraphPane = h('div', {
         style: { ...PANEL_CARD, padding: 0, minHeight: 0, overflow: 'hidden', display: 'flex' },
       },
-      h(MemoryGraph, { records: filtered, selectedId: selectedMemory, onPick: onPickNode, emptyText: query ? '没有匹配的记忆' : '还没有记忆', ariaLabel: '记忆关系图' }));
+      h(MemoryGraph, {
+        records: filtered, selectedId: selectedMemory, onPick: onPickNode,
+        onPickHub: (node) => {
+          setQuery(node.kind === 'tag' ? node.label.replace(/^#/, '') : node.label);
+          setMemoryView('list');
+        },
+        emptyText: query ? '没有匹配的记忆' : '还没有记忆', ariaLabel: '记忆关系图',
+        legend: '圆点 记忆 · 小点 标签/主题 · 虚线 关联 · 点任意点筛选或查看',
+      }));
       const memoryTab = h('div', { role: 'tabpanel', 'aria-label': '记忆', style: { flex: 1, minHeight: 0, display: 'flex', flexDirection: 'column', gap: '9px' } },
         h('div', { style: { display: 'flex', alignItems: 'center', gap: '8px', flex: '0 0 auto' } },
           h('input', {
@@ -1452,6 +1486,7 @@ window.__ModuleLoader__.load({
         records: filteredRules, graphOf: ruleGraphOf, primaryKind: 'rule',
         selectedId: selectedRule, onPick: onPickRuleNode,
         emptyText: evolutionEmptyText, ariaLabel: '经验关系图',
+        legend: '圆点 经验 · 小点 条件 · 虚线 共用条件 · 点圆点查看',
       }));
       const evolutionTab = evolutionFailed ? evolutionFailed : h('div', { role: 'tabpanel', 'aria-label': '自进化', style: { flex: 1, minHeight: 0, display: 'flex', flexDirection: 'column', gap: '9px' } },
         h('div', { style: { ...PANEL_CARD, padding: '9px 11px', display: 'flex', alignItems: 'flex-start', gap: '8px', flex: '0 0 auto' } },
@@ -1459,9 +1494,9 @@ window.__ModuleLoader__.load({
           h('div', { style: { display: 'flex', flexDirection: 'column', gap: '2px', minWidth: 0 } },
             h('div', { style: { fontSize: '12px', lineHeight: '1.55' } }, activityText || (rules.length === 0 ? '还没有整理出经验' : '暂无整理记录')),
             countsUnknown ? h('div', { style: PANEL_MUTED }, '数量未知') : null,
-            activityReason
+            activityReasonText
               ? (showReason
-                ? h('div', { style: { ...PANEL_MUTED, whiteSpace: 'pre-wrap', wordBreak: 'break-word' } }, activityReason)
+                ? h('div', { style: { ...PANEL_MUTED, whiteSpace: 'pre-wrap', wordBreak: 'break-word' } }, activityReasonText)
                 : h(Action, { onClick: () => setShowReason(true) }, '查看原因'))
               : null,
           ),
@@ -1528,14 +1563,16 @@ window.__ModuleLoader__.load({
       const groups = React.useMemo(() => {
         const list = Array.isArray(refs) ? refs : EMPTY;
         return {
-          reference: list.filter((item) => item.exposure === 'reference'),
+          found: list.filter((item) => item.exposure === 'reference' && item.kind === 'memory-search'),
+          provided: list.filter((item) => item.exposure === 'reference' && item.kind === 'memory-read'),
           update: list.filter((item) => item.exposure === 'update'),
         };
       }, [refs]);
       if (!sessionId && refs.length === 0) return null;
-      if (groups.reference.length === 0 && groups.update.length === 0) return null;
+      if (groups.found.length === 0 && groups.provided.length === 0 && groups.update.length === 0) return null;
       return h('div', { style: TAIL },
-        h(RefSection, { label: '本轮参考', items: groups.reference, sessionId, turnKey: turn }),
+        h(RefSection, { label: '搜索命中', items: groups.found, sessionId, turnKey: turn }),
+        h(RefSection, { label: '读过正文', items: groups.provided, sessionId, turnKey: turn }),
         h(RefSection, { label: '本轮更新', items: groups.update, sessionId, turnKey: turn }),
       );
     };

package/docs/RELEASE-0.16.0.md

@@ -0,0 +1,10 @@
+# 0.16.0
+
+- 任务切换不再把上一条任务的规则带进新任务：带明确对象的新要求按新任务处理，只有「继续改」这类没有对象的短句才继承。
+- 自进化关掉或换代后，已经准备好的实验正文和 `contextId` 立即失效；重新打开也不复活旧正文。
+- 试用到期的学习结果不再自动注入，检索、读取、自动注入共用同一档可用性判断。
+- 检索先过滤不可用条目再截断，不会被待确认的候选挤掉真正的命中；只有待确认候选时明确返回「适用条件还没确认」。
+- 写入口径放宽：正文上限 4096 字节，整库 1 MB；摘要超长自动截断；不再因为正文提到像素、字号或写成指令句而拒绝保存。
+- 只改标题的学习规则保持 `active` 和已有证据，不再降成试用。
+- 容量腾挪不归档用户固定过的规则；实验规则与待确认候选的额度不再重复计数。
+- 面板：作用范围改成「本项目内」，候选状态与引用分组的文案对齐实际行为，自进化开关标明会增加消耗。