@modusensus/dsh-mneme 0.9.0 → 0.9.2

package/lib/config.js

@@ -415,6 +415,13 @@ export const Config = z.object({
   // in the background after a short delay, rate-limited in batches. On by
   // default; set false to keep the backfill manual only.
   autoReindexOnBoot: z.boolean().default(true),
+  // Backfill pacing (previously hardcoded 500 / 10 / 200 in semantic.js). A
+  // fixed 500-per-boot cap meant a 4k-row backlog needed nine restarts to
+  // clear, and nothing reported that the run had been capped.
+  // reindexMaxPerBoot = 0 means "no cap, drain the whole backlog this run".
+  reindexMaxPerBoot: z.natural().default(500),
+  reindexBatchSize: z.natural().min(1).max(64).default(10),
+  reindexRateLimitMs: z.natural().default(200),
   // Semantic-first injection (Bug4): when enabled, injectCandidates with a
   // non-empty query recalls via the vector index first and falls back to the
   // rule-based pick to fill/dedupe. Empty query / no vector → legacy behavior.
@@ -856,6 +863,23 @@ export const Config = z.object({
   // 数据、观察 A2 加权质量后再切硬过滤。
   strictScope: z.boolean().default(false),
 
+  // scopeState（issue #471）：政策轴——作用域级可逆闸门。与上面两个键是**两条不同
+  // 的轴**：scopeEnabled/strictScope 管「这条记忆属于谁」（事实轴：持久、跟着记忆
+  // 行走、改的是归属数据），本键管「这个作用域现在通不通」（政策轴：暂时、由人单
+  // 方面按下、松开即恢复、不改任何记忆行）。
+  // 两级语义同 writeAdmission/preInjectGate——enabled 打开时被按下的作用域其候选
+  // 照常注入，但留一条审计行说清「本应被拦下几条」（观察档，先在真实流量看会少掉
+  // 多少再决定真按）；enforce 打开才真的不注入（拦截档）。两个都默认关，打开前
+  // 行为与今天逐字段一致。
+  // 不进 LIGHT_MODE_OFF：它只是查一张小表的判定，不引入重型后台路径、不加常驻
+  // 文本（同 actionPipelineEnabled 的定性）——轻量档预设该关的是重型能力，不该替
+  // 用户关掉一个纯判定入口，用户显式勾选仍然赢。
+  // 也走 feature_flags（FEATURE_FLAG_BOOLEANS 白名单），面板可启停=线上回滚开关。
+  scopeState: z.object({
+    enabled: z.boolean().default(false),
+    enforce: z.boolean().default(false)
+  }).default({}),
+
   // --- v0.9.0 M.O.（Modus Operandi · 手法，beta）--------------------------
   // 命名：M.O. = Modus Operandi，拉丁语「一个人一贯的做事方式」，缩写 M.O.；
   // 也正是 org 词根 modus（modusensus）。界面主显示 M.O.，设置项 hint 第一句
@@ -867,7 +891,27 @@ export const Config = z.object({
   // 它只是只读视图、不引入任何重型后台路径，轻量档用户显式勾选仍然赢（预设
   // 该关的是重型能力，不该替用户关掉一个纯 UI 入口）。
   // 也走 feature_flags（FEATURE_FLAG_BOOLEANS 白名单），面板可启停=线上回滚开关。
-  actionPipelineEnabled: z.boolean().default(false)
+  actionPipelineEnabled: z.boolean().default(false),
+
+  // M.O. 执行记账（v0.9.0 第二批）：`/mo-run` 显式开一次执行窗口，窗口内的命令执行
+  // 才可能被记成一条 run。与上面那个键**分开**：上面管「看图的座位」，这个管
+  // 「往账本里写」——看图和写账是两件事，混成一个键会让「只想看图」的人不知不觉
+  // 获得写入能力。
+  //
+  // 默认关（beta 必须 opt-in）。它挂在热路径上（每个会话事件都过一次监听），
+  // 所以轻量档要关掉：`LIGHT_MODE_OFF` 里有它。
+  actionRunEnabled: z.boolean().default(false),
+
+  // --- 人格定义页（beta）---------------------------------------------------
+  // 注入器渲染人格段的顶层总闸（双闸门的 config 半边；user_settings "persona"
+  // 键内的 persona.enabled 是 per-agent 半边，两闸同真才渲染）。API 的 effective
+  // 必须含这个键——schema 里没有它 effective 就静默少键，面板开关形同虚设
+  // （#254 漏登记 NESTED_FLAG_PATHS 是同一个坑，计数锁 test/api.test.js 钉住）。
+  // 默认关：beta 功能必须 opt-in，老用户行为逐字节不变。不进 LIGHT_MODE_OFF——
+  // 人格段是用户自写的一小段轻量常驻文本，不引入任何重型后台路径，轻量档用户
+  // 显式勾选仍然赢（同 actionPipelineEnabled 的定性）。
+  // 也走 feature_flags（FEATURE_FLAG_BOOLEANS 白名单），面板可启停=线上回滚开关。
+  personaEnabled: z.boolean().default(false)
 });
 
 // Fields forced to false by the light-mode preset. Everything not listed here
@@ -914,7 +958,11 @@ const LIGHT_MODE_OFF = [
   // #399：轻量档不开蒸馏原文留存——它是一份对话原文副本（磁盘 + 暴露面），
   // 与轻量档「小模型 / 小上下文 / 少留痕」的取向相反。默认关，这里只是
   // 轻量预设再确认一次；用户显式勾选仍然赢（合并顺序同 continuityRescueEnabled）。
-  "distillRecords.enabled"
+  "distillRecords.enabled",
+  // M.O. 执行记账：它挂在**热路径**上（每个会话事件都过一次监听）。轻量档的取向
+  // 是「小模型 / 小上下文 / 少常驻路径」，这与一个每事件都过一遍的监听器相冲突。
+  // 默认关，这里只是轻量预设再确认一次；用户显式勾选仍然赢（合并顺序同上面两条）。
+  "actionRunEnabled"
 ];
 
 /**

package/lib/dream/sleep.js

@@ -21,7 +21,7 @@ import { randomUUID, createHash } from "node:crypto";
 import { validateDecisions, applyDecisions, ACTIONS } from "./decisions.js";
 import { findPotentialConflicts, cosineSimilarity } from "./clustering.js";
 import { scopeKeyOf } from "../scope.js";
-import { buildReceipt, describeStreamFailure, resolveDreamEffort, withEffortFallback, maintainIndexAfterDream } from "../dream.js";
+import { buildReceipt, describeStreamFailure, resolveDreamEffort, withEffortFallback, withMaxTokensFallback, maintainIndexAfterDream } from "../dream.js";
 import { computeHeat } from "../heat.js";
 
 // Issue #126 review（Copilot）：默认档（sleepActionSet="conflict"）允许的动作 = 全局
@@ -172,6 +172,22 @@ function makeSummary(m) {
   return text.length <= SUMMARY_MAX ? text : `${text.slice(0, SUMMARY_MAX)}…`;
 }
 
+// issue #471 政策轴：被按下的作用域也不参与睡眠整理。与 dream.js 的 withoutPaused
+// 同源（那里记着「判定只许有一份实现」的理由），但这里是**单独一处**而不是复用：
+// 两个模块各被独立装配（runSleep / runDream 各自接 service），任何一个被换进只
+// 实现了一半 service 的夹具时都该各自降级，而不是因为对方模块没装而双双失效。
+//
+// 睡眠侧比日间加固侧更要紧：这几个相位不只读——phaseDemotion 会 setArchived 与
+// demoteToSummary（真改归档面），phasePatterns 会 mint 出 type=pattern 的新行
+// （凭空给被按下的作用域生出衍生记忆）。只挡日间那几处读入口的话，闸门开着而每
+// 6 小时一次的睡眠照样动手，那等于「按下」只是让它在白天看不见。
+//
+// service 上取不到 filterPaused 时（老装配、测试夹具）原样返回，与改动前一致。
+function withoutPaused(service, rows) {
+  if (typeof service?.filterPaused !== "function") return rows;
+  return service.filterPaused(rows);
+}
+
 // ---------------------------------------------------------------- phases
 
 /**
@@ -189,7 +205,7 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
   }
   const strictness = config.sleepConflictStrictness ?? "normal";
   const threshold = CONFLICT_THRESHOLDS[strictness] ?? CONFLICT_THRESHOLDS.normal;
-  const memories = service.all().filter((m) => !m.archived && !m.forgotten && m.type !== "summary" && m.type !== "document");
+  const memories = withoutPaused(service, service.all().filter((m) => !m.archived && !m.forgotten && m.type !== "summary" && m.type !== "document"));
   if (memories.length < 2) return { status: "skipped", reason: "too few memories" };
   if (signal?.aborted) return { status: "aborted", reason: "user activity" };
 
@@ -313,7 +329,7 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
   // actionSet 已在候选构造前解析（跨类型候选需要它），这里只按档位选 prompt：
   // 默认档保持只有 conflict/keep 的窄 prompt，"full" 才开放六分支。
   const conflictPrompt = actionSet === "full" ? STR.prompts.conflictFull[language] : STR.prompts.conflict[language];
-  const runConflict = (withEffort) => {
+  const runConflict = (withEffort, tokens) => {
     conflictStreamFailure = "";
     return auditedSleepLlm(ctx, service, config, logger, {
       triggerSource: "sleep",
@@ -331,7 +347,7 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     provider: route.provider,
     model: route.model,
     purpose: "sleep-conflict",
-    maxTokens: config.sleepMaxTokens ?? 2048,
+    maxTokens: tokens,
     ...(withEffort && sleepEffort ? { reasoningEffort: sleepEffort } : {}),
     messages: [
       { role: "system", content: [{ type: "text", text: conflictPrompt }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
@@ -339,7 +355,9 @@ async function phaseConflicts(ctx, service, config, logger, runId, semantic = nu
     ]
   }, reportUsage, (reason) => { conflictStreamFailure = describeStreamFailure(reason); }));
   };
-  const text = await withEffortFallback(ctx, sleepEffort, () => runConflict(true), () => runConflict(false), () => conflictStreamFailure);
+  // Issue #478：睡眠侧同样接 max_tokens 降级——面板 hint 已承诺「超上限同样自动降级」，
+  // 只挂 dream 三个点会让 sleepMaxTokens 的 131072 上限继续原样发。
+  const text = await withMaxTokensFallback(ctx, config.sleepMaxTokens ?? 2048, (tokens) => withEffortFallback(ctx, sleepEffort, () => runConflict(true, tokens), () => runConflict(false, tokens), () => conflictStreamFailure), () => conflictStreamFailure);
   if (text === undefined) {
     if (conflictStreamFailure) ctx.logger?.warn?.(`dsh-mneme sleep: conflict stream aborted or errored (${conflictStreamFailure})`);
     return { status: "failed", error: "llm failed" };
@@ -423,7 +441,10 @@ function phaseDemotion(service, config, logger, runId, signal = null) {
   const compressCut = Date.now() - compressDays * 86400000;
   const demoted = [];
   const archived = [];
-  for (const m of service.all()) {
+  // 政策轴在这里尤其要紧：下面两行会真改归档面（setArchived / demoteToSummary）。
+  // 把过滤放在循环之外、而不是在循环体里 continue：一旦将来有人在循环体里加
+  // 副作用（现已有），漏掉那条 continue 就是静默改到被按下的行。
+  for (const m of withoutPaused(service, service.all())) {
     if (signal?.aborted) break;
     if (m.archived || m.forgotten) continue;
     const ref = m.last_accessed_at ?? m.created_at;
@@ -472,9 +493,11 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
   const limit = config.sleepPatternMinMemories ?? 100;
   // #230：document 在查询层排除（excludeTypes）而不是截断后过滤——LIMIT 200
   // 先生效的话，指针行一多就会把普通记忆挤出扫描窗，池子饿到门槛以下。
-  const memories = service
+  // 政策轴同理必须排在 `.slice(0, limit)` **之前**，否则被按下的行照样占掉
+  // sleepPatternMinMemories 的名额，而它们既不会被扫、也不该挤掉别人（#471）。
+  const memories = withoutPaused(service, service
     .list({ limit: 200, includeForgotten: false, excludeTypes: ["document"] })
-    .filter((m) => !m.archived && m.type !== "summary" && m.type !== "pattern")
+    .filter((m) => !m.archived && m.type !== "summary" && m.type !== "pattern"))
     .sort((a, b) => (a.updated_at < b.updated_at ? 1 : -1))
     .slice(0, limit);
   if (memories.length === 0) return { status: "skipped", reason: "no memories to scan" };
@@ -485,7 +508,7 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
   const maxPatterns = config.sleepMaxPatternPerRun ?? 3;
   const sleepEffort = await resolveDreamEffort(ctx, route, config.sleepReasoningEffort, logger);
   let patternStreamFailure = "";
-  const runPattern = (withEffort) => {
+  const runPattern = (withEffort, tokens) => {
     patternStreamFailure = "";
     return auditedSleepLlm(ctx, service, config, logger, {
       triggerSource: "sleep",
@@ -500,7 +523,7 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
     provider: route.provider,
     model: route.model,
     purpose: "sleep-pattern",
-    maxTokens: config.sleepMaxTokens ?? 2048,
+    maxTokens: tokens,
     ...(withEffort && sleepEffort ? { reasoningEffort: sleepEffort } : {}),
     messages: [
       { role: "system", content: [{ type: "text", text: STR.prompts.pattern[language].replace("N", String(maxPatterns)) }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
@@ -508,7 +531,7 @@ async function phasePatterns(ctx, service, config, logger, runId, signal = null)
     ]
   }, reportUsage, (reason) => { patternStreamFailure = describeStreamFailure(reason); }));
   };
-  const text = await withEffortFallback(ctx, sleepEffort, () => runPattern(true), () => runPattern(false), () => patternStreamFailure);
+  const text = await withMaxTokensFallback(ctx, config.sleepMaxTokens ?? 2048, (tokens) => withEffortFallback(ctx, sleepEffort, () => runPattern(true, tokens), () => runPattern(false, tokens), () => patternStreamFailure), () => patternStreamFailure);
   if (text === undefined) {
     if (patternStreamFailure) ctx.logger?.warn?.(`dsh-mneme sleep: pattern stream aborted or errored (${patternStreamFailure})`);
     return { status: "failed", error: "llm failed" };
@@ -563,7 +586,7 @@ function phaseRelations(service, config, logger, runId, signal = null) {
   if (entities.length < 2) return { status: "skipped", reason: "too few entities" };
   const orphans = entities.filter((e) => (service.getRelations(e.id) ?? []).length === 0);
   if (orphans.length === 0) return { status: "skipped", reason: "no orphan entities" };
-  const memories = service.all().filter((m) => !m.archived && !m.forgotten);
+  const memories = withoutPaused(service, service.all().filter((m) => !m.archived && !m.forgotten));
   const seen = new Set();
   const related = [];
   const MAX_RELATIONS_PER_ORPHAN = 3;

package/lib/dream.js

@@ -10,7 +10,7 @@ import { scopeKeyOf } from "./scope.js";
 import { isInPeakWindow, nextOffPeakAt } from "./peak-hours.js";
 import { createHash, randomUUID } from "node:crypto";
 import { STR, langOf } from "./lang.js";
-export { validateDecisions, applyDecisions, withEffortFallback, describeStreamFailure, resolveDreamEffort, resolveRoute };
+export { validateDecisions, applyDecisions, withEffortFallback, withMaxTokensFallback, parseMaxTokensCap, describeStreamFailure, resolveDreamEffort, resolveRoute };
 
 // Extract the first JSON array from LLM output, tolerating markdown fences,
 // leading/trailing prose, and common wrapper noise. Returns an array or null.
@@ -57,10 +57,24 @@ function totalChars(memories) {
 // 两处若各写一份过滤条件，重启播种读到的基线就会和运行期判定口径漂移（一个把
 // document 算进去、一个不算），阈值随之失真，且这种漂移只会在重启后才显形。
 function activeStoreSize(service) {
-  const memories = service.all().filter((m) => !m.archived && m.type !== "summary" && m.type !== "document");
+  const memories = withoutPaused(service, service.all().filter((m) => !m.archived && m.type !== "summary" && m.type !== "document"));
   return { count: memories.length, chars: totalChars(memories) };
 }
 
+// issue #471 政策轴：被按下的作用域不参与巩固，也就不该再撑着阈值把它自己触发起来。
+// 三个读入口（本函数、generateNarratives 的 inputs、runDream 的 memories）各自的附加
+// 条件不同——有的排 forgotten、有的不排——但「政策轴这一层」对三处是一样的，故收成
+// 一个助手而不是各写一遍过滤，理由与 activeStoreSize 开头记着的口径漂移同源：两处
+// 各写一份过滤条件，漂移只会在重启后才显形。
+//
+// 走 service.filterPaused 而不是自己读状态表：判定只许有一份实现（见
+// src/scope-state.js 的模块注释）。service 上取不到这个函数时（老装配、测试夹具）
+// 原样返回，行为与改动前一致。
+function withoutPaused(service, rows) {
+  if (typeof service?.filterPaused !== "function") return rows;
+  return service.filterPaused(rows);
+}
+
 // 基线的唯一合法形状：两个非负整数；其余（缺字段、负数、非整数、整个对象缺失）
 // 一律视为「没有基线」→ 调用方退回 {0,0}。播种值来自持久化列，可能是老库的 NULL
 // 或手工改坏的库，判定必须比调用点更严格，而不是相信数据库里存的一定合法。
@@ -399,6 +413,60 @@ async function withEffortFallback(ctx, effort, attempt, fallback, getStreamError
   }
 }
 
+// Issue #478：max_tokens 超服务商硬上限的拒收判别式与上限提取的单一来源。
+// 实测失败样例（dream_runs 180 连败）："max_tokens 不能超过 65536"——131072 的
+// 默认值原样发出，网关 400 直接拒，推理还没开始。与 EFFORT_REJECT_RE 同款思路：
+// 各处手写会漂移，导出供测试与其它调用点复用。
+export const MAX_TOKENS_REJECT_RE = /max[\s_-]*tokens?/i;
+
+/**
+ * 从拒收报错里提取服务商声明的 max_tokens 上限。只认「显式给数」的说法
+ * （不能超过 / at most / maximum value is / <= 65536 …），认不出就返回 null
+ * ——宁可不降级重试，也不能把报错里那个被拒的请求值（131072）误当上限。
+ * @returns {number|null}
+ */
+function parseMaxTokensCap(message) {
+  const m = String(message ?? "").match(
+    /(?:不能超过|不得超过|超出上限|至多|最多(?:只能|仅)?|at\s+most|no\s+more\s+than|maximum(?:\s+value)?(?:\s+is)?|max(?:\.)?(?:\s+value)?(?:\s+is)?|less\s+than\s+or\s+equal\s+to|<=?)\s*[:：]?\s*(\d{2,10})/i
+  );
+  const cap = m ? Number(m[1]) : null;
+  return cap && Number.isFinite(cap) && cap > 0 ? cap : null;
+}
+
+/**
+ * Issue #478：max_tokens 被服务商 400 拒收时，按报错里的上限自动降级重试一次。
+ * 与 withEffortFallback 同构：stream 路径的结果折叠成 undefined、真实原因在
+ * getStreamError() 里；throw 路径直接看 message。命中拒收且提取到比当前值小的
+ * 上限才重试（attempt 接收 tokens 值），否则原样返回/抛出。单次重试，与
+ * effort 的先例一致——重试后若仍被拒（同上限再报），cap >= tokens 的守卫让
+ * 它自然终止，不会循环。
+ */
+async function withMaxTokensFallback(ctx, maxTokens, attempt, getStreamError) {
+  const retry = (tokens, reason) => {
+    ctx.logger?.warn?.(`dsh-mneme dream: max_tokens ${maxTokens} rejected by provider (${reason}); retrying with ${tokens}`);
+    return attempt(tokens);
+  };
+  try {
+    const result = await attempt(maxTokens);
+    if (result === undefined) {
+      const reason = String(getStreamError?.() ?? "");
+      if (MAX_TOKENS_REJECT_RE.test(reason)) {
+        const cap = parseMaxTokensCap(reason);
+        if (cap && cap < maxTokens) return retry(cap, reason);
+      }
+    }
+    return result;
+  } catch (error) {
+    // AbortError 直接放行（取消意图绝不能被降级重试吞掉，与 effort 同款守卫）。
+    if (error?.name === "AbortError") throw error;
+    const message = String(error?.message ?? error);
+    if (!MAX_TOKENS_REJECT_RE.test(message)) throw error;
+    const cap = parseMaxTokensCap(message);
+    if (!cap || cap >= maxTokens) throw error;
+    return retry(cap, message);
+  }
+}
+
 /** 向量索引同步（总览与叙述条共用）：fail-safe，失败只 warn 不反噬主流程。 */
 async function reEmbedMemory(semantic, memory, logger) {
   if (!semantic?.embedder || !semantic?.vectorIndex || !memory) return;
@@ -418,7 +486,7 @@ async function reEmbedMemory(semantic, memory, logger) {
  * 任何失败降级为 0 条，绝不反噬 dream 主流程。
  */
 async function generateNarratives({ ctx, service, config, route, language, effort, semantic, logger }) {
-  const inputs = service.all().filter((m) => !m.archived && !m.forgotten && m.type !== "summary" && m.type !== "document");
+  const inputs = withoutPaused(service, service.all().filter((m) => !m.archived && !m.forgotten && m.type !== "summary" && m.type !== "document"));
   const clusters = clusterByTag(inputs, { minCluster: config.dreamNarrativeMinCluster ?? 3 });
   if (!clusters.length) return 0;
 
@@ -427,7 +495,7 @@ async function generateNarratives({ ctx, service, config, route, language, effor
       [`# ${tag}`, ...members.map((m) => `- id=${m.id} | title=${m.title} | ${m.content}`)].join("\n"))
     .join("\n\n");
   let streamFailure = "";
-  const runNarratives = (withEffort) => {
+  const runNarratives = (withEffort, tokens) => {
     streamFailure = "";
     return runAuditedLlm(ctx, service, config, {
       triggerSource: "autoDream",
@@ -439,7 +507,7 @@ async function generateNarratives({ ctx, service, config, route, language, effor
       provider: route.provider,
       model: route.model,
       purpose: "compaction",
-      maxTokens: config.dreamMaxTokens ?? 2048,
+      maxTokens: tokens,
       ...(withEffort && effort ? { reasoningEffort: effort } : {}),
       messages: [
         { role: "system", content: [{ type: "text", text: STR.prompts.narrative[language] }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
@@ -447,7 +515,7 @@ async function generateNarratives({ ctx, service, config, route, language, effor
       ]
     }, reportUsage, (reason) => { streamFailure = describeStreamFailure(reason); }));
   };
-  const text = await withEffortFallback(ctx, effort, () => runNarratives(true), () => runNarratives(false), () => streamFailure);
+  const text = await withMaxTokensFallback(ctx, config.dreamMaxTokens ?? 2048, (tokens) => withEffortFallback(ctx, effort, () => runNarratives(true, tokens), () => runNarratives(false, tokens), () => streamFailure), () => streamFailure);
 
   const entries = extractJsonArray(text);
   if (!Array.isArray(entries)) return 0;
@@ -946,7 +1014,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
   async function runDream(ctx, service, config) {
     const language = langOf(config);
     const logger = ctx.logger;
-    let memories = service.all().filter((m) => !m.archived && m.type !== "summary" && m.type !== "document");
+    let memories = withoutPaused(service, service.all().filter((m) => !m.archived && m.type !== "summary" && m.type !== "document"));
     if (memories.length === 0) return { ok: true, applied: 0, skipped: true, summary: false };
     // Issue #89：开跑时刻既喂给审计行（created_at），也是调度器闸门的时间基准。
     const dreamStartedAt = Date.now();
@@ -1127,7 +1195,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     const effort = await resolveDreamEffort(ctx, route, config.dreamReasoningEffort, logger);
     let decisions = null;
     let streamFailure = "";
-    const runConsolidation = (withEffort) => {
+    const runConsolidation = (withEffort, tokens) => {
       streamFailure = "";
       return runAuditedLlm(ctx, service, config, {
       triggerSource: "autoDream",
@@ -1143,7 +1211,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       provider: route.provider,
       model: route.model,
       purpose: "compaction",
-      maxTokens: config.dreamMaxTokens ?? 4096,
+      maxTokens: tokens,
       ...(withEffort && effort ? { reasoningEffort: effort } : {}),
       messages: [
         { role: "system", content: [{ type: "text", text: consolidationPrompt }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
@@ -1155,7 +1223,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       // Bug8: the consolidation call is audited (tokens/time/status). A throw
       // re-propagates to the catch below; an aborted stream returns undefined
       // and is treated as a failed run after the check below.
-      decisionText = await withEffortFallback(ctx, effort, () => runConsolidation(true), () => runConsolidation(false), () => streamFailure);
+      decisionText = await withMaxTokensFallback(ctx, config.dreamMaxTokens ?? 4096, (tokens) => withEffortFallback(ctx, effort, () => runConsolidation(true, tokens), () => runConsolidation(false, tokens), () => streamFailure), () => streamFailure);
     } catch (error) {
       logger?.warn?.(`dsh-mneme dream: consolidation llm call failed: ${String(error)}`);
       return finish({ ok: false, error: "llm failed", summary: false });
@@ -1368,7 +1436,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // a failed run; summary:false marks a run that produced no summary.
     let summaryText;
     let summaryStreamFailure = "";
-    const runSummary = (withEffort) => {
+    const runSummary = (withEffort, tokens) => {
       summaryStreamFailure = "";
       // Issue #258：总览阶段可用 dreamSummaryProvider/dreamSummaryModel 走独立路由
       //（默认空 = 沿用 dream 路由）；输入侧有 dreamSummaryMaxInputs 硬上限，
@@ -1386,7 +1454,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       provider: summaryRoute.provider,
       model: summaryRoute.model,
       purpose: "compaction",
-      maxTokens: config.dreamMaxTokens ?? 2048,
+      maxTokens: tokens,
       ...(withEffort && effort ? { reasoningEffort: effort } : {}),
       messages: [
         { role: "system", content: [{ type: "text", text: STR.prompts.dreamSummary[language] }], source: { kind: "plugin:dsh-mneme", plugin: "dsh-mneme" } },
@@ -1404,7 +1472,11 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // 渐进恶化。倒序排序与 consolidate 窗口同款（updated_at desc, id tiebreak），
     // 保留最新的；0 = 关闭上限（回归全库行为，调用方自担 ctx）。
     // #230：document 指针行不进总览（与 dream/sleep 五个候选池的同款排除）。
-    const summaryAll = service.all().filter((m) => !m.archived && m.type !== "summary" && m.type !== "document");
+    // issue #471：这一处尤其不能漏——总览落库时是**无作用域**的 summary 行
+    // （saveWithDedupe 不带 agent_scope/workspace_scope），所以被按下作用域的内容
+    // 一旦进了总览，注入侧按作用域过滤就再也拦不住它：内容已经洗成了全局行。
+    // 别的入口漏了只是「那一条漏过去」，这里漏了是「洗一遍之后一直漏」。
+    const summaryAll = withoutPaused(service, service.all().filter((m) => !m.archived && m.type !== "summary" && m.type !== "document"));
     const summaryMaxInputs = Number.isInteger(config.dreamSummaryMaxInputs) ? config.dreamSummaryMaxInputs : 0;
     const summaryInputs = summaryMaxInputs > 0 && summaryAll.length > summaryMaxInputs
       ? [...summaryAll]
@@ -1425,7 +1497,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     );
     try {
       // Bug8: the summary call is audited too (operation dream_summarize).
-      summaryText = await withEffortFallback(ctx, effort, () => runSummary(true), () => runSummary(false), () => summaryStreamFailure);
+      summaryText = await withMaxTokensFallback(ctx, config.dreamMaxTokens ?? 2048, (tokens) => withEffortFallback(ctx, effort, () => runSummary(true, tokens), () => runSummary(false, tokens), () => summaryStreamFailure), () => summaryStreamFailure);
     } catch (error) {
       logger?.warn?.(`dsh-mneme dream: summary llm call failed: ${String(error)}`);
       return finish({ ok: false, error: "llm failed", applied, decisions: auditDecisions, outcome, frozen: frozenCount, summary: false });