dsh-layered-memory 0.8.2 → 0.8.4

package/dist/config.d.ts

@@ -5,6 +5,13 @@
  */
 import Schema from '@deepseek-ai/schemastery';
 import type { ExtractMode } from './types.js';
+/**
+ * 蒸馏思考档位全词汇表（唯一事实源）：'' = 自动（模型默认档 → high），
+ * 其余为各适配器通用档位词汇表（deepseek 认 'off'，OpenAI 系是 'none'）。
+ * schema（config/settings）、运行时解析（settings.resolveSettings）与 RPC
+ * 写入门（stats.settings-set）共用，勿在别处再抄字面量表。
+ */
+export declare const EFFORT_CHOICES: readonly ["", "off", "none", "minimal", "low", "medium", "high", "xhigh", "max"];
 export interface MemoryConfig {
     /** 数据目录；留空则用 $DSH_HOME/memory。 */
     dataDir: string;
@@ -198,7 +205,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         provider: Schema<string, string>;
         model: Schema<string, string>;
         maxTokens: Schema<number, number>;
-        reasoningEffort: Schema<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
+        reasoningEffort: Schema<"" | "off" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max", "" | "off" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max">;
         temperature: Schema<number, number>;
         maxInputChars: Schema<number, number>;
         timeoutMs: Schema<number, number>;
@@ -206,7 +213,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         provider: Schema<string, string>;
         model: Schema<string, string>;
         maxTokens: Schema<number, number>;
-        reasoningEffort: Schema<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
+        reasoningEffort: Schema<"" | "off" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max", "" | "off" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max">;
         temperature: Schema<number, number>;
         maxInputChars: Schema<number, number>;
         timeoutMs: Schema<number, number>;
@@ -303,7 +310,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         provider: Schema<string, string>;
         model: Schema<string, string>;
         maxTokens: Schema<number, number>;
-        reasoningEffort: Schema<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
+        reasoningEffort: Schema<"" | "off" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max", "" | "off" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max">;
         temperature: Schema<number, number>;
         maxInputChars: Schema<number, number>;
         timeoutMs: Schema<number, number>;
@@ -311,7 +318,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
         provider: Schema<string, string>;
         model: Schema<string, string>;
         maxTokens: Schema<number, number>;
-        reasoningEffort: Schema<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
+        reasoningEffort: Schema<"" | "off" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max", "" | "off" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max">;
         temperature: Schema<number, number>;
         maxInputChars: Schema<number, number>;
         timeoutMs: Schema<number, number>;

package/dist/config.js

@@ -5,6 +5,13 @@
  */
 import Schema from '@deepseek-ai/schemastery';
 import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
+/**
+ * 蒸馏思考档位全词汇表（唯一事实源）：'' = 自动（模型默认档 → high），
+ * 其余为各适配器通用档位词汇表（deepseek 认 'off'，OpenAI 系是 'none'）。
+ * schema（config/settings）、运行时解析（settings.resolveSettings）与 RPC
+ * 写入门（stats.settings-set）共用，勿在别处再抄字面量表。
+ */
+export const EFFORT_CHOICES = ['', 'off', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
 export const memorySchema = Schema.object({
     dataDir: Schema.string().default(''),
     family: Schema.union(['auto', 'chat', 'work']).default('auto'),
@@ -61,9 +68,10 @@ export const memorySchema = Schema.object({
         // 推理模型（如 v4-flash）的 reasoning 计入输出预算：预算不足会被思考吃光导致正文 0 字符。
         // 0.8.0 起各蒸馏层显式传分层预算（见 llm.ts LAYER_MAX_TOKENS_*），本值为未分层调用的兜底总闸
         maxTokens: Schema.number().min(1024).max(1_000_000).default(65_536),
-        // 蒸馏是结构化抽取任务，默认关思考（off）：v4-flash 默认 high 档的思考可把任意 maxTokens
-        // 预算全部吃光导致正文 0 字符；非推理模型不认识 effort 时会报 UNSUPPORTED_REASONING_EFFORT，设空串跳过
-        reasoningEffort: Schema.union(['', 'off', 'high', 'max']).default('off'),
+        // 蒸馏思考档位：'' = 自动（按模型能力解析：模型默认档 → high，见 llm.ts decideSendableEffort）；
+        // 显式值仅在该模型声明支持时发送（跨供应商 effort 词汇表不同：deepseek 认 'off'，
+        // openai 系是 'none'，未声明档位的模型不传）。旧默认 'off' 在非 deepseek 模型上必炸（400/本地拒绝）
+        reasoningEffort: Schema.union([...EFFORT_CHOICES]).default(''),
         temperature: Schema.number().min(0).max(2).default(0.3),
         // 模型上下文 1M token，日常压到 ~700k 使用（中文按 1 字≈1 token 保守折算）
         maxInputChars: Schema.number().min(1000).max(1_000_000).default(700_000),

package/dist/index.d.ts

@@ -99,7 +99,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         provider: import("@deepseek-ai/schemastery").default<string, string>;
         model: import("@deepseek-ai/schemastery").default<string, string>;
         maxTokens: import("@deepseek-ai/schemastery").default<number, number>;
-        reasoningEffort: import("@deepseek-ai/schemastery").default<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
+        reasoningEffort: import("@deepseek-ai/schemastery").default<"" | "off" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max", "" | "off" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max">;
         temperature: import("@deepseek-ai/schemastery").default<number, number>;
         maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
@@ -107,7 +107,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         provider: import("@deepseek-ai/schemastery").default<string, string>;
         model: import("@deepseek-ai/schemastery").default<string, string>;
         maxTokens: import("@deepseek-ai/schemastery").default<number, number>;
-        reasoningEffort: import("@deepseek-ai/schemastery").default<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
+        reasoningEffort: import("@deepseek-ai/schemastery").default<"" | "off" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max", "" | "off" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max">;
         temperature: import("@deepseek-ai/schemastery").default<number, number>;
         maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
@@ -204,7 +204,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         provider: import("@deepseek-ai/schemastery").default<string, string>;
         model: import("@deepseek-ai/schemastery").default<string, string>;
         maxTokens: import("@deepseek-ai/schemastery").default<number, number>;
-        reasoningEffort: import("@deepseek-ai/schemastery").default<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
+        reasoningEffort: import("@deepseek-ai/schemastery").default<"" | "off" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max", "" | "off" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max">;
         temperature: import("@deepseek-ai/schemastery").default<number, number>;
         maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;
@@ -212,7 +212,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
         provider: import("@deepseek-ai/schemastery").default<string, string>;
         model: import("@deepseek-ai/schemastery").default<string, string>;
         maxTokens: import("@deepseek-ai/schemastery").default<number, number>;
-        reasoningEffort: import("@deepseek-ai/schemastery").default<"" | "off" | "high" | "max", "" | "off" | "high" | "max">;
+        reasoningEffort: import("@deepseek-ai/schemastery").default<"" | "off" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max", "" | "off" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max">;
         temperature: import("@deepseek-ai/schemastery").default<number, number>;
         maxInputChars: import("@deepseek-ai/schemastery").default<number, number>;
         timeoutMs: import("@deepseek-ai/schemastery").default<number, number>;

package/dist/index.js

@@ -38,7 +38,7 @@ import { SessionModeStore } from './store/session-modes.js';
 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 { resolveModelRoute, invalidateEffortCache } from './llm.js';
 import { effectiveCfg } from './pipeline/runner.js';
 export const name = 'dsh-memory-plugin';
 /** 硬依赖：蒸馏要用 llm，工具注册要用 tools，召回注入要用 systemPrompt。 */
@@ -60,6 +60,8 @@ export async function apply(ctx, config) {
     // dsh 宿主无持久化日志，镜像 info+ 到数据目录 memory.log 供蒸馏问题诊断
     const fileLogger = withFileLog(dataDir, logger);
     logger = fileLogger;
+    // 供应商拓扑变化（增删/改配置）→ 思考档位能力缓存失效，下次调用重新探询
+    ctx.on('llm/adapters-updated', () => invalidateEffortCache());
     // 存储初始化失败只降级（禁用捕获/蒸馏），绝不拖垮宿主——
     // 记忆是增强能力，数据目录不可写时 dsh 本体必须照常启动。
     let storageOk = true;
@@ -92,7 +94,7 @@ export async function apply(ctx, config) {
         logger,
         proxy: config.embedding.proxy,
     });
-    const makeLocalService = makeLocalServiceFactory(installer, downloader, logger);
+    const makeLocalService = makeLocalServiceFactory(installer, downloader, logger, config.embedding.maxInputChars);
     let initial = { svc: new NoopEmbeddingService(), dims: 0 };
     /** 管理器引用：启动重嵌链/backfill 闭包在运行期解引用（声明早于创建避免 TDZ）。 */
     let embedManagerRef;

package/dist/llm.d.ts

@@ -28,7 +28,7 @@ export declare const LAYER_DEFAULT_BUDGETS: Record<DistillBudgetLayer, number>;
 /**
  * 解析某蒸馏层的生效输出预算：运行时覆盖（cfg.llm.budgets，由 effectiveCfg 从
  * 设置页 distillBudgets 注入，0/缺省 = 跟随）→ 内置默认 → 思考档放大
- * （high/max ×4，reasoning 计入输出预算的历史事故防线）。
+ * （high/xhigh/max ×4，reasoning 计入输出预算的历史事故防线）。
  */
 export declare function resolveLayerTokens(cfg: {
     llm: {
@@ -36,9 +36,15 @@ export declare function resolveLayerTokens(cfg: {
         budgets?: Partial<Record<DistillBudgetLayer, number>>;
     };
 }, layer: DistillBudgetLayer): number;
+/**
+ * 高思考档集合（输出预算 ×4 的档位）：阶段侧 layerMaxTokens 与 callLLM 的
+ * 自动档防线共用同一张表——此前两处字面量表分叉（防线漏 xhigh），显式 xhigh
+ * 配置被双重放大 ×16。勿再在别处抄写该列表。
+ */
+export declare const HIGH_EFFORT_TIERS: readonly ["high", "xhigh", "max"];
 /**
  * 思考档预算放大：reasoning 计入输出预算（v4-flash 事故：high 思考可吃光全部
- * 预算致正文 0 字符）——effort 为 high/max 时分层预算 ×4。
+ * 预算致正文 0 字符）——effort 为 high/xhigh/max 时分层预算 ×4。
  */
 export declare function layerMaxTokens(base: number, reasoningEffort: string): number;
 /** 解析蒸馏用的 provider/model：配置优先，其次当前默认选择。 */
@@ -46,6 +52,26 @@ export declare function resolveModelRoute(ctx: Context, cfg: MemoryConfig): Prom
     provider: string;
     model: string;
 }>;
+export interface ModelEffortInfo {
+    /** 模型可设置的思考档位 id（适配器声明；空 = 未声明/不可设置） */
+    efforts: string[];
+    /** 适配器配置的默认档位（省略 effort 时的请求值） */
+    defaultEffort?: string;
+}
+/** 清空能力缓存（llm/adapters-updated 时调用：供应商增删/改配置后重新探询）。 */
+export declare function invalidateEffortCache(): void;
+/** 探询某模型的思考档位能力；失败返回 null（调用方保持旧发送行为，不改判）。 */
+export declare function resolveModelEfforts(ctx: Context, provider: string, model: string): Promise<ModelEffortInfo | null>;
+export type EffortDecisionReason = 'supported' | 'auto-default' | 'auto-high' | 'alias-none' | 'unsupported' | 'no-efforts' | 'no-capability';
+export interface EffortDecision {
+    /** 实际发送的档位；'' = 不发送（跟随模型默认） */
+    effort: string;
+    reason: EffortDecisionReason;
+}
+/** 纯决策：配置档位 + 模型能力 → 实际发送值（callLLM 与 settings-get 共用）。 */
+export declare function decideSendableEffort(cap: ModelEffortInfo | null, cfgEffort: string): EffortDecision;
+/** 探询 + 决策 + 一次性告警（不支持/未声明时提示降级，不刷屏）。 */
+export declare function planDistillEffort(ctx: Context, provider: string, model: string, cfgEffort: string, logger?: MemoryLogger): Promise<EffortDecision>;
 /**
  * 一次完整蒸馏调用：流式收集文本，返回最终字符串。
  * 失败（error/aborted finish）抛错，由调用方兜底。

package/dist/llm.js

@@ -20,18 +20,24 @@ export const LAYER_DEFAULT_BUDGETS = {
 /**
  * 解析某蒸馏层的生效输出预算：运行时覆盖（cfg.llm.budgets，由 effectiveCfg 从
  * 设置页 distillBudgets 注入，0/缺省 = 跟随）→ 内置默认 → 思考档放大
- * （high/max ×4，reasoning 计入输出预算的历史事故防线）。
+ * （high/xhigh/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);
 }
+/**
+ * 高思考档集合（输出预算 ×4 的档位）：阶段侧 layerMaxTokens 与 callLLM 的
+ * 自动档防线共用同一张表——此前两处字面量表分叉（防线漏 xhigh），显式 xhigh
+ * 配置被双重放大 ×16。勿再在别处抄写该列表。
+ */
+export const HIGH_EFFORT_TIERS = ['high', 'xhigh', 'max'];
 /**
  * 思考档预算放大：reasoning 计入输出预算（v4-flash 事故：high 思考可吃光全部
- * 预算致正文 0 字符）——effort 为 high/max 时分层预算 ×4。
+ * 预算致正文 0 字符）——effort 为 high/xhigh/max 时分层预算 ×4。
  */
 export function layerMaxTokens(base, reasoningEffort) {
-    return reasoningEffort === 'high' || reasoningEffort === 'max' ? base * 4 : base;
+    return HIGH_EFFORT_TIERS.includes(reasoningEffort) ? base * 4 : base;
 }
 /** 解析蒸馏用的 provider/model：配置优先，其次当前默认选择。 */
 export async function resolveModelRoute(ctx, cfg) {
@@ -46,6 +52,75 @@ export async function resolveModelRoute(ctx, cfg) {
     }
     throw new Error('无法解析蒸馏模型路由：请在插件 config 中配置 llm.provider / llm.model，或确保存在默认模型选择');
 }
+const effortCache = new Map();
+/** 清空能力缓存（llm/adapters-updated 时调用：供应商增删/改配置后重新探询）。 */
+export function invalidateEffortCache() {
+    effortCache.clear();
+    effortWarned.clear();
+}
+/** 探询某模型的思考档位能力；失败返回 null（调用方保持旧发送行为，不改判）。 */
+export async function resolveModelEfforts(ctx, provider, model) {
+    const key = `${provider}::${model}`;
+    const hit = effortCache.get(key);
+    if (hit)
+        return hit;
+    try {
+        if (typeof ctx.llm?.resolveModelInfo !== 'function')
+            return null;
+        const info = await ctx.llm.resolveModelInfo(provider, model);
+        const efforts = (info.reasoning?.efforts ?? [])
+            .map((e) => String(e.id))
+            .filter((id) => id.length > 0);
+        const cap = {
+            efforts,
+            ...(info.reasoning?.defaultEffort ? { defaultEffort: String(info.reasoning.defaultEffort) } : {}),
+        };
+        effortCache.set(key, cap);
+        return cap;
+    }
+    catch {
+        return null; // 不缓存失败：路由尚未注册等瞬时态，下次调用重试
+    }
+}
+/** 纯决策：配置档位 + 模型能力 → 实际发送值（callLLM 与 settings-get 共用）。 */
+export function decideSendableEffort(cap, cfgEffort) {
+    if (!cap)
+        return { effort: cfgEffort, reason: 'no-capability' };
+    if (cfgEffort) {
+        if (cap.efforts.includes(cfgEffort))
+            return { effort: cfgEffort, reason: 'supported' };
+        if (cfgEffort === 'off' && cap.efforts.includes('none'))
+            return { effort: 'none', reason: 'alias-none' };
+        if (cap.efforts.length === 0)
+            return { effort: '', reason: 'no-efforts' };
+        return { effort: '', reason: 'unsupported' };
+    }
+    // 空配置 = 自动：模型默认档 → 无默认取 high（用户规则：未声明/无默认一律 high）→ 仍无则不传
+    if (cap.defaultEffort && cap.efforts.includes(cap.defaultEffort)) {
+        return { effort: cap.defaultEffort, reason: 'auto-default' };
+    }
+    if (cap.efforts.includes('high'))
+        return { effort: 'high', reason: 'auto-high' };
+    return { effort: '', reason: 'no-efforts' };
+}
+const effortWarned = new Set();
+/** 探询 + 决策 + 一次性告警（不支持/未声明时提示降级，不刷屏）。 */
+export async function planDistillEffort(ctx, provider, model, cfgEffort, logger) {
+    const cap = await resolveModelEfforts(ctx, provider, model);
+    const d = decideSendableEffort(cap, cfgEffort);
+    if ((d.reason === 'unsupported' || d.reason === 'no-efforts') && logger) {
+        const key = `${provider}::${model}::${cfgEffort}::${d.reason}`;
+        if (!effortWarned.has(key)) {
+            effortWarned.add(key);
+            logger.warn(`[memory] 蒸馏思考档位 ${cfgEffort || '(auto)'} 不被 ${provider}/${model} 支持` +
+                (d.reason === 'no-efforts'
+                    ? '（模型未声明思考档位）'
+                    : `（支持: ${cap?.efforts.join('/')}）`) +
+                '，本次调用不传档位（跟随模型默认）');
+        }
+    }
+    return d;
+}
 /**
  * 一次完整蒸馏调用：流式收集文本，返回最终字符串。
  * 失败（error/aborted finish）抛错，由调用方兜底。
@@ -56,22 +131,31 @@ export async function resolveModelRoute(ctx, cfg) {
 export async function callLLM(ctx, cfg, opts) {
     const { provider, model } = await resolveModelRoute(ctx, cfg);
     const signal = opts.signal ?? AbortSignal.timeout(cfg.llm.timeoutMs);
+    // 档位按模型能力决策（跨供应商 effort 兼容）：不支持的档位不传 + 告警一次，
+    // 空配置 = 自动（模型默认档 → high）；详见 decideSendableEffort
+    const effort = await planDistillEffort(ctx, provider, model, cfg.llm.reasoningEffort, opts.logger);
     // 输入预算兜底：任何蒸馏调用的用户 prompt 不超过 maxInputChars
     // （L1 已在数据层分块，这里是 L2/L3 与异常场景的最后一道网）
     const user = opts.user.length > cfg.llm.maxInputChars
         ? `${opts.user.slice(0, cfg.llm.maxInputChars)}\n\n[输入超出 ${cfg.llm.maxInputChars} 字符预算，已截断]`
         : opts.user;
+    // 输出预算 ×4 防线跟随【实际发送】的档位：阶段侧已按原始配置的高档位
+    // （HIGH_EFFORT_TIERS）放大过，这里只补自动档（'' → 模型默认/高档）解析出
+    // 高档时的欠放大缺口——两侧共用一张表，配置本身就是高档时不再放大（防 ×16 双乘）
+    const baseMaxTokens = opts.maxTokens ?? cfg.llm.maxTokens;
+    const highTiers = HIGH_EFFORT_TIERS;
+    const maxTokens = highTiers.includes(effort.effort) && !highTiers.includes(cfg.llm.reasoningEffort)
+        ? layerMaxTokens(baseMaxTokens, 'high')
+        : baseMaxTokens;
     const stream = ctx.llm.stream({
         provider,
         model,
         system: opts.system,
         messages: [createUserMessage({ content: [{ type: 'text', text: user }], source: { kind: 'user' } })],
         temperature: opts.temperature ?? cfg.llm.temperature,
-        maxTokens: opts.maxTokens ?? cfg.llm.maxTokens,
-        // 默认 off：蒸馏是结构化抽取，high 思考可吃光全部输出预算致正文 0 字符；空串不传（非推理模型）
-        ...(cfg.llm.reasoningEffort
-            ? { reasoningEffort: ReasoningEffortId(cfg.llm.reasoningEffort) }
-            : {}),
+        maxTokens,
+        // 档位只在能力决策给出非空值时传；空串不传（跟随模型默认）
+        ...(effort.effort ? { reasoningEffort: ReasoningEffortId(effort.effort) } : {}),
         signal,
     });
     const startedAt = Date.now();

package/dist/pipeline/runner.js

@@ -25,6 +25,8 @@ export function pickNextTaskIndex(tasks) {
  */
 export function effectiveCfg(cfg, live) {
     const s = live?.get();
+    // 思考档位：设置服务在场时运行时值整体接管——'' = 自动（按模型能力解析），
+    // 不再回退静态配置（"跟随配置"选项已删）；静态值仅无 settings 服务的部署生效
     const eff = s?.reasoningEffort ?? '';
     // 可选链防御：smoke/测试缝构造的最小 cfg 可能没有 llm 字段
     const pinned = Boolean(cfg.llm?.provider && cfg.llm?.model);
@@ -41,13 +43,15 @@ export function effectiveCfg(cfg, live) {
         }
         : null;
     const maxInput = s && s.distillMaxInputChars > 0 ? s.distillMaxInputChars : null;
-    if (!eff && !override && !budgets && !maxInput)
+    // 无任何注入且（无 live，或运行时 '' 且静态本就 ''）→ 原引用返回，保持引用稳定性
+    const effNoop = eff === '' && (!live || !cfg.llm?.reasoningEffort);
+    if (!override && !budgets && !maxInput && effNoop)
         return cfg;
     return {
         ...cfg,
         llm: {
             ...cfg.llm,
-            ...(eff ? { reasoningEffort: eff } : {}),
+            ...(live ? { reasoningEffort: eff } : {}),
             ...(override ?? {}),
             ...(budgets ? { budgets } : {}),
             ...(maxInput ? { maxInputChars: maxInput } : {}),

package/dist/settings.d.ts

@@ -5,10 +5,11 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 import Schema from '@deepseek-ai/schemastery';
+import { EFFORT_CHOICES } from './config.js';
 import type { DistillBudgetLayer } from './llm.js';
 import type { MemoryLogger } from './types.js';
-/** 蒸馏思考档位可选项：'' = 跟随静态 config（部署默认）。 */
-export type EffortChoice = '' | 'off' | 'high' | 'max';
+/** 蒸馏思考档位：'' = 自动（模型默认档 → high）；词汇表单源于 config.ts 的 EFFORT_CHOICES。 */
+export type EffortChoice = (typeof EFFORT_CHOICES)[number];
 /** 分层输出预算（与 llm.ts 的 DistillBudgetLayer 同键；0 = 跟随内置默认）。 */
 export type DistillBudgets = Record<DistillBudgetLayer, number>;
 export interface MemoryLiveSettings {

package/dist/settings.js

@@ -1,5 +1,6 @@
 import Schema from '@deepseek-ai/schemastery';
 import { settingsNamespace } from '@deepseek-ai/dsh-settings';
+import { EFFORT_CHOICES } from './config.js';
 const NS = settingsNamespace('dsh-memory');
 const ALWAYS_ON = {
     enabled: true,
@@ -36,7 +37,7 @@ export function liveSettingsSchema() {
         capture: Schema.boolean().default(true),
         distill: Schema.boolean().default(true),
         recall: Schema.boolean().default(true),
-        reasoningEffort: Schema.union(['', 'off', 'high', 'max']).default(''),
+        reasoningEffort: Schema.union([...EFFORT_CHOICES]).default(''),
         distillProvider: Schema.string().default(''),
         distillModel: Schema.string().default(''),
         distillBudgets: Schema.object({
@@ -154,7 +155,6 @@ function resolveSettings(value) {
     if (!value || typeof value !== 'object')
         return { ...ALWAYS_ON };
     const v = value;
-    const efforts = ['', 'off', 'high', 'max'];
     const num = (x) => (typeof x === 'number' && Number.isFinite(x) && x >= 0 ? Math.floor(x) : 0);
     const rawBudgets = (v.distillBudgets ?? {});
     return {
@@ -162,7 +162,7 @@ function resolveSettings(value) {
         capture: v.capture !== false,
         distill: v.distill !== false,
         recall: v.recall !== false,
-        reasoningEffort: typeof v.reasoningEffort === 'string' && efforts.includes(v.reasoningEffort)
+        reasoningEffort: typeof v.reasoningEffort === 'string' && EFFORT_CHOICES.includes(v.reasoningEffort)
             ? v.reasoningEffort
             : '',
         distillProvider: typeof v.distillProvider === 'string' ? v.distillProvider : '',

package/dist/stats.js

@@ -9,9 +9,9 @@
 import { createRequire } from 'node:module';
 import { closeSync, openSync, readSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-import { resolveDataDir } from './config.js';
+import { EFFORT_CHOICES, resolveDataDir } from './config.js';
 import { effectiveCfg } from './pipeline/runner.js';
-import { LAYER_DEFAULT_BUDGETS, resolveModelRoute } from './llm.js';
+import { decideSendableEffort, LAYER_DEFAULT_BUDGETS, resolveModelEfforts, resolveModelRoute } from './llm.js';
 import { errDetail } from './util/filelog.js';
 const require = createRequire(import.meta.url);
 export const PLUGIN_VERSION = require('../package.json').version;
@@ -132,6 +132,15 @@ async function buildStats(cfg, stores, status) {
         thresholds: { l2MinNewMemories: cfg.l2.minNewMemories, l3Interval: cfg.l3.interval },
     };
 }
+/** RPC 字符串入参上限校验：防 loopback 面畸形超长载荷
+ *  （超长 sessionId 持久化进 session-modes.json / 超长 query 触发 jieba 全量分词 CPU 峰值）。 */
+function expectSessionId(v) {
+    if (typeof v !== 'string' || !v)
+        throw new Error('sessionId 缺失');
+    if (v.length > 512)
+        throw new Error('sessionId 过长（≤512 字符）');
+    return v;
+}
 async function handleEndpoint(endpoint, payload, deps) {
     const { cfg, stores, status, live, modes, dataDir, rebuild, embedManager } = deps;
     switch (endpoint) {
@@ -141,27 +150,44 @@ async function handleEndpoint(endpoint, payload, deps) {
             if (!modes)
                 throw new Error('档位存储未初始化');
             const p = (payload ?? {});
-            if (typeof p.sessionId !== 'string' || !p.sessionId)
-                throw new Error('sessionId 缺失');
-            return { sessionId: p.sessionId, mode: modes.get(p.sessionId), defaultMode: modes.default };
+            const sessionId = expectSessionId(p.sessionId);
+            return { sessionId, mode: modes.get(sessionId), defaultMode: modes.default };
         }
         case 'dsh-memory/session-mode-set': {
             if (!modes)
                 throw new Error('档位存储未初始化');
             const p = (payload ?? {});
-            if (typeof p.sessionId !== 'string' || !p.sessionId)
-                throw new Error('sessionId 缺失');
+            const sessionId = expectSessionId(p.sessionId);
             const allowed = ['auto', 'chat', 'work', 'off'];
             if (typeof p.mode !== 'string' || !allowed.includes(p.mode)) {
                 throw new Error(`非法档位: ${String(p.mode)}（允许 ${allowed.join('/')}）`);
             }
-            modes.set(p.sessionId, p.mode);
-            deps.logger.info(`[memory] 会话档位设置 session=${p.sessionId} mode=${p.mode}`);
-            return { sessionId: p.sessionId, mode: p.mode };
+            modes.set(sessionId, p.mode);
+            deps.logger.info(`[memory] 会话档位设置 session=${sessionId} mode=${p.mode}`);
+            return { sessionId, mode: p.mode };
         }
         case 'dsh-memory/settings-get': {
             const s = live?.get();
             const budgets = s?.distillBudgets ?? { extract: 0, dedup: 0, l2: 0, l3: 0 };
+            // 蒸馏思考档位：current 是运行时值（'' = 自动）；effective 是能力探询后实际发送值
+            // （'' = 不传，跟随模型默认）；options 是当前生效模型声明的档位表（空声明 → 只显示
+            // high，用户规则：无声明默认 high），供蒸馏思考选择器渲染；fallback 是静态部署值
+            let effortEffective = s?.reasoningEffort || cfg.llm.reasoningEffort;
+            let effortOptions = ['high'];
+            let effortRoute = null;
+            try {
+                const ecfg = effectiveCfg(cfg, live);
+                effortRoute = await resolveModelRoute(deps.ctx, ecfg);
+                const cap = await resolveModelEfforts(deps.ctx, effortRoute.provider, effortRoute.model);
+                if (cap) {
+                    effortEffective = decideSendableEffort(cap, ecfg.llm.reasoningEffort).effort;
+                    if (cap.efforts.length > 0)
+                        effortOptions = cap.efforts;
+                }
+            }
+            catch {
+                /* 路由解析/探询失败保持占位（effective 用运行时||静态值） */
+            }
             return {
                 supported: live?.supported ?? false,
                 settings: s ?? {
@@ -171,11 +197,12 @@ async function handleEndpoint(endpoint, payload, deps) {
                 },
                 // 静态部署上限（cordis.patch.yml）：运行时开关与它取 AND
                 ceilings: { capture: cfg.capture.enabled, distill: cfg.extract.enabled, recall: cfg.recall.enabled },
-                // 蒸馏思考档位：current 是运行时覆盖（'' = 跟随配置），effective 是实际生效值
                 effort: {
                     current: s?.reasoningEffort ?? '',
-                    effective: s?.reasoningEffort || cfg.llm.reasoningEffort,
+                    effective: effortEffective,
                     fallback: cfg.llm.reasoningEffort,
+                    options: effortOptions,
+                    ...(effortRoute ? { route: effortRoute } : {}),
                 },
                 // 分层输出预算：current 是运行时覆盖（0 = 跟随默认），defaults 是内置默认（UI 占位/提示用）
                 budgets: {
@@ -207,8 +234,10 @@ async function handleEndpoint(endpoint, payload, deps) {
             }
             if (patch.reasoningEffort !== undefined) {
                 const v = String(patch.reasoningEffort);
-                if (!['', 'off', 'high', 'max'].includes(v)) {
-                    throw new Error(`非法思考档位: ${v}（允许 ''/off/high/max）`);
+                // 白名单与 schema/settings 同源（config.ts EFFORT_CHOICES）——此前此处漏扩词表，
+                // 设置页新词汇（none/minimal/low/medium/xhigh）被拒并回滚
+                if (!EFFORT_CHOICES.includes(v)) {
+                    throw new Error(`非法思考档位: ${v}（允许 '' 或 ${EFFORT_CHOICES.filter((x) => x !== '').join('/')}）`);
                 }
                 clean.reasoningEffort = v;
             }
@@ -251,8 +280,10 @@ async function handleEndpoint(endpoint, payload, deps) {
         }
         case 'dsh-memory/list-records': {
             const p = (payload ?? {});
+            if (p.query !== undefined && p.query.length > 4096)
+                throw new Error('query 过长（≤4096 字符）');
             const limit = Math.min(Math.max(Number(p.limit) || 50, 1), 200);
-            const offset = Math.max(Number(p.offset) || 0, 0);
+            const offset = Math.min(Math.max(Number(p.offset) || 0, 0), 1_000_000);
             // 关键词路径：复用检索唯一缝（与召回同源），取回后做场景过滤 + 手工分页。
             // 检索侧单次上限 200：分页窗口触达上限时显式标记 truncated（结果可能不完整），
             // 不再静默返回空结果让用户误以为"没有更多"等于"不存在更多"。
@@ -371,6 +402,8 @@ async function handleEndpoint(endpoint, payload, deps) {
             const p = (payload ?? {});
             if (typeof p.provider !== 'string' || !p.provider)
                 throw new Error('provider 缺失');
+            if (p.provider.length > 200)
+                throw new Error('provider 过长（≤200 字符）');
             // 两个内置适配器（deepseek/pi-ai）的 listModels 都读本地快照不触网；
             // 仍加超时兜底，防第三方适配器实现为远端查询拖死 RPC 轮询
             const models = await Promise.race([
@@ -395,6 +428,9 @@ async function handleEndpoint(endpoint, payload, deps) {
             if (p.source !== 'remote' && p.source !== 'local' && p.source !== 'off') {
                 throw new Error('source 必须是 remote | local | off');
             }
+            if (typeof p.activeModel === 'string' && p.activeModel.length > 200) {
+                throw new Error('activeModel 过长（≤200 字符）');
+            }
             const r = embedManager.requestSource({ source: p.source, activeModel: p.activeModel ?? null });
             if (!r.accepted)
                 throw new Error(r.error ?? '切换请求被拒绝');

package/dist/store/download-queue.d.ts

@@ -101,4 +101,7 @@ export declare class ModelDownloadQueue {
  * 镜像直连往往间歇不可达（真实事故：直连超时与污染字节交替出现）。
  */
 export declare function resolveProxyUrl(setting: string | undefined, host: string): string;
+/** 代理 URL 日志脱敏：剥掉 userinfo（内网代理常带 user:pass 凭据），只留 scheme//host；
+ *  解析失败的串原样也可能是凭据形态，返回占位符。 */
+export declare function maskProxyUrl(proxy: string): string;
 export {};

package/dist/store/download-queue.js

@@ -40,8 +40,15 @@ export class ModelDownloadQueue {
         }
         const proxy = resolveProxyUrl(opts.proxy, host);
         if (proxy) {
-            this.agent = new ProxyAgent(proxy);
-            opts.logger?.info(`[memory] 模型下载走代理 ${proxy}（镜像直连在国内网络间歇不可达）`);
+            try {
+                this.agent = new ProxyAgent(proxy);
+                opts.logger?.info(`[memory] 模型下载走代理 ${maskProxyUrl(proxy)}（镜像直连在国内网络间歇不可达）`);
+            }
+            catch (err) {
+                // 与畸形 mirror 同款容错（见上）：畸形代理（无 scheme 等常见笔误）只降级直连，
+                // 绝不炸构造器——本构造发生在 apply 装配链上，抛错会拖垮宿主启动
+                opts.logger?.warn(`[memory] 代理配置无效，已忽略并直连（${maskProxyUrl(proxy)}）: ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
         this.defaultFetch = ((u, init) => {
             const dispatch = this.agent;
@@ -382,6 +389,8 @@ export function resolveProxyUrl(setting, host) {
     if (value)
         return value;
     const noProxy = process.env.NO_PROXY ?? process.env.no_proxy ?? '';
+    if (noProxy.trim() === '*')
+        return '';
     if (noProxy) {
         for (const raw of noProxy.split(',')) {
             const entry = raw.trim().replace(/^\./, '').toLowerCase();
@@ -400,6 +409,17 @@ export function resolveProxyUrl(setting, host) {
     }
     return '';
 }
+/** 代理 URL 日志脱敏：剥掉 userinfo（内网代理常带 user:pass 凭据），只留 scheme//host；
+ *  解析失败的串原样也可能是凭据形态，返回占位符。 */
+export function maskProxyUrl(proxy) {
+    try {
+        const u = new URL(proxy);
+        return `${u.protocol}//${u.host}`;
+    }
+    catch {
+        return '<invalid-url>';
+    }
+}
 async function sha256File(p) {
     const { createReadStream } = await import('node:fs');
     const hash = createHash('sha256');

package/dist/store/embedding-source.d.ts

@@ -36,7 +36,7 @@ export interface InitialEmbedding {
 export declare function remoteCeiling(cfg: MemoryConfig): boolean;
 export declare function resolveInitialEmbedding(cfg: MemoryConfig, sourceStore: EmbeddingSourceStore, downloader: ModelDownloadQueue, makeLocal: (modelId: string) => LocalEmbeddingService | null, logger?: MemoryLogger): Promise<InitialEmbedding>;
 /** 本地服务构造工厂（index.ts 的初始解析与 Manager 共用一份实现，防漂移）。 */
-export declare function makeLocalServiceFactory(installer: RuntimeInstaller, downloader: ModelDownloadQueue, logger?: MemoryLogger): (modelId: string) => LocalEmbeddingService | null;
+export declare function makeLocalServiceFactory(installer: RuntimeInstaller, downloader: ModelDownloadQueue, logger?: MemoryLogger, maxInputChars?: number): (modelId: string) => LocalEmbeddingService | null;
 export type ApplyPhase = 'idle' | 'installing-runtime' | 'warming' | 'switching' | 'reindexing' | 'done' | 'error';
 export interface ReindexProgressState {
     running: boolean;