dsh-layered-memory 0.8.2 → 0.8.3

package/dist/config.d.ts

@@ -198,7 +198,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 +206,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 +303,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 +311,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

@@ -61,9 +61,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(['', 'off', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']).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

@@ -46,6 +46,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

@@ -31,7 +31,7 @@ export function resolveLayerTokens(cfg, layer) {
  * 预算致正文 0 字符）——effort 为 high/max 时分层预算 ×4。
  */
 export function layerMaxTokens(base, reasoningEffort) {
-    return reasoningEffort === 'high' || reasoningEffort === 'max' ? base * 4 : base;
+    return reasoningEffort === 'high' || reasoningEffort === 'xhigh' || reasoningEffort === 'max' ? base * 4 : base;
 }
 /** 解析蒸馏用的 provider/model：配置优先，其次当前默认选择。 */
 export async function resolveModelRoute(ctx, cfg) {
@@ -46,6 +46,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 +125,29 @@ 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/max），
+    // 这里补自动档（'' → 模型默认/high）解析出高档时欠放大的缺口
+    const baseMaxTokens = opts.maxTokens ?? cfg.llm.maxTokens;
+    const maxTokens = ['high', 'xhigh', 'max'].includes(effort.effort) && !['high', 'max'].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

@@ -8,7 +8,8 @@ import Schema from '@deepseek-ai/schemastery';
 import type { DistillBudgetLayer } from './llm.js';
 import type { MemoryLogger } from './types.js';
 /** 蒸馏思考档位可选项：'' = 跟随静态 config（部署默认）。 */
-export type EffortChoice = '' | 'off' | 'high' | 'max';
+/** 蒸馏思考档位：'' = 自动（模型默认档 → high）；其余为各适配器通用档位词汇表。 */
+export type EffortChoice = '' | 'off' | 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
 /** 分层输出预算（与 llm.ts 的 DistillBudgetLayer 同键；0 = 跟随内置默认）。 */
 export type DistillBudgets = Record<DistillBudgetLayer, number>;
 export interface MemoryLiveSettings {

package/dist/settings.js

@@ -36,7 +36,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(['', 'off', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']).default(''),
         distillProvider: Schema.string().default(''),
         distillModel: Schema.string().default(''),
         distillBudgets: Schema.object({
@@ -154,7 +154,7 @@ function resolveSettings(value) {
     if (!value || typeof value !== 'object')
         return { ...ALWAYS_ON };
     const v = value;
-    const efforts = ['', 'off', 'high', 'max'];
+    const efforts = ['', 'off', 'none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
     const num = (x) => (typeof x === 'number' && Number.isFinite(x) && x >= 0 ? Math.floor(x) : 0);
     const rawBudgets = (v.distillBudgets ?? {});
     return {

package/dist/stats.js

@@ -11,7 +11,7 @@ import { closeSync, openSync, readSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { 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: {
@@ -251,8 +278,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 +400,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 +426,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;

package/dist/store/embedding-source.js

@@ -102,12 +102,12 @@ export async function resolveInitialEmbedding(cfg, sourceStore, downloader, make
     return { svc, dims: cfg.embedding.dimensions, providerInfo: svc.getProviderInfo() };
 }
 /** 本地服务构造工厂（index.ts 的初始解析与 Manager 共用一份实现，防漂移）。 */
-export function makeLocalServiceFactory(installer, downloader, logger) {
+export function makeLocalServiceFactory(installer, downloader, logger, maxInputChars) {
     return (modelId) => {
         const entry = catalogById(modelId);
         if (!entry)
             return null;
-        return new LocalEmbeddingService(entry, downloader.modelsDir(entry.id), () => Promise.resolve(installer.resolveModule()), logger);
+        return new LocalEmbeddingService(entry, downloader.modelsDir(entry.id), () => Promise.resolve(installer.resolveModule()), logger, maxInputChars);
     };
 }
 export class EmbeddingManager {
@@ -167,7 +167,7 @@ export class EmbeddingManager {
     }
     /** 构造绑定真实运行时 loader 的本地服务（deps.makeLocal 可注入，测试替换）。 */
     makeLocalService(modelId) {
-        const factory = this.deps.makeLocal ?? makeLocalServiceFactory(this.installer, this.downloader, this.deps.logger);
+        const factory = this.deps.makeLocal ?? makeLocalServiceFactory(this.installer, this.downloader, this.deps.logger, this.deps.cfg.embedding.maxInputChars);
         return factory(modelId);
     }
     /** 活切换请求：验证通过即接受，后台执行应用链（进度轮询可见）。 */

package/dist/store/io.d.ts

@@ -1,11 +1,19 @@
 export declare function ensureDir(dir: string): Promise<void>;
-/** 原子写文本文件。 */
+/**
+ * 原子写文本文件。tmp 写满后先 fsync 数据块再 rename——否则断电时文件系统可能
+ * 先持久化 rename 元数据、后持久化数据块（ext4 delayed allocation / NTFS 均可能），
+ * 目标文件变成空文件或半截。tmp 名带随机段防同毫秒碰撞；失败路径清理孤儿 tmp。
+ */
 export declare function atomicWriteText(file: string, content: string): Promise<void>;
 /** 原子写 JSON。 */
 export declare function atomicWriteJson(file: string, value: unknown): Promise<void>;
 export declare function readJsonIfExists<T>(file: string): Promise<T | undefined>;
 export declare function readTextIfExists(file: string): Promise<string | undefined>;
-/** 追加 JSONL 行（存在则追加，否则创建）。 */
+/**
+ * 追加 JSONL 行（存在则追加，否则创建）。走 OS 写回不加 fsync：追加是热路径
+ * （每轮对话一次），逐条 fsync 的延迟代价大于崩溃窗口丢尾部几行的损失——
+ * 事实源的完整性边界见 README「日志与故障排查」。
+ */
 export declare function appendJsonl(file: string, lines: unknown[]): Promise<void>;
 /** 读取 JSONL 全部行。 */
 export declare function readJsonl<T>(file: string): Promise<T[]>;

package/dist/store/io.js

@@ -1,17 +1,35 @@
 /**
- * 持久化工具：原子写（tmp + rename）、JSON 状态。
+ * 持久化工具：原子写（tmp + fsync + rename）、JSON 状态。
  */
+import { randomUUID } from 'node:crypto';
 import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
 export async function ensureDir(dir) {
     await fs.mkdir(dir, { recursive: true });
 }
-/** 原子写文本文件。 */
+/**
+ * 原子写文本文件。tmp 写满后先 fsync 数据块再 rename——否则断电时文件系统可能
+ * 先持久化 rename 元数据、后持久化数据块（ext4 delayed allocation / NTFS 均可能），
+ * 目标文件变成空文件或半截。tmp 名带随机段防同毫秒碰撞；失败路径清理孤儿 tmp。
+ */
 export async function atomicWriteText(file, content) {
     await ensureDir(path.dirname(file));
-    const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
-    await fs.writeFile(tmp, content, 'utf-8');
-    await fs.rename(tmp, file);
+    const tmp = `${file}.${process.pid}.${randomUUID().slice(0, 8)}.tmp`;
+    try {
+        await fs.writeFile(tmp, content, 'utf-8');
+        const fh = await fs.open(tmp, 'r+');
+        try {
+            await fh.sync();
+        }
+        finally {
+            await fh.close();
+        }
+        await fs.rename(tmp, file);
+    }
+    catch (err) {
+        await fs.unlink(tmp).catch(() => { });
+        throw err;
+    }
 }
 /** 原子写 JSON。 */
 export async function atomicWriteJson(file, value) {
@@ -34,7 +52,11 @@ export async function readTextIfExists(file) {
         return undefined;
     }
 }
-/** 追加 JSONL 行（存在则追加，否则创建）。 */
+/**
+ * 追加 JSONL 行（存在则追加，否则创建）。走 OS 写回不加 fsync：追加是热路径
+ * （每轮对话一次），逐条 fsync 的延迟代价大于崩溃窗口丢尾部几行的损失——
+ * 事实源的完整性边界见 README「日志与故障排查」。
+ */
 export async function appendJsonl(file, lines) {
     if (lines.length === 0)
         return;