dsh-lite-memory 0.16.4 → 0.17.0

package/index.js

@@ -226,6 +226,13 @@ function keepHandler(webServer, cwdForSession) {
         return sendJson(res, 400, { ok: false, reason: '缺少来源' });
       }
       if (!found) return sendJson(res, 200, { ok: true, status: 'gone', id });
+      /** 面板要分开「当前规范」和旧版本；历史只作可折叠对照，不拼进正文。 */
+      const versions = Array.isArray(found.versions) ? found.versions
+        : Array.isArray(found.history) ? found.history : [];
+      const learning = found.learning && typeof found.learning === 'object' ? found.learning : {};
+      const enums = new Set(['applied', 'unchanged', 'superseded', 'failed']);
+      const processingStatus = enums.has(found.processingStatus) ? found.processingStatus
+        : enums.has(learning.lastStatus) ? learning.lastStatus : '';
       return sendJson(res, 200, {
         ok: true,
         id: found.id,
@@ -236,6 +243,13 @@ function keepHandler(webServer, cwdForSession) {
         scopeLabel: found.scopeLabel || '',
         revision: found.revision,
         body: found.body,
+        currentBody: typeof found.currentBody === 'string' ? found.currentBody : found.body,
+        versions,
+        sourceExcerpt: found.sourceExcerpt || learning.sourceExcerpt || '',
+        sourceRefs: Array.isArray(found.sourceRefs) ? found.sourceRefs : (Array.isArray(learning.sourceRefs) ? learning.sourceRefs : []),
+        evidence: found.evidence || (found.evidenceRef ? [found.evidenceRef] : []),
+        evidenceRef: found.evidenceRef || '',
+        processingStatus,
       });
     }
 
@@ -627,6 +641,9 @@ function refsOf(hits) {
     revision: item.revision || 1,
     status: item.status || 'ok',
     origin: item.origin === 'project_evolution' ? 'project_evolution' : 'user_explicit',
+    /** 界面要按类型分开展示（偏好/约定/流程/资料），维护字段不进正文。 */
+    kind: typeof item.kind === 'string' && item.kind ? item.kind : 'note',
+    when: typeof item.when === 'string' ? item.when : '',
   }));
 }
 
