@modusensus/dsh-mneme 0.7.31 → 0.8.0

package/src/api.js

@@ -3,8 +3,11 @@ import { readFileSync } from "node:fs";
 import { timingSafeEqual, randomBytes } from "node:crypto";
 import { FEATURE_FLAG_SPEC } from "./settings.js";
 import { TYPE_FILE, renderMirrorText, parseHumanEdits } from "./mirror.js";
+import { langOf } from "./lang.js";
 import { computeHeat } from "./heat.js";
 import { describeStreamFailure, resolveRoute } from "./dream.js";
+import { describeLocalRuntime, publicRuntimeStatus } from "./runtime/loader.js";
+import { hostModulesDir, provisionRuntime } from "./runtime/provision.js";
 
 // headers：少数端点（/export 附件下载）需要追加 Content-Disposition 等响应头。
 function sendJson(res, status, payload, headers = {}) {
@@ -113,6 +116,7 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
   const flagKeys = [
     ...FEATURE_FLAG_SPEC.booleans,
     ...Object.keys(FEATURE_FLAG_SPEC.ints),
+    ...Object.keys(FEATURE_FLAG_SPEC.numbers),
     ...FEATURE_FLAG_SPEC.strings,
     ...FEATURE_FLAG_SPEC.urls,
     ...Object.keys(FEATURE_FLAG_SPEC.enums)
@@ -604,18 +608,87 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     handler(req, res) {
       try {
         const stats = semantic?.vectorIndex?.getStats?.() ?? null;
+        // #118: expose readiness so the status card can tell "initializing /
+        // unreachable" from "disabled". An embedder carrying no `ready` prop at
+        // all (test doubles, third-party adapters) is assumed usable.
+        // issue #135: 但「可用」和「配了」是两件事 —— legacy OpenAI embedder
+        // 此前恒报 ready，于是 baseUrl/apiKey/model 全空时状态卡依然是绿的
+        // （"绿色假阳性"）。下面把两者分开，并附上索引覆盖度。
+        const ready = embedder ? ("ready" in embedder ? embedder.ready === true : true) : null;
+        // local/ollama 的配置来自 settings 兜底，没有「未配置」态：它们的
+        // ready=false 表示「还在初始化」，不是「没配」。
+        const configured = embedder ? (typeof embedder.configured === "boolean" ? embedder.configured : true) : null;
+        const embedded = Number(stats?.embeddedCount ?? 0);
+        const total = Number(stats?.totalCount ?? 0);
         sendJson(res, 200, {
-          // #118: expose readiness so the status card can tell "initializing /
-          // unreachable" from "disabled". Legacy OpenAI embedder has no `ready`
-          // prop and is immediately usable, so treat that as ready.
-          ready: embedder ? ("ready" in embedder ? embedder.ready === true : true) : null,
+          ready,
+          configured,
+          // 机器可读的原因；null = 一切正常。面板按它选文案，不用猜布尔组合。
+          reason: !embedder ? "no-embedder"
+            : configured === false ? "not-configured"
+              : ready !== true ? "initializing"
+                : null,
+          // 空库时 ratio 必须是 null 而非 0 —— 0 会被读成「一条都没嵌上」。
+          coverage: { embedded, total, ratio: total > 0 ? embedded / total : null },
+          // 配了、库里有东西可嵌、却一条都没嵌上 = 真的降级（本机此前长期
+          // 处于 ready:true + embeddedCount:0，面板却显示正常）。
+          degraded: configured === true && total > 0 && embedded === 0,
           // Explicit display name first: the legacy OpenAI-compatible embedder
           // is an object literal, so constructor.name would be "Object".
           embedProvider: embedder ? (embedder.name ?? embedder.constructor?.name ?? "unknown") : null,
           modelHash: embedder?.modelHash ?? null,
           dimension: embedder?.dimension ?? null,
           reranker: semantic?.reranker ? "ready" : null,
-          index: stats
+          index: stats,
+          // issue #131 / PR-A：自管运行时的状态。无论当前 provider 是不是 local
+          // 都报 —— 面板需要区分「已收编但没启用」和「要用本地却没收编」。
+          // 这里只做结构检查（不跑推理），失败降级成状态对象，不会让本端点 500。
+          // 必须经 publicRuntimeStatus 投影：本端点是免鉴权的，绝对路径与原始错误
+          // 文本不能出去（CWE-200）。完整诊断走本机 CLI 的 status。
+          localRuntime: publicRuntimeStatus(describeLocalRuntime({ runtimeDir: config?.runtimeDir ?? "" }))
+        });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  // --- 一键取回自管运行时（issue #131 / PR-C：三档来源）-------------------------
+  // 写路径（requireAuth）：它会往 ~/.dsh/mneme/runtime/ 落一份依赖闭包。
+  //
+  // 第一档源固定取本 profile 的 node_modules（由插件自身路径推出），不接受客户端传源目录 ——
+  // 「从任意目录往运行时目录里搬东西」没有必要成为对外能力。
+  //
+  // 一律回 200：请求本身合法，成不成看 body 里的 ok/status/reason。让 HTTP 码只表达
+  // 「有没有鉴权/路径对不对」，结论交给 ok —— 面板要能显示「收编了但闭包缺件」这种
+  // 中间状态，用一个 4xx 概括会把信息压掉。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/runtime/provision",
+    handler(req, res) {
+      try {
+        if (req.method !== "POST") {
+          sendJson(res, 405, { error: "method-not-allowed" });
+          return;
+        }
+        if (!requireAuth(req, res, apiToken)) return;
+        return readBody(req).then(async (text) => {
+          const body = parseBody(text);
+          const runtimeDir = config?.runtimeDir ?? "";
+          // 三档来源依次尝试（收编本机 node_modules → 本地 .tgz 目录 → registry）。
+          // 所以这个端点会**联网**：它可能拉一份几十到上百 MB 的闭包。
+          const result = await provisionRuntime({
+            hostModulesDir: hostModulesDir(import.meta.url),
+            runtimeDir,
+            localTarballDir: config?.runtimeTarballDir ?? "",
+            mirror: config?.runtimeMirror ?? "",
+            overwrite: body?.overwrite === true
+          });
+          // 顺手带回最新状态，面板不必再打一次 /semantic（且它走的是免鉴权投影）。
+          sendJson(res, 200, {
+            ...result,
+            localRuntime: publicRuntimeStatus(describeLocalRuntime({ runtimeDir }))
+          });
         });
       } catch {
         sendJson(res, 500, { error: "internal" });
@@ -853,7 +926,7 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
         }
         const sections = [];
         for (const type of Object.keys(TYPE_FILE)) {
-          if (byType[type]?.length) sections.push(renderMirrorText(type, byType[type]));
+          if (byType[type]?.length) sections.push(renderMirrorText(type, byType[type], langOf(config)));
         }
         sendAttachment(res, 200, "text/markdown; charset=utf-8", `dsh-mneme-export-${stamp}.md`, sections.join("\n"));
       } catch {
@@ -941,6 +1014,66 @@ export function createApi(ctx, service, settings, commands, embedder, semantic =
     }
   });
 
+  // --- 冲突集中处理（v0.8.0）：队列 + 人工确认 --------------------------------
+  // GET /conflicts：未解决冲突 + 双方当前内容（此前面板只有计数与徽章，
+  // resolveConflictPending 在存储层躺着没有任何调用方）。POST /conflicts/resolve：
+  // {id, winner: "a"|"b"|null, apply}——盖章审计，apply 时按 dream 非冻结
+  // conflict 路径同款处置（service.resolveConflictPending 内部复用
+  // applyDecisions：CAS + 事务 + 注记 + 幂等）。认证与其他写路由一致。
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/conflicts",
+    handler(req, res) {
+      try {
+        if (req.method !== "GET") {
+          sendJson(res, 404, { error: "not-found" });
+          return;
+        }
+        if (!requireAuth(req, res, apiToken)) return;
+        const url = new URL(req.url, "http://localhost");
+        const limit = Math.min(200, Math.max(1, Number(url.searchParams.get("limit") ?? 50) || 50));
+        const offset = Math.max(0, Number(url.searchParams.get("offset") ?? 0) || 0);
+        const items = service.listConflictQueue({ limit, offset });
+        sendJson(res, 200, { items, total: service.countConflictPending?.() ?? items.length });
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
+  register({
+    kind: "exact",
+    path: "/api/dsh-mneme/conflicts/resolve",
+    handler(req, res) {
+      try {
+        if (req.method !== "POST") {
+          sendJson(res, 404, { error: "not-found" });
+          return;
+        }
+        if (!requireAuth(req, res, apiToken)) return;
+        return readBody(req).then((text) => {
+          let body = {};
+          try { body = JSON.parse(text || "{}"); } catch { /* 坏 JSON → 走缺参分支 */ }
+          const id = typeof body.id === "string" ? body.id.trim() : "";
+          if (!id) {
+            sendJson(res, 400, { error: "missing-id" });
+            return;
+          }
+          const winner = body.winner === "a" || body.winner === "b" ? body.winner : null;
+          const apply = body.apply !== false;
+          const result = service.resolveConflictPending(id, { winner, apply });
+          if (!result) {
+            sendJson(res, 404, { error: "not-found" });
+            return;
+          }
+          sendJson(res, 200, { ok: true, conflict: result });
+        }).catch(() => sendJson(res, 500, { error: "internal" }));
+      } catch {
+        sendJson(res, 500, { error: "internal" });
+      }
+    }
+  });
+
   // --- health: mirror sync state (F-NEW-03 / v0.3.6) ---
   // Auth-gated; only returns a sanitized error code (never raw last_error which
   // may leak paths/token-like strings/internal hosts). On state read failure it

package/src/commands.js

@@ -1,10 +1,18 @@
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { STR } from "./lang.js";
+
 // Custom slash-command manager: keeps the DSH command registry in sync with
 // user-defined commands persisted in SQLite. Commands are registered on boot
 // and (re)registered on add/remove through the API.
 //
-// Each custom command's handler returns the user-authored instruction as a
-// success result; the DSH UI surfaces it as a model-directed instruction.
-export function createCommandManager({ ctx, settings, logger }) {
+// Per the DSH command contract, a handler's CommandResult text is only a UI
+// settlement notice and never reaches the model. To actually drive the agent,
+// the handler submits the user-authored instruction itself as a user followup
+// message on the receiving agent (same pattern as the official /goal command).
+// The notice just acknowledges the submission; an optional rawInput suffix
+// typed after the command is appended for the model.
+
+export function createCommandManager({ ctx, settings, logger, language = "zh" }) {
   const registered = new Map(); // name -> disposer
 
   function registerOne(command) {
@@ -13,8 +21,10 @@ export function createCommandManager({ ctx, settings, logger }) {
     try {
       dispose = ctx.commands.register({
         name: command.name,
-        description: command.description || `自定义指令 ${command.name}`,
-        handler: () => ({ kind: "success", text: command.instruction })
+        // 缺省描述随实例语言（命令描述进命令注册表，对 LLM 可见）。
+        description: command.description || STR.commandFallbackDesc[language](command.name),
+        input: { hint: STR.commandInputHint[language] },
+        handler: (invocation) => submit(command, invocation)
       });
     } catch (error) {
       logger?.warn?.(`dsh-mneme: failed to register command /${command.name}: ${String(error)}`);
@@ -23,6 +33,27 @@ export function createCommandManager({ ctx, settings, logger }) {
     registered.set(command.name, dispose);
   }
 
+  /** Submit the instruction (plus optional rawInput suffix) to the receiving agent. */
+  function submit(command, invocation) {
+    const suffix = typeof invocation?.rawInput === "string" ? invocation.rawInput.trim() : "";
+    const text = suffix ? `${command.instruction}\n\n${suffix}` : command.instruction;
+    const agent = invocation?.agent;
+    if (typeof agent?.followup !== "function") {
+      // 兜底：宿主未提供接收 agent 时退回旧行为，至少把指令展示在 notice 里。
+      return { kind: "success", text };
+    }
+    try {
+      agent.followup(createUserMessage({
+        content: [{ type: "text", text }],
+        source: { kind: "user" }
+      }));
+    } catch (error) {
+      logger?.warn?.(`dsh-mneme: failed to submit /${command.name} to agent: ${String(error)}`);
+      return { kind: "error", text: STR.commandSubmitFailed[language](command.name) };
+    }
+    return { kind: "success", text: STR.commandSubmitted[language](command.name) };
+  }
+
   function unregisterOne(name) {
     const dispose = registered.get(name);
     if (dispose) {

package/src/config.js

@@ -2,6 +2,10 @@ import z from "@deepseek-ai/schemastery";
 import { TYPE_DECAY_DEFAULTS } from "./heat.js";
 
 export const Config = z.object({
+  // 记忆语言：生成记忆、注入标题与后台 LLM 提示词所用语言；'zh'（默认，
+  // 行为不变）/ 'en'。启动时读入，切换后重启生效。
+  language: z.union([z.const("zh"), z.const("en")]).default("zh")
+    .description("记忆语言：生成的记忆条目、注入标题与后台 LLM 提示词所用语言（zh=默认中文，en=英文）。"),
   memoryDir: z.string().default("~/.dsh/memory"),
   autoInject: z.boolean().default(true),
   autoSummarize: z.boolean().default(true),
@@ -14,6 +18,17 @@ export const Config = z.object({
   // 蒸馏把完整对话上下文交给 LLM 提炼，不硬裁到 8000 字就截断语义；默认
   // 24000 字符（约覆盖一整轮中等对话），需要更完整可调大。
   distillMaxChars: z.natural().min(1000).max(200000).default(24000),
+  // autoSummarize 节流、产出上限与写入端同会话去重（Issue #127，默认全 0/off =
+  // 零行为变化）。此前每个 turn/end 必跑、产出条数由模型输出决定、写入端只按
+  // 「同类型 + 标题 trim 全等」去重——本机实测单日 84 次、单会话一天 198 条、
+  // 同一事实 6 小时铸出 28+ 条。阀门交给用户按需拧，升级本身不改行为。
+  summarizeMinIntervalMinutes: z.natural().min(0).max(10080).default(0),
+  summarizeMaxEntriesPerRun: z.natural().min(0).max(50).default(0),
+  // 落库前去重档位：off（默认，等同现状）/ title（零成本，仅拦完全同名）/
+  // vector（复用已有 embedding 列做同会话语义近邻，无 LLM 调用）。
+  summarizeDedupeMode: z.union([z.const("off"), z.const("title"), z.const("vector")]).default("off"),
+  summarizeDedupeMinSim: z.number().min(0.5).max(0.99).default(0.92),
+  summarizeDedupeWindowHours: z.natural().min(0).max(168).default(24),
   // 智能调速器（429 保护，默认开）：蒸馏 LLM 调用全局串行排队，相邻请求
   // 间隔 distillRateLimitIntervalMs（默认 1s 一次）；命中 429 限流时按
   // distillRateLimitBaseDelayMs 指数退避（1s→2s→4s…）自动重试
@@ -43,6 +58,11 @@ export const Config = z.object({
   // 编码记忆注入加权系数：编码任务时对 rejected_solution/pitfall/constraint
   // 记忆的 importance 乘以该系数排序，让编码记忆在编码场景更靠前。
   codingBoostFactor: z.number().min(1).max(5).default(2),
+  // 注入边界花括号转义（issue #162，v0.7.4 曾修后被 v0.7.11 重构误删）：默认开启，
+  // 在 memory / 短期上下文 / 用户设置三处注入出口对连续 2+ 个花括号插 `\`
+  // （`{{a}}`→`{\{a\}\}`），让 DSH 的 interpolate() 不再扫到非法变量名而 throw。
+  // 关闭时按原样透传。
+  escapePromptVariables: z.boolean().default(true),
   autoDream: z.boolean().default(true),
   dreamThresholdCount: z.natural().min(1).max(1000).default(10),
   dreamThresholdChars: z.natural().min(100).max(100000).default(5000),
@@ -64,25 +84,47 @@ export const Config = z.object({
   //     选用时建议配 dreamReasoningEffort 并实测；不行就换非思考模型。
   dreamProvider: z.string().description("记忆巩固专用模型的服务商（settings「巩固模型」）。巩固反复失败时，优先改用官方非思考模型的服务商（如 deepseek / glm）。"),
   dreamModel: z.string().description("记忆巩固专用模型。建议选非思考模型（如 deepseek-chat、glm-5-2 类）：思考模型可能烧光 token 预算返回空体，导致巩固失败（UNSUPPORTED_REASONING_EFFORT）。"),
-  dreamMaxTokens: z.natural().min(256).max(131072).default(32768),
-  // Pass-through reasoning effort for dream's LLM calls. 'none' (default)
-  // omits the field so the provider's own default applies; low/medium/high
-  // are forwarded verbatim. Useful to cap reasoning spend on thinking-type
-  // models that would otherwise drain the whole token budget and return an
-  // empty body ("no json array in llm output").
+  // Issue #135 建议 3：#9 只抬了 max（8192→131072），default 停在 32768。思考型
+  // 模型的推理与正文共享该预算，effort 未压低时 32768 恰好被推理烧光 → 空体
+  // （"no json array in llm output"，报告实测 146 轮因此失败）。默认抬到上限，
+  // 让默认配置也留足正文预算；流式计费按实际用量，不按上限。
+  dreamMaxTokens: z.natural().min(256).max(131072).default(131072),
+  // Pass-through reasoning effort for dream's LLM calls (Issue #135 建议 4/5).
+  // Unset (no value) resolves to the LOWEST effort the model declares before
+  // streaming: background consolidation must produce JSON, and omitting the
+  // field lets the harness substitute the model's defaultEffort (thinking-type
+  // models often default to high/max) — the reasoning then drains the whole
+  // token budget and the run dies with an empty body. Explicit 'none' still
+  // omits the field (provider default applies); off/low/medium/high are
+  // forwarded verbatim, unsupported values are remapped (v0.7.26+).
   // Caveat: on some thinking models (e.g. v4-flash-ga) the harness declares NO
   // supported effort, so even the fallback retry (field stripped) is rejected
   // again via its defaultEffort — prefer a non-reasoning dreamProvider/dreamModel.
   dreamReasoningEffort: z.union([
+    z.const("off"),
     z.const("low"),
     z.const("medium"),
     z.const("high"),
     z.const("none")
-  ]).default("none").description("巩固模型的推理档位：'none'（默认）用服务商自带默认；low/medium/high 原样传递。模型不支持的值会自动换用其支持的档位（v0.7.26+）。"),
+  ]).description("巩固模型的推理档位：未配置 = 自动取模型支持的最低档（避免思考模型用自带默认档烧光预算返回空体，#135）；显式 'none' = 不发送字段、用服务商自带默认；off/low/medium/high 原样传递。模型不支持的值会自动换用其支持的档位（v0.7.26+）。"),
   // 滑动窗口上限（v0.4.4）：autoDream 每次只对最近 dreamMaxSnapshotSize 条
   // 记忆做 consolidation。大记忆量下全量快照会把 LLM 输入撑爆（636 记忆 →
   // 677 "missing" errors、applied=0），窗口外的旧记忆不进 snapshot。
   dreamMaxSnapshotSize: z.natural().min(1).max(1000).default(200),
+  // Issue #125：候选集构造方式。"window"（默认，等同现状）只取最近
+  // dreamMaxSnapshotSize 条；"hybrid" 在此基础上并入**向量翻出的高相似组**——
+  // 本机实测 45 对「双方活跃且 sim≥0.85」里 0 对能同时进窗口（窗口覆盖率 11.7%），
+  // 纯时间窗口让"该合并的一对"几乎永远碰不到面。候选总量仍由下面的上限封顶、
+  // 与库总量解耦，这是相对"调大窗口"的核心收益：输入成本不随库增长。
+  dreamCandidateMode: z.union([
+    z.const("window"),
+    z.const("hybrid")
+  ]).default("window"),
+  // hybrid 的候选总量上限；0 = 复用 dreamMaxSnapshotSize（不迁移，需要时显式覆盖）。
+  dreamCandidateMax: z.natural().min(0).max(5000).default(0),
+  // hybrid 判"高相似"的阈值；0.85 与 sleep normal 档对齐——两个模块对"高相似"
+  // 保持同一个定义。
+  dreamCandidateMinSim: z.number().min(0.5).max(0.99).default(0.85),
   // 隐式 keep（v0.4.4）：LLM 未提及的 snapshot 记忆自动补 {action:"keep"}，
   // 避免"未覆盖即全拒"白白浪费整轮 run。设为 false 时保留旧的严格校验
   // （未覆盖即拒绝整单）。
@@ -134,6 +176,20 @@ export const Config = z.object({
   embedModelCacheDir: z.string().default(""),
   embedModelMirror: z.string().default("https://hf-mirror.com"),
 
+  // 自管运行时目录（issue #131）。空 = ~/.dsh/mneme/runtime：里面放收编或下载来的
+  // transformers + onnxruntime 闭包，插件经 src/runtime/loader.js 的三层解析加载它。
+  // 目的就是让这条重依赖不必留在宿主 profile 的依赖图里——profile 是所有插件共用的
+  // 依赖图，留在里面会让「装任何插件都要替它重走一遍这条链」。
+  runtimeDir: z.string().default(""),
+
+  // 运行时取件的两个来源（issue #131 / PR-C）。都是「克制」的默认：留空 = 不额外改变行为。
+  // - runtimeTarballDir：本地 .tgz 目录。某个包网络下不到时（例如 onnxruntime-node），
+  //   把 `npm pack <pkg>` 出来的 tgz 丢进这个目录即可离线取件；有它就优先于联网。
+  // - runtimeMirror：registry 镜像前缀，例如 https://npmmirror.com/mirrors/npm/ 。
+  //   留空则用 runtime-manifest.json 里写死的官方地址（那是随包发布的固定清单）。
+  runtimeTarballDir: z.string().default(""),
+  runtimeMirror: z.string().default(""),
+
   // Vector search tuning.
   vectorSearchTopK: z.natural().min(1).max(100).default(20),
   vectorSearchThreshold: z.number().min(0).max(1).default(0.65),
@@ -228,9 +284,9 @@ export const Config = z.object({
   // default provider/model.
   entityExtractionModel: z.string().default(""),
   // Reasoning effort for entity extraction (issue #109), mirrors
-  // dreamReasoningEffort: 'none' (default) omits the field / provider default;
-  // low/medium/high passed through. A provider that rejects the effort retries
-  // once without it, so opting in is safe to experiment with.
+  // dreamReasoningEffort pass-through: 'none' omits the field / provider
+  // default; off/low/medium/high passed through. A provider that rejects the
+  // effort retries once without it, so opting in is safe to experiment with.
   entityExtractionReasoning: z.union([
     z.const("low"),
     z.const("medium"),
@@ -265,6 +321,14 @@ export const Config = z.object({
     z.const("normal"),
     z.const("aggressive")
   ]).default("normal"),
+  // Issue #126：冲突阶段的动作集。"conflict"（默认 = 现状）只用 conflict/keep——
+  // 后台自动流程不静默扩张行为；"full" 开放六分支（merge / update / supersede /
+  // differentiate / conflict / keep），互补型与演进型重复因此有了正确出口，不再
+  // 被迫"输赢化"（实测抽样 10 对里 2 对属演进型/互补型，用 conflict 处理会丢信息）。
+  sleepActionSet: z.union([
+    z.const("conflict"),
+    z.const("full")
+  ]).default("conflict"),
   // Archival demotion tiering (days since last access):
   //   >= sleepArchiveDays  → shrink to summary, full body kept in _full_content
   //   >= sleepCompressDays → archived outright (entity relations preserved)
@@ -281,14 +345,16 @@ export const Config = z.object({
   sleepProvider: z.string().default("").description("sleep 深维护专用模型服务商，留空用巩固模型或当前模型。"),
   sleepModel: z.string().default("").description("sleep 深维护专用模型，留空用巩固模型或当前模型；建议同巩固模型选非思考模型。"),
   // Pass-through reasoning effort for sleep's LLM passes, same semantics as
-  // dreamReasoningEffort: 'none' (default) omits the field; low/medium/high
-  // are forwarded verbatim.
+  // dreamReasoningEffort (Issue #135 建议 4/5): unset resolves to the lowest
+  // effort the model declares; explicit 'none' omits the field; off/low/
+  // medium/high are forwarded verbatim.
   sleepReasoningEffort: z.union([
+    z.const("off"),
     z.const("low"),
     z.const("medium"),
     z.const("high"),
     z.const("none")
-  ]).default("none").description("同 dreamReasoningEffort：sleep 各阶段 LLM 的推理档位，'none' 用服务商默认。"),
+  ]).description("同 dreamReasoningEffort：sleep 各阶段 LLM 的推理档位，未配置 = 自动取模型支持的最低档；显式 'none' = 不发送字段、用服务商自带默认。"),
 
   // --- epistemic trust: memory source credibility (v0.4.5) -----------------
   // Distinguish memories by source: observation (measured / witnessed),
@@ -311,7 +377,12 @@ export const Config = z.object({
     enabled: z.boolean().default(true),
     archiveThreshold: z.natural().min(1).max(100).default(30),
     degradeThreshold: z.natural().min(1).max(100).default(60),
-    minContentLength: z.natural().min(1).max(1000).default(10)
+    minContentLength: z.natural().min(1).max(1000).default(10),
+    // Issue #135 附属发现 1：importance ≥ 该值的记忆不参与静默自动归档——评分
+    // 与信号标签照常写入（可观测）、注入排序照常降权，但 setArchived 跳过。
+    // 报告实测 150 条低分归档里 128 条 importance ≥ 4（51 条 = 5）。设 1 = 全部
+    // 豁免（等效关闭自动归档），设 5 = 仅最重要的豁免。
+    exemptImportance: z.natural().min(1).max(5).default(4)
   }).default({}),
 
   // --- LLM audit trail (Bug8) ------------------------------------------------
@@ -372,6 +443,22 @@ export const Config = z.object({
   recallRecordDefault: z.boolean().default(true),
   // recall_runs 滚动清理保留天数。
   recallRetentionDays: z.natural().min(1).max(3650).default(90),
+
+  // --- scope: v0.8.0 A1 存储层（issue #17）--------------------------------
+  // 总开关默认关：关闭时写入不标注 scope、去重维持 (type, title) 现状，行为
+  // 逐字节不变。开启后 memory_save 写入 agent_scope（session header 的
+  // agentPreset）与 workspace_scope（registry 反查 canonical path，header.cwd
+  // 兜底，取不到 NULL——解析绝不阻塞写入），去重键扩展为 (type, title,
+  // agent_scope, workspace_scope, sensitivity)。检索侧加权/过滤在 A2/A3 落地。
+  // 也走 feature_flags（FEATURE_FLAG_BOOLEANS 白名单），面板可启停=线上回滚开关。
+  scopeEnabled: z.boolean().default(false),
+  // strictScope（A3）：硬过滤模式。关闭=A2 软隔离（他 scope 降权保留可见）；
+  // 开启后检索/注入/list/get 按 issue #17 四象限可见性公式硬过滤——带他 scope
+  // 的记忆完全不可见，未标注（NULL）恒可见；当前会话某维度解析不到时该维度
+  // 带标注的记忆一律不可见（fail-closed：身份不明只见全局）。依赖 scopeEnabled
+  // 打开才有意义（没有写入标注就无可过滤维度），但独立成键：可先开标注积累
+  // 数据、观察 A2 加权质量后再切硬过滤。
+  strictScope: z.boolean().default(false),
 });
 
 // Fields forced to false by the light-mode preset. Everything not listed here