dsh-layered-memory 0.8.0 → 0.8.2

package/dist/client.js

@@ -1463,6 +1463,363 @@ window.__ModuleLoader__.load({
       );
     }
 
+    // ── 蒸馏模型选择器（供应商/模型两级下拉）──
+    // 数据源：dsh-memory/llm-providers（供应商目录 + 当前覆盖 + 实际生效路由）与
+    // dsh-memory/llm-models（所选供应商的模型列表）。写入走 settings-set 的
+    // distillProvider/distillModel 两键（成对提交）。部署静态 pin（pinned）时禁用。
+    function LlmModelRow(props) {
+      var rpc = props.rpc;
+      var disabled = !!props.disabled;
+
+      // 注意：全部 hook 必须在任何提前返回之前声明（Rules of Hooks）——
+      // info 未加载的首渲染会 return null，晚于它的 useState 会让 hook 数随渲染漂移而崩溃
+      var infoState = react.useState(null);
+      var setInfo = infoState[1];
+      var modelsState = react.useState(null);
+      var setModels = modelsState[1];
+      var draftState = react.useState("");
+      var setDraft = draftState[1];
+      var manualState = react.useState("");
+      var manualModel = manualState[0];
+      var setManualModel = manualState[1];
+
+      react.useEffect(function () {
+        var load = function () {
+          rpc("dsh-memory/llm-providers", {})
+            .then(function (r) { if (r && r.ok) setInfo(r.value); })
+            .catch(function () {});
+        };
+        load();
+        var timer = setInterval(load, 5000);
+        return function () { clearInterval(timer); };
+      }, [rpc]);
+
+      var info = infoState[0];
+      // 草稿供应商（已选待挑模型）优先于已存选择
+      var draft = draftState[0];
+      var curProvider = draft || (info && info.current ? info.current.provider : "");
+      var curModel = info && info.current ? info.current.model : "";
+
+      react.useEffect(function () {
+        if (!curProvider) { setModels(null); return undefined; }
+        var alive = true;
+        setModels(null);
+        rpc("dsh-memory/llm-models", { provider: curProvider })
+          .then(function (r) { if (alive && r && r.ok) setModels(r.value.models || []); })
+          .catch(function () { if (alive) setModels([]); });
+        return function () { alive = false; };
+      }, [rpc, curProvider]);
+
+      var writeLlm = function (patch) {
+        if (!info) return;
+        // 乐观更新：立即写视图字段，失败回滚
+        var prev = info;
+        setInfo(Object.assign({}, prev, {
+          current: Object.assign({}, prev.current, patch),
+        }));
+        setDraft("");
+        rpc("dsh-memory/settings-set", patch)
+          .then(function (r) {
+            if (!r || !r.ok) {
+              setInfo(prev);
+              setDraft(draft);
+            }
+          })
+          .catch(function () {
+            setInfo(prev);
+            setDraft(draft);
+          });
+      };
+
+      if (!info) return null;
+      if (info.pinned) {
+        // 部署静态 pin：显示固定路由，选择器不出场
+        return react.createElement(
+          "div", { style: S.switchRow },
+          react.createElement("div", null,
+            react.createElement("div", { style: S.switchLabel }, "蒸馏模型"),
+            react.createElement(
+              "div", { style: S.switchDesc },
+              "已由部署配置固定：" + info.effective.provider + " / " + info.effective.model,
+            )),
+        );
+      }
+
+      var providers = info.providers || [];
+      var models = modelsState[0];
+      var providerKnown = curProvider === "" || providers.some(function (p) { return p.id === curProvider; });
+      var modelKnown = models && models.some(function (m) { return m.id === curModel; });
+      // 供应商列表为空数组 = 适配器不提供模型目录：降级为手动输入模型 id
+      var manualInput = models !== null && models.length === 0;
+
+      var defaultLabel = info.default
+        ? "跟随默认（" + info.default.provider + " / " + info.default.model + "）"
+        : "跟随默认";
+
+      var providerOptions = [{ id: "", label: defaultLabel }].concat(
+        providers.map(function (p) { return { id: p.id, label: p.name + "（" + p.id + "）" }; }),
+      );
+      if (curProvider && !providerKnown) {
+        providerOptions.push({ id: curProvider, label: curProvider + "（已不在列表）" });
+      }
+
+      var modelOptions = [{ id: "", label: "跟随默认" }].concat(
+        (models || []).map(function (m) { return { id: m.id, label: m.name !== m.id ? m.name + "（" + m.id + "）" : m.id }; }),
+      );
+      if (curModel && !modelKnown) {
+        modelOptions.push({ id: curModel, label: curModel + "（已不在列表）" });
+      }
+
+      return react.createElement(
+        "div", { style: Object.assign({}, S.switchRow, { flexWrap: "wrap" }) },
+        react.createElement(
+          "select",
+          {
+            className: "dsh-mem-select",
+            style: { flexShrink: 0, maxWidth: 220 },
+            value: curProvider,
+            disabled: disabled,
+            onChange: function (e) {
+              var v = e.target.value;
+              if (v === "") {
+                writeLlm({ distillProvider: "", distillModel: "" });
+              } else {
+                setDraft(v);
+              }
+            },
+          },
+          providerOptions.map(function (o) {
+            return react.createElement("option", { key: o.id, value: o.id }, o.label);
+          }),
+        ),
+        !curProvider
+          ? null
+          : manualInput
+            ? react.createElement(NInput, {
+                style: { flex: 1, minWidth: 160 },
+                placeholder: "模型 id（该供应商未提供列表，手动输入后回车）…",
+                value: manualModel,
+                onChange: function (e) { setManualModel(e.target.value); },
+                onKeyDown: function (e) {
+                  if (e.key === "Enter" && manualModel.trim()) {
+                    writeLlm({ distillProvider: curProvider, distillModel: manualModel.trim() });
+                    setManualModel("");
+                  }
+                },
+              })
+            : react.createElement(
+                "select",
+                {
+                  className: "dsh-mem-select",
+                  style: { flex: 1, minWidth: 160 },
+                  value: curModel,
+                  disabled: disabled || models === null,
+                  onChange: function (e) {
+                    writeLlm({ distillProvider: curProvider, distillModel: e.target.value });
+                  },
+                },
+                modelOptions.map(function (o) {
+                  return react.createElement("option", { key: o.id, value: o.id }, o.label);
+                }),
+              ),
+        react.createElement("div", null,
+          react.createElement("div", { style: S.switchLabel }, "蒸馏模型"),
+          react.createElement(
+            "div", { style: S.switchDesc },
+            info.effective
+              ? "当前生效 " + info.effective.provider + " / " + info.effective.model +
+                  (curProvider ? "" : "（跟随默认选择）")
+              : "暂无可用路由（未选择且无默认）",
+          ),
+          !providerKnown || (curModel && models !== null && !modelKnown)
+            ? react.createElement(
+                "div", { style: { fontSize: 12, color: "var(--dsh-mem-danger)" } },
+                "所选供应商或模型已不在已配置列表中，蒸馏调用可能失败，建议重新选择。",
+              )
+            : null),
+      );
+    }
+
+    // ── 蒸馏预算（分层输出 token 上限 + 输入字符上限）──
+    // 数据源：settings-get 的 budgets（current 运行时覆盖 0=跟随默认 / defaults
+    // 内置默认 / effective 实际生效）与 inputBudget（current 0=跟随配置 /
+    // fallback 静态配置值 / effective）。输出四键经 settings-set 的
+    // distillBudgets 成对提交；输入走 distillMaxInputChars 单键提交。
+    // 思考档 high/max 的 ×4 放大只作用于输出预算（提示文案注明）。
+    function BudgetInputs(props) {
+      var rpc = props.rpc;
+      var disabled = !!props.disabled;
+      var data = props.data;
+      var setData = props.setData;
+      var onError = props.onError;
+      var layers = [
+        ["extract", "抽取"],
+        ["dedup", "去重"],
+        ["l2", "L2 场景"],
+        ["l3", "L3 画像"],
+      ];
+      // 输入草稿（string|null）：击键只改本地，blur/回车才提交（input 键 = 输入预算）
+      var draftState = react.useState(null);
+      var draft = draftState[0];
+      var setDraft = draftState[1];
+
+      if (!data || !data.budgets) return null;
+      var cur = data.budgets.current || {};
+      var def = data.budgets.defaults || {};
+      var eff = data.budgets.effective || {};
+      var ib = data.inputBudget || {};
+      var curIn = ib.current || 0;
+      var effIn = ib.effective || ib.fallback || 0;
+
+      var shown = function (key) {
+        if (draft && draft[key] !== undefined) return draft[key];
+        var c = key === "input" ? curIn : cur[key];
+        return c > 0 ? String(c) : "";
+      };
+
+      /** 通用提交：patchKey 为 settings-set 载荷键名；pick 从草稿取值并校验。 */
+      var commitPart = function (keys, buildPayload, applyView) {
+        if (!draft) return;
+        var values = {};
+        for (var i = 0; i < keys.length; i++) {
+          var key = keys[i];
+          var raw = (draft[key] !== undefined ? draft[key] : shown(key)).trim();
+          var n = raw === "" ? 0 : Number(raw);
+          var max = key === "input" ? 1000000 : 1000000;
+          var min = key === "input" ? (raw === "" ? 0 : 1000) : 0;
+          if (!Number.isInteger(n) || n < min || n > max) {
+            onError(key === "input"
+              ? "输入预算须为 0 或 1000~1000000 的整数（留空或 0 = 跟随配置）"
+              : "输出预算须为 0~1000000 的整数（留空或 0 = 跟随默认）");
+            setDraft(null);
+            return;
+          }
+          values[key] = n;
+        }
+        setDraft(null);
+        var prev = data;
+        setData(applyView(prev, values));
+        rpc("dsh-memory/settings-set", buildPayload(values))
+          .then(function (r) {
+            if (!r || !r.ok) {
+              setData(prev);
+              onError(r && r.error ? "预算写入失败：" + r.error.message : "预算写入失败");
+            } else {
+              onError(null);
+            }
+          })
+          .catch(function (e) {
+            setData(prev);
+            onError("预算写入失败：" + String((e && e.message) || e));
+          });
+      };
+
+      /** 输出四键成对提交（distillBudgets）。 */
+      var commitOutputs = function () {
+        commitPart(
+          ["extract", "dedup", "l2", "l3"],
+          function (v) { return { distillBudgets: v }; },
+          function (prev, v) {
+            var effNext = {};
+            for (var j = 0; j < layers.length; j++) {
+              var k = layers[j][0];
+              effNext[k] = v[k] > 0 ? v[k] : (def[k] || 0);
+            }
+            return Object.assign({}, prev, {
+              settings: Object.assign({}, prev.settings, { distillBudgets: v }),
+              budgets: Object.assign({}, prev.budgets, { current: v, effective: effNext }),
+            });
+          },
+        );
+      };
+
+      /** 输入预算单键提交（distillMaxInputChars）。 */
+      var commitInput = function () {
+        commitPart(
+          ["input"],
+          function (v) { return { distillMaxInputChars: v.input }; },
+          function (prev, v) {
+            return Object.assign({}, prev, {
+              settings: Object.assign({}, prev.settings, { distillMaxInputChars: v.input }),
+              inputBudget: Object.assign({}, prev.inputBudget || {}, {
+                current: v.input,
+                effective: v.input > 0 ? v.input : (ib.fallback || 0),
+              }),
+            });
+          },
+        );
+      };
+
+      /** 某组键是否有未提交改动（触发 blur/Enter 提交）。 */
+      var dirty = function (keys) {
+        if (!draft) return false;
+        for (var i = 0; i < keys.length; i++) {
+          var key = keys[i];
+          var want = (draft[key] !== undefined ? draft[key] : "").trim();
+          var was = key === "input"
+            ? (curIn > 0 ? String(curIn) : "")
+            : (cur[key] > 0 ? String(cur[key]) : "");
+          if (want !== was) return true;
+        }
+        return false;
+      };
+      var outKeys = ["extract", "dedup", "l2", "l3"];
+
+      var inputBox = function (key, label, title, width, placeholder, onCommit) {
+        return react.createElement(NInput, {
+          key: key,
+          type: "number",
+          min: 0,
+          max: 1000000,
+          style: { width: width },
+          title: title,
+          placeholder: String(placeholder || ""),
+          value: shown(key),
+          disabled: disabled,
+          onChange: function (e) {
+            var v = e.target.value;
+            var d = Object.assign({}, draft || {});
+            d[key] = v;
+            setDraft(d);
+          },
+          onBlur: function () { if (dirty([key])) onCommit(); },
+          onKeyDown: function (e) { if (e.key === "Enter" && dirty([key])) onCommit(); },
+        });
+      };
+
+      return react.createElement(
+        "div", null,
+        react.createElement(
+          "div", { style: S.switchRow },
+          react.createElement(
+            "div", { style: Object.assign({}, S.flexRow, { gap: 6 }) },
+            layers.map(function (l) {
+              return inputBox(l[0], l[1], l[1] + " 输出预算（token，留空 = 默认 " + (def[l[0]] || "?") + "）", 92, def[l[0]], commitOutputs);
+            }),
+          ),
+          react.createElement("div", null,
+            react.createElement("div", { style: S.switchLabel }, "输出预算"),
+            react.createElement(
+              "div", { style: S.switchDesc },
+              "各蒸馏层单次输出的 token 上限（抽取/去重/L2/L3）；留空或 0 = 跟随默认（当前生效 " +
+                layers.map(function (l) { return eff[l[0]] || "?"; }).join(" / ") +
+                "）；思考档 high/max 时实际限额自动 ×4",
+            )),
+        ),
+        react.createElement(
+          "div", { style: S.switchRow },
+          inputBox("input", "输入", "单次蒸馏输入字符上限（≈token，中文 1 字≈1 token；留空 = 跟随配置 " + (ib.fallback || "?") + "）", 120, ib.fallback, commitInput),
+          react.createElement("div", null,
+            react.createElement("div", { style: S.switchLabel }, "输入预算"),
+            react.createElement(
+              "div", { style: S.switchDesc },
+              "单次蒸馏调用的输入字符上限（≈token）：L1 抽取按此分块、L2/L3 超限截断；" +
+                "留空或 0 = 跟随配置（当前生效 " + (effIn || "?") + "，来自 llm.maxInputChars）",
+            )),
+        ),
+      );
+    }
+
     // ── Tab：概览（开关面板 + 计数） ──
     function OverviewTab(props) {
       var rpc = props.rpc;
@@ -1567,6 +1924,8 @@ window.__ModuleLoader__.load({
           : settingsData
             ? react.createElement(
                 "div", { style: S.switchPanel },
+                // 分组：记忆模式（总闸与三个分项开关）
+                react.createElement("div", { style: S.panelLabel }, "记忆模式"),
                 react.createElement(SwitchRow, {
                   label: "记忆模式",
                   desc: master ? "已开启：捕获对话并蒸馏记忆" : "已关闭：不捕获、不蒸馏、不注入（数据保留）",
@@ -1594,6 +1953,8 @@ window.__ModuleLoader__.load({
                   disabled: !master,
                   onChange: function (v) { toggle("recall", v); },
                 }),
+                // 分组：蒸馏参数（模型路由 / 思考档位 / 输出预算）
+                react.createElement("div", { style: S.panelLabel }, "蒸馏参数"),
                 settingsData.effort
                   ? react.createElement(
                       "div",
@@ -1619,6 +1980,14 @@ window.__ModuleLoader__.load({
                         )),
                     )
                   : null,
+                react.createElement(LlmModelRow, { rpc: rpc, disabled: !master }),
+                react.createElement(BudgetInputs, {
+                  rpc: rpc,
+                  disabled: !master,
+                  data: settingsData,
+                  setData: setSettingsData,
+                  onError: setError,
+                }),
                 ceilingNote
                   ? react.createElement("p", { style: S.hint }, ceilingNote)
                   : null,

package/dist/config.d.ts

@@ -77,6 +77,9 @@ export interface MemoryConfig {
         allowLocalModels: boolean;
         /** 模型下载镜像根地址（默认国内可达的 hf-mirror.com，可改回官方）。 */
         mirror: string;
+        /** 模型下载代理三态：''（默认）= 探测代理环境变量（HTTPS_PROXY/ALL_PROXY 等）；
+         *  'none' = 禁用强制直连；其他值 = 代理 URL（如 http://127.0.0.1:7890）。 */
+        proxy: string;
     };
     llm: {
         /** 蒸馏用的 provider 路由；留空用当前默认选择。 */
@@ -92,6 +95,14 @@ export interface MemoryConfig {
         maxInputChars: number;
         /** 单次蒸馏调用超时（ms）。 */
         timeoutMs: number;
+        /** 分层输出预算运行时覆盖（设置页 distillBudgets 经 effectiveCfg 注入；
+         *  0/缺省 = 用内置默认。不属于静态 schema——预算无部署上限语义，只有运行时偏好）。 */
+        budgets?: Partial<{
+            extract: number;
+            dedup: number;
+            l2: number;
+            l3: number;
+        }>;
     };
     /** 是否注册模型可调用的记忆工具。 */
     tools: boolean;
@@ -170,6 +181,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         timeoutMs: Schema<number, number>;
         allowLocalModels: Schema<boolean, boolean>;
         mirror: Schema<string, string>;
+        proxy: Schema<string, string>;
     }>, Schemastery.ObjectT<{
         enabled: Schema<boolean, boolean>;
         baseUrl: Schema<string, string>;
@@ -180,6 +192,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         timeoutMs: Schema<number, number>;
         allowLocalModels: Schema<boolean, boolean>;
         mirror: Schema<string, string>;
+        proxy: Schema<string, string>;
     }>>;
     llm: Schema<Schemastery.ObjectS<{
         provider: Schema<string, string>;
@@ -273,6 +286,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         timeoutMs: Schema<number, number>;
         allowLocalModels: Schema<boolean, boolean>;
         mirror: Schema<string, string>;
+        proxy: Schema<string, string>;
     }>, Schemastery.ObjectT<{
         enabled: Schema<boolean, boolean>;
         baseUrl: Schema<string, string>;
@@ -283,6 +297,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         timeoutMs: Schema<number, number>;
         allowLocalModels: Schema<boolean, boolean>;
         mirror: Schema<string, string>;
+        proxy: Schema<string, string>;
     }>>;
     llm: Schema<Schemastery.ObjectS<{
         provider: Schema<string, string>;

package/dist/config.js

@@ -53,6 +53,7 @@ export const memorySchema = Schema.object({
         timeoutMs: Schema.number().min(1000).max(300_000).default(10_000),
         allowLocalModels: Schema.boolean().default(true),
         mirror: Schema.string().default('https://hf-mirror.com'),
+        proxy: Schema.string().default(''),
     }),
     llm: Schema.object({
         provider: Schema.string().default(''),

package/dist/index.d.ts

@@ -82,6 +82,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
         allowLocalModels: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         mirror: import("@deepseek-ai/schemastery").default<string, string>;
+        proxy: import("@deepseek-ai/schemastery").default<string, string>;
     }>, Schemastery.ObjectT<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         baseUrl: import("@deepseek-ai/schemastery").default<string, string>;
@@ -92,6 +93,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
         allowLocalModels: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         mirror: import("@deepseek-ai/schemastery").default<string, string>;
+        proxy: import("@deepseek-ai/schemastery").default<string, string>;
     }>>;
     llm: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
         provider: import("@deepseek-ai/schemastery").default<string, string>;
@@ -185,6 +187,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
         allowLocalModels: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         mirror: import("@deepseek-ai/schemastery").default<string, string>;
+        proxy: import("@deepseek-ai/schemastery").default<string, string>;
     }>, Schemastery.ObjectT<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         baseUrl: import("@deepseek-ai/schemastery").default<string, string>;
@@ -195,6 +198,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
         allowLocalModels: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         mirror: import("@deepseek-ai/schemastery").default<string, string>;
+        proxy: import("@deepseek-ai/schemastery").default<string, string>;
     }>>;
     llm: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
         provider: import("@deepseek-ai/schemastery").default<string, string>;

package/dist/index.js

@@ -39,6 +39,7 @@ import { StateStore } from './store/state.js';
 import { registerMemoryTools } from './tools/index.js';
 import { errDetail, withFileLog } from './util/filelog.js';
 import { resolveModelRoute } from './llm.js';
+import { effectiveCfg } from './pipeline/runner.js';
 export const name = 'dsh-memory-plugin';
 /** 硬依赖：蒸馏要用 llm，工具注册要用 tools，召回注入要用 systemPrompt。 */
 export const inject = ['llm', 'tools', 'systemPrompt'];
@@ -86,7 +87,11 @@ export async function apply(ctx, config) {
     // ── 嵌入源三态（D4：远程/本地/关闭）——状态文件优先于静态配置 ──
     const sourceStore = new EmbeddingSourceStore(dataDir, logger);
     const installer = new RuntimeInstaller(dataDir, PINNED_TRANSFORMERS_VERSION, { logger });
-    const downloader = new ModelDownloadQueue(dataDir, { mirror: config.embedding.mirror, logger });
+    const downloader = new ModelDownloadQueue(dataDir, {
+        mirror: config.embedding.mirror,
+        logger,
+        proxy: config.embedding.proxy,
+    });
     const makeLocalService = makeLocalServiceFactory(installer, downloader, logger);
     let initial = { svc: new NoopEmbeddingService(), dims: 0 };
     /** 管理器引用：启动重嵌链/backfill 闭包在运行期解引用（声明早于创建避免 TDZ）。 */
@@ -157,9 +162,10 @@ export async function apply(ctx, config) {
         logger.warn(`[memory] 检索策略 ${config.recall.strategy} 需要向量能力（embedding 未启用/不可用），本次运行按 keyword（FTS5 BM25）检索`);
     }
     logger.info(`[memory] 数据目录: ${dataDir}（v${PLUGIN_VERSION}，默认档=${config.family}，检索: FTS=${caps.ftsSearch} 向量=${caps.vectorSearch}${storageOk ? '' : '，存储不可用已停用捕获/蒸馏'}）`);
-    // 蒸馏模型路由：启动期解析一次并记录（路由错误是最难事后排查的问题之一）
+    // 蒸馏模型路由：启动期解析一次并记录（路由错误是最难事后排查的问题之一）；
+    // 用运行时调参视图解析——用户已用 UI 覆盖蒸馏模型时，日志反映实际路由
     try {
-        const route = await resolveModelRoute(ctx, config);
+        const route = await resolveModelRoute(ctx, effectiveCfg(config, live));
         logger.info(`[memory] 蒸馏模型路由: ${route.provider}/${route.model}`);
     }
     catch (err) {
@@ -298,6 +304,7 @@ export async function apply(ctx, config) {
         disposed = true;
         runner.stop();
         embedManager?.dispose();
+        downloader.dispose();
         return (async () => {
             await flushL0?.();
             db.close();

package/dist/llm.d.ts

@@ -21,6 +21,21 @@ export declare const LAYER_MAX_TOKENS_DEDUP = 8000;
 export declare const LAYER_MAX_TOKENS_L2 = 32000;
 /** L3 画像（完整 persona 文档）。 */
 export declare const LAYER_MAX_TOKENS_L3 = 16000;
+/** 分层输出预算键（运行时设置 / UI 与内置默认共用同一套键名）。 */
+export type DistillBudgetLayer = 'extract' | 'dedup' | 'l2' | 'l3';
+/** 各层内置默认预算（设置页"0 = 跟随默认"的默认值来源）。 */
+export declare const LAYER_DEFAULT_BUDGETS: Record<DistillBudgetLayer, number>;
+/**
+ * 解析某蒸馏层的生效输出预算：运行时覆盖（cfg.llm.budgets，由 effectiveCfg 从
+ * 设置页 distillBudgets 注入，0/缺省 = 跟随）→ 内置默认 → 思考档放大
+ * （high/max ×4，reasoning 计入输出预算的历史事故防线）。
+ */
+export declare function resolveLayerTokens(cfg: {
+    llm: {
+        reasoningEffort: string;
+        budgets?: Partial<Record<DistillBudgetLayer, number>>;
+    };
+}, layer: DistillBudgetLayer): number;
 /**
  * 思考档预算放大：reasoning 计入输出预算（v4-flash 事故：high 思考可吃光全部
  * 预算致正文 0 字符）——effort 为 high/max 时分层预算 ×4。

package/dist/llm.js

@@ -10,6 +10,22 @@ export const LAYER_MAX_TOKENS_DEDUP = 8_000;
 export const LAYER_MAX_TOKENS_L2 = 32_000;
 /** L3 画像（完整 persona 文档）。 */
 export const LAYER_MAX_TOKENS_L3 = 16_000;
+/** 各层内置默认预算（设置页"0 = 跟随默认"的默认值来源）。 */
+export const LAYER_DEFAULT_BUDGETS = {
+    extract: LAYER_MAX_TOKENS_EXTRACT,
+    dedup: LAYER_MAX_TOKENS_DEDUP,
+    l2: LAYER_MAX_TOKENS_L2,
+    l3: LAYER_MAX_TOKENS_L3,
+};
+/**
+ * 解析某蒸馏层的生效输出预算：运行时覆盖（cfg.llm.budgets，由 effectiveCfg 从
+ * 设置页 distillBudgets 注入，0/缺省 = 跟随）→ 内置默认 → 思考档放大
+ * （high/max ×4，reasoning 计入输出预算的历史事故防线）。
+ */
+export function resolveLayerTokens(cfg, layer) {
+    const override = cfg.llm.budgets?.[layer];
+    return layerMaxTokens(override && override > 0 ? override : LAYER_DEFAULT_BUDGETS[layer], cfg.llm.reasoningEffort);
+}
 /**
  * 思考档预算放大：reasoning 计入输出预算（v4-flash 事故：high 思考可吃光全部
  * 预算致正文 0 字符）——effort 为 high/max 时分层预算 ×4。

package/dist/pipeline/l1.js

@@ -3,7 +3,7 @@
  * 移植 MemoryCore 的 l1 runner 语义（抽取 prompt → batch 冲突检测 → apply）。
  */
 import { randomBytes } from 'node:crypto';
-import { callLLM, layerMaxTokens, LAYER_MAX_TOKENS_DEDUP, LAYER_MAX_TOKENS_EXTRACT, parseJsonLogged } from '../llm.js';
+import { callLLM, parseJsonLogged, resolveLayerTokens } from '../llm.js';
 import { formatExtractionPrompt, getExtractMemoriesSystemPrompt } from '../prompts/l1-extraction.js';
 import { formatBatchConflictPrompt, getConflictDetectionSystemPrompt } from '../prompts/l1-dedup.js';
 import { familyForType } from '../types.js';
@@ -63,7 +63,7 @@ export async function runExtraction(ctx, cfg, store, states, pending, background
         const raw = await callLLM(ctx, cfg, {
             system: getExtractMemoriesSystemPrompt(mode),
             user: userPrompt,
-            maxTokens: layerMaxTokens(LAYER_MAX_TOKENS_EXTRACT, cfg.llm.reasoningEffort),
+            maxTokens: resolveLayerTokens(cfg, 'extract'),
             logger,
         });
         const scenes = parseJsonLogged(raw, 'L1 抽取', logger);
@@ -101,7 +101,7 @@ export async function runExtraction(ctx, cfg, store, states, pending, background
     const dedupRaw = await callLLM(ctx, cfg, {
         system: getConflictDetectionSystemPrompt(mode),
         user: dedupPrompt,
-        maxTokens: layerMaxTokens(LAYER_MAX_TOKENS_DEDUP, cfg.llm.reasoningEffort),
+        maxTokens: resolveLayerTokens(cfg, 'dedup'),
         logger,
     });
     const decisions = parseJsonLogged(dedupRaw, 'L1 去重判定', logger);

package/dist/pipeline/l2.js

@@ -1,4 +1,4 @@
-import { callLLM, layerMaxTokens, LAYER_MAX_TOKENS_L2, parseJsonLogged } from '../llm.js';
+import { callLLM, parseJsonLogged, resolveLayerTokens } from '../llm.js';
 import { buildScenePrompt, formatSceneSummaries } from '../prompts/scene.js';
 import { Bm25Index } from '../store/bm25.js';
 const REQUEST_RE = /\[PERSONA_UPDATE_REQUEST\]\s*reason:\s*([\s\S]*?)\[\/PERSONA_UPDATE_REQUEST\]/;
@@ -30,7 +30,7 @@ export async function runSceneConsolidation(ctx, cfg, scenes, newMemories, logge
     const raw = await callLLM(ctx, cfg, {
         system: systemPrompt,
         user: userPrompt,
-        maxTokens: layerMaxTokens(LAYER_MAX_TOKENS_L2, cfg.llm.reasoningEffort),
+        maxTokens: resolveLayerTokens(cfg, 'l2'),
         logger,
     });
     // ── 解析：先取 PERSONA_UPDATE_REQUEST 标记，再解析操作数组 ──

package/dist/pipeline/l3.js

@@ -1,4 +1,4 @@
-import { callLLM, layerMaxTokens, LAYER_MAX_TOKENS_L3 } from '../llm.js';
+import { callLLM, resolveLayerTokens } from '../llm.js';
 import { buildPersonaPrompt } from '../prompts/persona.js';
 export async function runPersona(ctx, cfg, scenes, persona, state, logger, family) {
     if (!cfg.l3.enabled)
@@ -51,7 +51,7 @@ export async function runPersona(ctx, cfg, scenes, persona, state, logger, famil
     const raw = await callLLM(ctx, cfg, {
         system: systemPrompt,
         user: userPrompt,
-        maxTokens: layerMaxTokens(LAYER_MAX_TOKENS_L3, cfg.llm.reasoningEffort),
+        maxTokens: resolveLayerTokens(cfg, 'l3'),
         logger,
     });
     const body = unwrapFence(raw);

package/dist/pipeline/rebuild.js

@@ -99,7 +99,7 @@ export class RebuildController {
                 ...this.status,
                 sessionCount: est.sessions,
                 messageCount: est.messages,
-                estCalls: estimateCalls(est.sessions, est.messages, est.chars, this.cfg.llm.maxInputChars),
+                estCalls: estimateCalls(est.sessions, est.messages, est.chars, effectiveCfg(this.cfg, this.live).llm.maxInputChars),
             };
         }
         return { ...this.status };
@@ -123,7 +123,7 @@ export class RebuildController {
             phase: 'preparing',
             sessionCount: est.sessions,
             messageCount: est.messages,
-            estCalls: estimateCalls(est.sessions, est.messages, est.chars, this.cfg.llm.maxInputChars),
+            estCalls: estimateCalls(est.sessions, est.messages, est.chars, effectiveCfg(this.cfg, this.live).llm.maxInputChars),
             startedAt: Date.now(),
         };
         this.runner.enqueueRebuildTask(() => this.prepare());