@@ -872,6 +889,14 @@ export function apply(ctx, config) {
 
   const windowOf = (agent) => windows.get(agentKey(agent)) || null;
 
+  /** 自动注入账本：普通段与实验段共用 3 条 / 1200 字节，量的是拼接后的完整文本。 */
+  const emptyAutoBudget = () => ({
+    normalText: '', experimentText: '',
+    normalCards: 0, experimentCards: 0,
+    cards: 0, cardBytes: 0, experimentBytes: 0, totalBytes: 0,
+  });
+
+
   /** 预算按规范化 JSON 字节算：转义、中文、换行都算进模型真正收到的内容。 */
   const jsonBytes = (value) => Buffer.byteLength(JSON.stringify(value));
 
@@ -892,7 +917,7 @@ export function apply(ctx, config) {
       signature, sessionId, turn, messageIds,
       bytes: 0, bodies: 0, reads: 0,
       provided: new Map(), readBodies: new Map(), at: Date.now(),
-      experiment: null, contexts: new Map(),
+      experiment: null, contexts: new Map(), runtime: null, autoBudget: null,
     };
     windows.set(key, next);
     return next;
@@ -917,6 +942,11 @@ export function apply(ctx, config) {
   }
 
   /** 两层都算：任何一层换库、换代或清空，之前准备的卡片都要失效。 */
+  /**
+   * 同一请求的召回快照只要内容没变就保持原样：命中次数、使用时间这类使用记录
+   * 不参与指纹，否则模型多读一次就会触发重投影。真正改变应看条目内容版本、
+   * 启停/控制代号与自进化代号。
+   */
   function fingerprintOf(scope) {
     try {
       return [scope, globalScopeView()].map((source) => {
@@ -924,7 +954,11 @@ export function apply(ctx, config) {
         const meta = index.__meta || {};
         const evolutionEpoch = index.__evolution && index.__evolution.epoch ? index.__evolution.epoch : '';
         const controlEpoch = index.__control && index.__control.epoch ? index.__control.epoch : '';
-        return `${index.scope}:${meta.storeId || ''}:${index.generation}:${index.epoch}:${evolutionEpoch}:${controlEpoch}`;
+        const content = (index.entries || [])
+          .map((entry) => `${entry.id}:${entry.revision || 1}:${entry.status || 'active'}:${entry.updated || ''}:${entry.topicKey || ''}`)
+          .sort()
+          .join(',');
+        return `${index.scope}:${meta.storeId || ''}:${evolutionEpoch}:${controlEpoch}:${content}`;
       }).join('|');
     } catch {
       return '';
@@ -934,7 +968,8 @@ export function apply(ctx, config) {
   const globalScopeView = () => globalScope();
 
   /** 纯内存：读两层当前投影，先判适用再排序，整卡装预算。 */
-  function projectRecall(scope, query, context, win) {
+  function projectRecall(scope, query, context, win, runtime) {
+    context = view.contextWithTask(context, runtime && runtime.task);
     const layers = { project: [], global: [] };
     const seen = new Set();
     for (const source of [scope, globalScope()]) {
@@ -958,38 +993,61 @@ export function apply(ctx, config) {
       records.push(group.record);
       layerOf.set(group.record.id, group.scope === 'global' ? 'global' : 'project');
     }
-    const ranked = view.rank(records, query, { limit: 8, requireApplicable: true, context });
-    const headerBytes = Buffer.byteLength(RECALL_HEADER);
-    let used = headerBytes;
+    const ranked = view.rank(records, query, {
+      limit: 8, requireApplicable: true, context,
+      runtime: runtime || (win && win.runtime) || null,
+      task: runtime && runtime.task ? runtime.task : null,
+    });
+    /** 普通记忆与实验规则共用一份自动注入预算：总条数和最终完整文本字节一起算。 */
+    const auto = win && win.autoBudget ? win.autoBudget : null;
     /** 卡片上限含包装；共享请求账本也要把标题行算进去，不能只算卡片行。 */
     let headerCharged = win ? win.recallHeader === true : false;
     const lines = [];
     const cards = [];
     for (const row of ranked) {
-      if (cards.length >= view.CARD.max) break;
+      const usedCards = cards.length + (auto ? (auto.experimentCards || 0) : 0);
+      if (usedCards >= view.CARD.max) break;
       const card = view.cardOf(row.record, layerOf.get(row.record.id));
       if (card.scope === 'project') card.scopeName = projectNameOf(scope);
       const line = renderRecallCard(card);
-      const size = Buffer.byteLength(`\n${line}`);
-      if (used + size > view.CARD.bytes) continue;
+      const nextText = `${RECALL_HEADER}\n${[...lines, line].join('\n')}`;
+      if (auto) {
+        /** 实验段可能先渲染：组装成最终两段再量，超了就跳过这张，不把标题留在模型侧。 */
+        const admitted = admitAuto(win, {
+          normal: nextText,
+          experiment: auto.experimentText || '',
+          normalCards: cards.length + 1,
+          experimentCards: auto.experimentCards || 0,
+        });
+        if (!admitted.ok) continue;
+      } else {
+        const size = Buffer.byteLength(nextText);
+        if (size > view.CARD.bytes) continue;
+        const cost = Buffer.byteLength(`\n${line}`) + (headerCharged ? 0 : Buffer.byteLength(RECALL_HEADER));
+        if (win && !affordable(win, cost)) continue;
+        if (win) win.bytes += cost;
+      }
       const revision = card.revision || 1;
-      const already = win ? win.provided.get(card.id) === revision : false;
-      if (win && !already) {
-        const cost = size + (headerCharged ? 0 : headerBytes);
-        if (!affordable(win, cost)) continue;
-        win.bytes += cost;
-        win.provided.set(card.id, revision);
-        if (!headerCharged) {
-          headerCharged = true;
-          win.recallHeader = true;
-        }
+      if (win) win.provided.set(card.id, revision);
+      if (win && !headerCharged) {
+        headerCharged = true;
+        win.recallHeader = true;
       }
-      used += size;
       lines.push(line);
       cards.push({ id: card.id, revision, scope: card.scope, title: card.title });
     }
+    const finalText = `${RECALL_HEADER}\n${lines.join('\n')}`;
+    if (auto) {
+      /** 没有任何普通卡片时也要把已有实验段记账成当前状态。 */
+      admitAuto(win, {
+        normal: lines.length ? finalText : (auto.normalText || ''),
+        experiment: auto.experimentText || '',
+        normalCards: cards.length,
+        experimentCards: auto.experimentCards || 0,
+      });
+    }
     if (!cards.length) return null;
-    return { text: `${RECALL_HEADER}\n${lines.join('\n')}`, cards, bytes: used, query };
+    return { text: finalText, cards, bytes: Buffer.byteLength(finalText), query };
   }
 
   /* ---------------- 项目自进化：任务锚点、读取决策、上下文解析 ---------------- */
@@ -1037,9 +1095,62 @@ export function apply(ctx, config) {
       .join('、');
   }
 
-  /** 实验内容单独记账：同一请求里再次渲染只补差额，不重复占满预算。 */
-  function chargeExperiment(win, text) {
+  /**
+   * 自动注入只有一份预算：普通卡片与实验规则合计最多 3 条 / 1200 字节。
+   * 这里按 provider 最终会看到的完整文本量字节（含标题行、ID、换行和两段之间的空行），
+   * 先组装再测量，不能只量卡片正文再拼。
+   */
+  function autoTextOf(win, normal, experiment) {
+    const auto = win && win.autoBudget ? win.autoBudget : null;
+    const n = normal === undefined ? String(auto?.normalText || '') : String(normal || '');
+    const e = experiment === undefined ? String(auto?.experimentText || '') : String(experiment || '');
+    return { normal: n, experiment: e, text: [e, n].filter(Boolean).join('\n\n') };
+  }
+
+  function autoBytesOf(win, normal, experiment) {
+    return Buffer.byteLength(autoTextOf(win, normal, experiment).text);
+  }
+
+  /**
+   * 原子准入：量的是最终完整文本和总条数；通过才写入预算账本。
+   * 任何一段超限都整段回退，不截半句前提、不把标题留在模型侧。
+   */
+  function admitAuto(win, { normal, experiment, normalCards, experimentCards } = {}) {
+    if (!win || !win.autoBudget) return { ok: false, bytes: 0 };
+    const auto = win.autoBudget;
+    const parts = autoTextOf(win, normal, experiment);
+    const cards = (normalCards === undefined ? (auto.normalCards || 0) : normalCards)
+      + (experimentCards === undefined ? (auto.experimentCards || 0) : experimentCards);
+    const bytes = Buffer.byteLength(parts.text);
+    if (cards > view.CARD.max || bytes > view.CARD.bytes) return { ok: false, bytes, cards };
+    const previousTotal = Number(auto.totalBytes || 0);
+    if (!affordable(win, bytes - previousTotal)) return { ok: false, bytes, cards };
+    auto.normalText = parts.normal;
+    auto.experimentText = parts.experiment;
+    auto.normalCards = normalCards === undefined ? (auto.normalCards || 0) : normalCards;
+    auto.experimentCards = experimentCards === undefined ? (auto.experimentCards || 0) : experimentCards;
+    auto.cards = cards;
+    auto.cardBytes = Buffer.byteLength(parts.normal);
+    auto.experimentBytes = Buffer.byteLength(parts.experiment);
+    auto.totalBytes = bytes;
+    win.bytes += bytes - previousTotal;
+    return { ok: true, bytes, cards };
+  }
+
+  /** 实验内容单独记账：同一请求里再次渲染替换旧段，只补差额。 */
+  function chargeExperiment(win, text, cards = 1) {
     if (!text) return '';
+    const auto = win && win.autoBudget ? win.autoBudget : null;
+    if (auto) {
+      const admitted = admitAuto(win, {
+        normal: auto.normalText || '',
+        experiment: text,
+        normalCards: auto.normalCards || 0,
+        experimentCards: cards,
+      });
+      if (!admitted.ok) return '';
+      return text;
+    }
     const bytes = Buffer.byteLength(`\n\n${text}`);
     const previous = win ? (win.experimentBytes || 0) : 0;
     if (bytes > EXPERIMENT_BYTES) return '';
@@ -1128,8 +1239,16 @@ export function apply(ctx, config) {
       return chargeExperiment(win, '这些实验规则互相冲突，先按用户这次说的做，别叠加对立的规则。');
     }
     const parts = { header: EXPERIMENT_RULES_HEADER, items: [], tail: held && held.contextId ? `\ncontextId=${held.contextId}` : '' };
+    /** 与普通记忆共用 3 张卡片 / 1200 字节：普通卡片先占掉的位子和字节，实验规则不能再拿。 */
+    const auto = win && win.autoBudget ? win.autoBudget : null;
+    const cardCap = auto
+      ? Math.max(0, view.CARD.max - (auto.normalCards || 0) - (auto.experimentCards || 0))
+      : view.CARD.max;
+    const autoCap = auto
+      ? Math.max(0, view.CARD.bytes - Buffer.byteLength(auto.normalText || '') - 2)
+      : EXPERIMENT_BYTES;
     let used = Buffer.byteLength(EXPERIMENT_RULES_HEADER) + 1;
-    for (const record of matched.slice(0, 3)) {
+    for (const record of matched.slice(0, cardCap)) {
       const body = String(record.body || '');
       const short = body && body.length <= EXPERIMENT_SHORT_CHARS && body.split('\n').length <= 4;
       const conditions = conditionLabel(record.conditions);
@@ -1141,7 +1260,7 @@ export function apply(ctx, config) {
         ? `- 「${record.title}」${conditions ? `（${conditions}）` : ''} · ${record.id}：${body}${check}`
         : `- 「${record.title}」 · ${record.id}（用途：${record.summary || record.title}；要用时 memory_read 取正文）`;
       const size = Buffer.byteLength(`\n${line}`);
-      if (used + size > EXPERIMENT_BYTES) break;
+      if (used + size > autoCap) break;
       used += size;
       const trialLearning = record.learning && typeof record.learning === 'object' ? record.learning : {};
       const trialUntil = trialLearning.state === 'trial' && Number.isFinite(Date.parse(String(trialLearning.trialUntil || '')))
@@ -1154,71 +1273,136 @@ export function apply(ctx, config) {
       return chargeExperiment(win, '有些实验规则的适用条件还没确认，先按用户这次说的做，别把它们当本轮依据。');
     }
     if (!parts.items.length) return '';
+    /** 先按最终整段文本过预算，再登记可发布内容；没通过就一条都不留。 */
+    const admitted = chargeExperiment(win, experimentTextFrom(parts), parts.items.length);
+    if (!admitted) {
+      if (held) { held.experimentParts = null; held.injectedIds = []; held.validUntil = ''; }
+      return '';
+    }
     if (held) held.experimentParts = parts;
     /** 兼容旧读取点：整体最早到期只取本轮真正注入的条目，不再被无关试验拖下水。 */
     if (held) {
       const deadlines = parts.items.map((item) => Date.parse(String(item.validUntil))).filter(Number.isFinite);
       if (deadlines.length) held.validUntil = new Date(Math.min(...deadlines)).toISOString();
     }
-    return chargeExperiment(win, experimentTextFrom(parts));
+    return admitted;
   }
 
-  /** 一次真人请求只路由一次；同一批次重试复用同一 transitionId。 */
-  function experimentFor(scope, { sessionId, query, batchKey, messageIds, win }) {
-    if (!win || !batchKey) return null;
-    let status;
-    try { status = evolutionStatus(scope); } catch { return null; }
-    if (!status || status.enabled !== true || status.compatible === false) return null;
-    if (scope.confirmed !== true) return null;
-    let tasks;
-    try { tasks = taskState(scope); } catch { return null; }
+  /**
+   * 一次真人请求只路由一次：不管自进化开没开，都先建独立的任务上下文。
+   * 普通记忆按这个上下文判适用；实验规则只是在这个上下文上再加一层可用性。
+   */
+  function runtimeFor(scope, { sessionId, query, batchKey, messageIds, autoRoute = true }) {
+    if (!batchKey) return null;
+    let status = null;
+    try { status = evolutionStatus(scope); } catch { status = null; }
+    const enabled = Boolean(status && status.enabled === true && status.compatible !== false && scope.confirmed === true);
+    /** 任务上下文独立于自进化：项目状态读不出来也要按当前任务判普通记忆，不能整段取消召回。 */
+    let tasks = null;
+    try { tasks = taskState(scope); } catch { tasks = null; }
+    tasks = tasks && typeof tasks === 'object' ? tasks : {};
     const ranges = rangesOf(scope);
-    const routed = anchor.routeTask(tasks, {
-      projectId: scope.key,
-      sessionId,
-      batchKey,
-      messageIds,
-      query,
-      registeredSeries: ranges.series,
-      defaults: tasks.defaults,
-      now: Date.now(),
-    });
+    /**
+     * 工具模式不自动路由：上下文照样要有，但不能因为一句点名就改任务状态；
+     * 真正的绑定留给 memory_search bindForRequest，绑定后状态是 proposed。
+     */
+    const routed = autoRoute
+      ? anchor.routeTask(tasks, {
+        projectId: scope.key,
+        sessionId,
+        batchKey,
+        messageIds,
+        query,
+        registeredSeries: ranges.series,
+        defaults: tasks.defaults,
+        now: Date.now(),
+      })
+      : (() => {
+        const sessionAnchor = tasks.sessions && tasks.sessions[sessionId] ? tasks.sessions[sessionId] : null;
+        const episode = sessionAnchor && sessionAnchor.episodeId && tasks.episodes
+          ? tasks.episodes[sessionAnchor.episodeId] || null
+          : null;
+        return { tasks, anchor: sessionAnchor, episode, changed: false, decision: { kind: 'none', reason: 'tool_only' } };
+      })();
     if (routed.changed) {
-      const saved = saveTaskState(scope, routed.tasks, { operationId: `task_${batchKey}` });
-      if (!saved.ok) return null;
+      /** 落盘失败也不能取消本轮任务判断：进程内上下文仍然有效，只是不留任务历史。 */
+      saveTaskState(scope, routed.tasks, { operationId: `task_${batchKey}` });
     }
     const context = view.trustedContext(scope, anchor.contextOfAnchor(routed.anchor, {}));
     const thanks = anchor.isThanks(query);
     const decision = anchor.decideRead({
       mode: recallMode(),
-      enabled: true,
-      identityConfirmed: true,
+      enabled,
+      identityConfirmed: scope.confirmed === true,
       anchor: routed.anchor,
       ranges: [...ranges.taskKinds, ...ranges.series],
       thanks,
       boundForRequest: false,
     });
     const contextId = anchor.contextIdFor(scope.key, batchKey, crypto.randomUUID().slice(0, 8));
-    const episode = routed.tasks && routed.tasks.episodes ? routed.tasks.episodes[routed.anchor.episodeId] : null;
+    const episode = routed.episode
+      || (routed.anchor && routed.tasks && routed.tasks.episodes ? routed.tasks.episodes[routed.anchor.episodeId] : null);
     let epoch = '';
-    try { epoch = String(evolutionStatus(scope).epoch || ''); } catch { epoch = ''; }
+    try { epoch = String(status && status.epoch ? status.epoch : ''); } catch { epoch = ''; }
+    const anchorTask = routed.anchor || {};
+    /** 与自进化开关无关的请求上下文：普通记忆也靠它判断项目、任务与代号。 */
+    const requestContext = anchor.buildRuntimeContext({
+      projectId: scope.key,
+      sessionId,
+      batchKey,
+      messageIds,
+      controlEpoch: epoch,
+      query,
+      anchor: anchorTask,
+      episode,
+    });
+    const task = {
+      ...requestContext.task,
+      kind: anchorTask.taskKind || requestContext.task.kind || context.taskKind || '',
+      seriesId: anchorTask.seriesId || requestContext.task.seriesId || context.seriesId || '',
+      artifactKey: requestContext.task.artifactKey || context.artifactKey || '',
+      phase: requestContext.task.phase || context.phase || '',
+    };
     const held = {
-      contextId, projectKey: scope.key, sessionId, batchKey, messageIds, query,
-      context, anchor: routed.anchor, ranges, decision, epoch,
+      contextId, requestId: requestContext.requestId, controlEpoch: epoch,
+      projectKey: scope.key, sessionId, batchKey, messageIds, query,
+      context, task, anchor: routed.anchor, ranges, decision, epoch,
+      experimental: enabled,
       episodeUpdatedAt: episode ? episode.updatedAt : '', injectedIds: [],
       at: Date.now(),
     };
-    win.experiment = held;
-    win.contexts.set(contextId, held);
-    return { text: renderExperiment(scope, decision, context, held, win), decision, held };
+    return { held, decision, ranges, enabled, status };
+  }
+
+  /** 实验正文只在自进化开着时登记；普通记忆共享同一个任务上下文。 */
+  function experimentFor(scope, runtime, win) {
+    if (!runtime || !runtime.held) return null;
+    const held = runtime.held;
+    if (win) win.runtime = held;
+    if (!runtime.enabled) return null;
+    if (!experimentStillCurrent(scope, held)) return { text: '', held, decision: held.decision };
+    if (win) {
+      win.experiment = held;
+      win.contexts.set(held.contextId, held);
+    }
+    return { text: renderExperiment(scope, held.decision, held.context, held, win), decision: held.decision, held };
   }
 
-  /** 自动路径与工具共用一次解析：没有本轮上下文就退回普通检索，绝不猜一个空上下文。 */
   function resolveRequestContext(execution, optionalContextId) {
     const scope = scopeOf(cwdOf(execution));
     const win = windowOf(execution && execution.agent);
     const contextId = typeof optionalContextId === 'string' ? optionalContextId.trim() : '';
     if (!contextId) {
+      /** 没有显式上下文时，用本请求已经路由出来的任务；这层不依赖自进化开关。 */
+      const runtime = win && win.runtime;
+      const sameRequest = runtime
+        && runtime.projectKey === scope.key
+        && (!runtime.sessionId || runtime.sessionId === String(win.sessionId || ''))
+        && runtime.batchKey === anchor.requestBatchKey(win.messageIds || []);
+      if (sameRequest) {
+        /** 普通记忆可以直接用本请求上下文；实验正文仍要求显式 contextId，不能顺手放行。 */
+        return { ok: true, scope, win, context: runtime.context, held: runtime, experimental: false };
+      }
       return { ok: true, scope, win, context: view.trustedContext(scope, {}), experimental: false };
     }
     /** 先认项目再找本地记录：别的项目的上下文要明确拒绝，不能只报过期。 */
@@ -1371,6 +1555,7 @@ export function apply(ctx, config) {
         scope: value.scope || '',
         revision: value.revision || 0,
         changed: value.changed === true,
+        recordKind: typeof value.kind === 'string' && value.kind ? value.kind : '',
         mode: value.needsScope ? 'needs_scope'
           : value.existingId ? 'duplicate'
             : value.needsResolution ? 'needs_resolution'
@@ -1383,8 +1568,9 @@ export function apply(ctx, config) {
           title: { type: 'string' },
           summary: { type: 'string' },
           when: { type: 'string' },
+          kind: { type: 'string' },
           summaryShortened: { type: 'boolean' },
-          fullTextInBody: { type: 'boolean' },
+          fullTextSaved: { type: 'boolean' },
           revision: { type: 'integer' },
           merged: { type: 'boolean' },
           changed: { type: 'boolean' },
@@ -1418,7 +1604,7 @@ export function apply(ctx, config) {
           ? `memory · 需要确认：「${value.title}」与已有条目相近${value.crossLayer ? '（在另一层）' : ''}${value.sameTopic ? '（同一主题槽位）' : ''}\n${value.similar}\n要更新它，用 id 重存；确实是另一条，加 resolution="distinct"`
           : value.changed === false
             ? `memory · unchanged ${withTag(value, `"${value.title}"`)} · ${value.id}`
-            : `memory · ${value.merged ? 'merged' : 'saved'} ${withTag(value, `"${value.title}"`)}${value.when ? `（${value.when}）` : ''} · ${value.id}${value.similar ? ` · 相近：${value.similar}` : ''}${value.archived ? ` · 已归档「${value.archived}」腾位` : ''}${value.fullTextInBody ? ' · 摘要超过 60 字，完整原句已存进正文' : ''}`,
+            : `memory · ${value.merged ? 'merged' : 'saved'} ${withTag(value, `"${value.title}"`)}${value.when ? `（${value.when}）` : ''} · ${value.id}${value.similar ? ` · 相近：${value.similar}` : ''}${value.archived ? ` · 已归档「${value.archived}」腾位` : ''}${value.fullTextSaved ? ' · 完整原句已另存' : ''}`,
       }],
     },
     execute: async (args, execution) => {
@@ -1496,8 +1682,9 @@ export function apply(ctx, config) {
         title: saved.record.title,
         summary: saved.record.summary,
         when: saved.record.when || '',
+        kind: saved.record.kind || 'note',
         summaryShortened: Boolean(saved.draft?.summaryShortened),
-        fullTextInBody: Boolean(saved.draft?.fullTextInBody),
+        fullTextSaved: Boolean(saved.draft?.fullTextSaved ?? saved.draft?.fullTextInBody),
         revision: saved.record.revision || 1,
         merged: saved.merged,
         changed: !saved.noop,
@@ -1558,7 +1745,10 @@ export function apply(ctx, config) {
     description: `按需检索已有记忆：先搜，命中再 memory_read 读正文。用户提到「记住了什么 / 上次 / 规范 / 约定 / 路径 / 凭据怎么取」，或者眼前反复出现的报错、弹窗、异常时，先查这里有没有记过解法。跨项目的通用条目以 [global] 开头，项目条目以 [项目名] 开头。中文长句可以直接当查询。每行带 id，更新时把 id 传回 memory_save。默认只列当前有效的；已经归档或被更新替换的旧说法不混进来，要查历史就在参数里显式要 history。`,
     parameters: SEARCH_PARAMS,
     output: {
-      presentationMeta: (_args, value) => ({ kind: 'memory-search', count: value.count, status: value.status || 'ok', refs: value.refs || [] }),
+      presentationMeta: (_args, value) => ({
+        kind: 'memory-search', count: value.count, status: value.status || 'ok', refs: value.refs || [],
+        noTriggerReason: value.noTriggerReason || '',
+      }),
       schema: {
         type: 'object',
         properties: {
@@ -1567,6 +1757,7 @@ export function apply(ctx, config) {
           text: { type: 'string' },
           status: { type: 'string', enum: ['ok', 'budget_exhausted', 'memory_disabled', 'needs_context'] },
           reasonCode: { type: 'string' },
+          noTriggerReason: { type: 'string' },
           refs: {
             type: 'array',
             items: {
@@ -1578,8 +1769,10 @@ export function apply(ctx, config) {
                 revision: { type: 'integer' },
                 status: { type: 'string' },
                 origin: { type: 'string' },
+                kind: { type: 'string' },
+                when: { type: 'string' },
               },
-              required: ['id', 'title', 'scope', 'revision', 'status', 'origin'],
+              required: ['id', 'title', 'scope', 'revision', 'status', 'origin', 'kind', 'when'],
               additionalProperties: false,
             },
           },
@@ -1618,13 +1811,16 @@ export function apply(ctx, config) {
       }
       const scope = resolved.scope;
       const context = resolved.context;
+      const gateRuntime = resolved.held || win?.runtime
+        || { projectId: scope.key, context, experimental: resolved.experimental === true };
       /** 检索只列当前任务真能用的条目；先取全量候选，过滤后再截断，避免不可用条目挤掉后面的命中。 */
       const limit = args.limit ?? 3;
       const rawHits = search(scope, args.query, 50, {
         context,
         history: args.history === true,
         allowExperimental: resolved.experimental === true,
-      }).filter((item) => !item.ownerProjectId || item.ownerProjectId === scope.key);
+      }).filter((item) => !item.ownerProjectId || item.ownerProjectId === scope.key)
+        .filter((item) => item.archived || view.eligibility(item, gateRuntime, 'search').ok);
       const hits = rawHits.filter((item) => item.archived || item.status === 'ok').slice(0, limit);
       const withheld = rawHits.filter((item) => !item.archived && item.status !== 'ok');
       const scopeName = scope.key === 'global' ? '' : projectNameOf(scope);
@@ -1647,6 +1843,7 @@ export function apply(ctx, config) {
             : '有相关的项目记忆，但当前任务明确不适用。',
           status: unresolved ? 'needs_context' : 'ok',
           reasonCode: unresolved ? 'applicability_unresolved' : 'not_applicable',
+          noTriggerReason: unresolved ? '适用条件未确认' : '当前任务不适用',
           refs: [],
         };
         if (win) {
@@ -1659,7 +1856,7 @@ export function apply(ctx, config) {
       }
       /** 没命中是正常结果，不是额度问题；空响应同样记一次本请求开销。 */
       if (!hits.length) {
-        const empty = { count: 0, chars: 0, text: '', status: 'ok', refs: [] };
+        const empty = { count: 0, chars: 0, text: '', status: 'ok', reasonCode: 'no_match', noTriggerReason: '没有匹配的记忆', refs: [] };
         if (win) {
           const bytes = jsonBytes(empty);
           if (!affordable(win, bytes)) return { ...empty, status: 'budget_exhausted' };
@@ -1699,6 +1896,7 @@ export function apply(ctx, config) {
           scope: { type: 'string' },
           scopeName: { type: 'string' },
           origin: { type: 'string', enum: ['user_explicit', 'project_evolution'] },
+          kind: { type: 'string' },
           status: { type: 'string', enum: ['ok', 'archived', 'needs_context', 'not_applicable', 'gone', 'budget_exhausted', 'memory_disabled'] },
           body: { type: 'string' },
           links: { type: 'string' },
@@ -1736,6 +1934,7 @@ export function apply(ctx, config) {
         scope: value.scope || '',
         revision: value.revision || 0,
         origin: value.origin === 'project_evolution' ? 'project_evolution' : 'user_explicit',
+        recordKind: typeof value.kind === 'string' && value.kind ? value.kind : '',
         status: value.status || 'ok',
       }),
     },
@@ -1749,8 +1948,14 @@ export function apply(ctx, config) {
       const allowExperimental = resolved.experimental === true;
       const agent = execution?.agent;
       const win = windowOf(agent);
+      const gateRuntime = resolved.held || win?.runtime
+        || { projectId: scope.key, context, experimental: resolved.experimental === true };
       if (args.view === 'links') {
-        const found = readLinks(scope, args.id, { context, allowExperimental });
+        const source = locate(scope, args.id);
+        if (source && !view.eligibility(source.record, gateRuntime, 'read').ok) {
+          return { id: '', scope: '', status: 'needs_context', links: '' };
+        }
+        const found = readLinks(scope, args.id, { context, allowExperimental, runtime: gateRuntime, now: Date.now() });
         if (!found) throw new Error(`没有 ${args.id} 这条记忆`);
         if (found.status !== 'ok') {
           const withheld = { id: '', scope: '', status: found.status, links: '' };
@@ -1778,20 +1983,8 @@ export function apply(ctx, config) {
       }
       const record = readEntry(scope, args.id, { context, allowExperimental });
       if (!record) throw new Error(`没有 ${args.id} 这条记忆`);
-      if (record.origin === 'project_evolution' && record.ownerProjectId && record.ownerProjectId !== scope.key) {
-        return { id: '', scope: record.scope, status: 'not_applicable', body: '' };
-      }
-      if (record.origin === 'project_evolution' && !allowExperimental) {
-        return { id: '', scope: record.scope, status: 'needs_context', body: '' };
-      }
-      /** 暂停、过期或条件不匹配的实验条目只给状态，不给标题和正文。 */
-      if (record.origin === 'project_evolution' && !view.experimentalUsable(record)) {
-        return { id: '', scope: record.scope, status: 'needs_context', body: '' };
-      }
-      const learningState = record.learning && typeof record.learning === 'object' ? record.learning : {};
-      if (record.origin === 'project_evolution' && (learningState.state === 'paused' || learningState.blockedReason)) {
-        return { id: '', scope: record.scope, status: 'needs_context', body: '' };
-      }
+      const gate = view.eligibility(record, gateRuntime, 'read');
+      if (!gate.ok) return { id: '', scope: record.scope, status: gate.status, body: '' };
       /** 条件未知或不适用的条目只报状态：正文和标题都不能绕过自动召回的门槛。 */
       if (record.status !== 'ok') {
         return { id: '', scope: record.scope, status: record.status === 'needs_context' ? 'needs_context' : 'not_applicable', body: '' };
@@ -1806,6 +1999,7 @@ export function apply(ctx, config) {
         scope: record.scope,
         scopeName,
         status: record.status,
+        kind: record.kind || 'note',
         body,
       };
       if (win) {
@@ -1963,7 +2157,6 @@ export function apply(ctx, config) {
   });
 
   if (typeof ctx.on === 'function') ctx.on('agent/pre-step', async (payload, next) => {
-    const startedAt = Date.now();
     const agent = payload?.agent;
     syncMemoryTools(agent);
     let decision;
@@ -1973,6 +2166,8 @@ export function apply(ctx, config) {
       clearPrepared(agent);
       throw error;
     }
+    /** 宿主等待不算本地召回时间：额度从拿到这一步的开始算。 */
+    const startedAt = Date.now();
     try {
       if (!agent || decision?.kind !== 'enter') {
         clearPrepared(agent);
@@ -2018,7 +2213,8 @@ export function apply(ctx, config) {
         }
         if (fingerprint !== previous.fingerprint) {
           const win = windowOf(agent);
-          const snapshot = projectRecall(scope, previous.query, view.trustedContext(scope, {}), win);
+          if (win) win.autoBudget = emptyAutoBudget();
+          const snapshot = projectRecall(scope, previous.query, win && win.runtime ? win.runtime.context : view.trustedContext(scope, {}), win, win && win.runtime ? win.runtime : null);
           let experimentText = '';
           if (win && win.experiment) {
             experimentText = renderExperiment(scope, win.experiment.decision, win.experiment.context, win.experiment, win);
@@ -2042,15 +2238,16 @@ export function apply(ctx, config) {
       /** 工具模式也要开额度窗口：只是不自动注入，工具调用同样受每请求预算约束。 */
       const ids = fresh.map((message) => String(message?.id ?? '')).filter(Boolean).sort();
       const win = openWindow(agent, { sessionId, turn, messageIds: ids });
+      const budgetBefore = win ? {
+        bytes: win.bytes, bodies: win.bodies, reads: win.reads,
+        provided: new Map(win.provided), readBodies: new Map(win.readBodies),
+        recallHeader: win.recallHeader, experimentBytes: win.experimentBytes,
+        autoBudget: win.autoBudget ? JSON.parse(JSON.stringify(win.autoBudget)) : null,
+      } : null;
       /** 工具模式也要记下本轮真人原话：只用于核对绑定，不自动注入。 */
       const query = view.newestUserQuery(fresh).slice(0, RECALL_QUERY_CHARS);
       if (win && query) win.query = query;
 
-      if (recallMode() !== 'adaptive') {
-        clearPrepared(agent);
-        return decision;
-      }
-
       if (!query) {
         clearPrepared(agent);
         return decision;
@@ -2065,29 +2262,60 @@ export function apply(ctx, config) {
         clearPrepared(agent);
         return decision;
       }
+      const batchKey = anchor.requestBatchKey(ids);
+      /**
+       * 工具模式也必须先有本请求上下文：memory_search/read/links 靠同一个 contextId 判项目和任务，
+       * 不能等到自动召回分支才建，否则工具模式永远拿不到可核对的任务。
+       */
+      const runtime = runtimeFor(scope, { sessionId, query, batchKey, messageIds: ids, autoRoute: recallMode() === 'adaptive' });
+      if (win && runtime) win.runtime = runtime.held;
+      if (recallMode() !== 'adaptive') {
+        clearPrepared(agent);
+        return decision;
+      }
       const context = view.trustedContext(scope, {});
       const fingerprint = fingerprintOf(scope);
       const controlEpoch = controlStatus(scope).epoch || '';
-      const batchKey = anchor.requestBatchKey(ids);
       dropStaleCandidate(sessionId, batchKey);
-      const experiment = experimentFor(scope, { sessionId, query, batchKey, messageIds: ids, win });
-      const remembered = experiment && experiment.held
-        ? rememberFeedback(scope, sessionId, fresh, experiment.held, turn)
+      /** 任务上下文独立于自进化开关：普通记忆按当前任务判适用，实验规则再叠一层可用性。 */
+      const auto = emptyAutoBudget();
+      if (win) win.autoBudget = auto;
+      const experiment = runtime ? experimentFor(scope, runtime, win) : null;
+      const recalledContext = runtime ? runtime.held.context : context;
+      const remembered = runtime && runtime.enabled
+        ? rememberFeedback(scope, sessionId, fresh, runtime.held, turn)
         : null;
-      const snapshot = projectRecall(scope, query, context, win);
-      if (generation !== generations.get(agent)) return decision;
+      const snapshot = projectRecall(scope, query, recalledContext, win, runtime ? runtime.held : null);
+      /** 没发布出去的投影要退还额度：不能因为一次超时把本请求的召回额度耗掉。 */
+      const rollbackBudget = () => {
+        if (!win || !budgetBefore) return;
+        win.bytes = budgetBefore.bytes;
+        win.bodies = budgetBefore.bodies;
+        win.reads = budgetBefore.reads;
+        win.provided = budgetBefore.provided;
+        win.readBodies = budgetBefore.readBodies;
+        win.recallHeader = budgetBefore.recallHeader;
+        win.experimentBytes = budgetBefore.experimentBytes;
+        win.autoBudget = budgetBefore.autoBudget || emptyAutoBudget();
+        win.experiment = null;
+        win.contexts.clear();
+      };
+      if (generation !== generations.get(agent)) { rollbackBudget(); return decision; }
       /** 投影期间开关被改过：丢弃这批内容，不把关闭前的记忆交给当前请求。 */
       if (!memoryEnabled(scope) || (controlStatus(scope).epoch || '') !== controlEpoch) {
+        rollbackBudget();
         clearPrepared(agent);
         return decision;
       }
       /** 超时或被取消：这一步不留半旧卡片，下一真人请求重新投影。 */
       if (signal?.aborted || Date.now() - startedAt > RECALL_DEADLINE_MS) {
+        rollbackBudget();
         clearPrepared(agent);
         return decision;
       }
       /** 实验上下文即使本轮零注入也要留着：工具绑定后同一请求还能补上规则。 */
       if (!snapshot && !experiment) {
+        rollbackBudget();
         clearPrepared(agent);
         return decision;
       }
@@ -2196,6 +2424,13 @@ export function apply(ctx, config) {
     const route = routeForSession(session);
     if (!route) return;
     const candidate = pending.candidate;
+    /** 候选进入整理前再走一次统一准入：项目/作品身份、作用域与反馈类型都对上才花配额。 */
+    const admission = learning.admissionOf(candidate, {
+      projectId: scope.key,
+      sessionId: candidate.sessionId,
+      anchor: pending.held?.anchor || null,
+    }, 'collect');
+    if (!admission || admission.ok !== true) return;
     const operationId = `learn_${crypto.createHash('sha256')
       .update(`${scope.key}|${candidate.episodeId}|${candidate.messageIds.join(',')}`)
       .digest('hex').slice(0, 16)}`;
@@ -2254,6 +2489,12 @@ export function apply(ctx, config) {
       }
       const parsed = learning.parseOutput(text, { finish, refs: input.refs, rules: input.rules, ranges });
       if (!parsed.ok) throw new Error(parsed.reason);
+      /** 用户已经把要求说成长期规则，模型仍返回空时至少留一条规则，不让这条反馈无声消失。 */
+      const changes = parsed.changes.length
+        ? parsed.changes
+        : (candidate.cue?.explicitLongTerm && candidate.cue?.type === 'spec_change'
+          ? [learning.pendingChangeFrom(candidate)].filter(Boolean)
+          : []);
       const commit = commitLearning(scope, {
         operationId,
         epoch: begin.epoch,
@@ -2263,8 +2504,9 @@ export function apply(ctx, config) {
         sessionId: candidate.sessionId,
         messageIds: candidate.messageIds,
         feedbackText: candidate.text,
+        sourceExcerpt: candidate.sourceExcerpt || learning.sourceExcerptOf(candidate.text),
         dimension: candidate.cue?.dimension || '',
-        changes: parsed.changes,
+        changes,
         preparedTargets,
         usage: learning.usageOf(chunks),
         explicitLongTerm: Boolean(candidate.cue.explicitLongTerm),