dsh-layered-memory 0.8.0 → 0.8.2

package/dist/pipeline/runner.d.ts

@@ -36,10 +36,16 @@ export interface PipelineTask {
 /** 选取下一个要执行的任务下标：最早的 live 优先，否则队首（rebuild 分块让位）。 */
 export declare function pickNextTaskIndex(tasks: PipelineTask[]): number;
 /**
- * 运行时调参视图：UI 选择器可临时覆盖蒸馏思考档位（空串回退静态 config 默认）。
- * 浅拷贝只覆盖 llm 一层，其余键与原 cfg 共享只读引用；pipeline 全链继续收 cfg，无需感知。
+ * 运行时调参视图：UI 选择器可临时覆盖蒸馏思考档位、蒸馏模型路由与分层输出预算
+ * （空串/0 回退静态 config / 内置默认）。浅拷贝只覆盖 llm 一层，其余键与原 cfg
+ * 共享只读引用；pipeline 全链继续收 cfg，无需感知。
+ *
+ * 蒸馏模型覆盖优先级：部署静态 pin（cfg.llm.provider+model 双字段齐）不可被
+ * 运行时覆盖（部署可强制蒸馏走内网路由，防用户选择把对话外送）；未 pin 时
+ * 运行时选择（distillProvider+distillModel 成对）生效；再退 agentDefaultModel。
+ * 输出预算无部署上限语义：非零运行时值直接注入 cfg.llm.budgets（0/缺省不注入）。
  */
-export declare function effectiveCfg(cfg: MemoryConfig, live: LiveSettingsHandle): MemoryConfig;
+export declare function effectiveCfg(cfg: MemoryConfig, live?: LiveSettingsHandle): MemoryConfig;
 export declare class MemoryRunner {
     private readonly ctx;
     private readonly cfg;

package/dist/pipeline/runner.js

@@ -14,12 +14,45 @@ export function pickNextTaskIndex(tasks) {
     return 0;
 }
 /**
- * 运行时调参视图：UI 选择器可临时覆盖蒸馏思考档位（空串回退静态 config 默认）。
- * 浅拷贝只覆盖 llm 一层，其余键与原 cfg 共享只读引用；pipeline 全链继续收 cfg，无需感知。
+ * 运行时调参视图：UI 选择器可临时覆盖蒸馏思考档位、蒸馏模型路由与分层输出预算
+ * （空串/0 回退静态 config / 内置默认）。浅拷贝只覆盖 llm 一层，其余键与原 cfg
+ * 共享只读引用；pipeline 全链继续收 cfg，无需感知。
+ *
+ * 蒸馏模型覆盖优先级：部署静态 pin（cfg.llm.provider+model 双字段齐）不可被
+ * 运行时覆盖（部署可强制蒸馏走内网路由，防用户选择把对话外送）；未 pin 时
+ * 运行时选择（distillProvider+distillModel 成对）生效；再退 agentDefaultModel。
+ * 输出预算无部署上限语义：非零运行时值直接注入 cfg.llm.budgets（0/缺省不注入）。
  */
 export function effectiveCfg(cfg, live) {
-    const eff = live.get().reasoningEffort;
-    return eff ? { ...cfg, llm: { ...cfg.llm, reasoningEffort: eff } } : cfg;
+    const s = live?.get();
+    const eff = s?.reasoningEffort ?? '';
+    // 可选链防御：smoke/测试缝构造的最小 cfg 可能没有 llm 字段
+    const pinned = Boolean(cfg.llm?.provider && cfg.llm?.model);
+    const override = s && !pinned && s.distillProvider && s.distillModel
+        ? { provider: s.distillProvider, model: s.distillModel }
+        : null;
+    const b = s?.distillBudgets;
+    const budgets = b && (b.extract > 0 || b.dedup > 0 || b.l2 > 0 || b.l3 > 0)
+        ? {
+            ...(b.extract > 0 ? { extract: b.extract } : {}),
+            ...(b.dedup > 0 ? { dedup: b.dedup } : {}),
+            ...(b.l2 > 0 ? { l2: b.l2 } : {}),
+            ...(b.l3 > 0 ? { l3: b.l3 } : {}),
+        }
+        : null;
+    const maxInput = s && s.distillMaxInputChars > 0 ? s.distillMaxInputChars : null;
+    if (!eff && !override && !budgets && !maxInput)
+        return cfg;
+    return {
+        ...cfg,
+        llm: {
+            ...cfg.llm,
+            ...(eff ? { reasoningEffort: eff } : {}),
+            ...(override ?? {}),
+            ...(budgets ? { budgets } : {}),
+            ...(maxInput ? { maxInputChars: maxInput } : {}),
+        },
+    };
 }
 /** 单桶堆积上限（防无限堆积；重建分块不受限——历史会话需全量入桶蒸馏）。 */
 const PENDING_BUCKET_CAP = 200;

package/dist/settings.d.ts

@@ -5,9 +5,12 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 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';
+/** 分层输出预算（与 llm.ts 的 DistillBudgetLayer 同键；0 = 跟随内置默认）。 */
+export type DistillBudgets = Record<DistillBudgetLayer, number>;
 export interface MemoryLiveSettings {
     /** 总开关：关 = 捕获/蒸馏/召回注入全停（数据保留） */
     enabled: boolean;
@@ -19,6 +22,17 @@ export interface MemoryLiveSettings {
     recall: boolean;
     /** 蒸馏思考档位运行时覆盖：'' = 跟随静态 config（llm.reasoningEffort） */
     reasoningEffort: EffortChoice;
+    /** 蒸馏模型运行时覆盖（供应商 id，用户已配置的路由）：'' = 跟随静态 config/默认选择。
+     *  与 distillModel 成对生效（单字段不算）；部署静态 pin（provider+model 双字段）优先。 */
+    distillProvider: string;
+    /** 蒸馏模型运行时覆盖（模型 id）：'' = 跟随静态 config/默认选择。 */
+    distillModel: string;
+    /** 分层输出预算运行时覆盖（token）：extract/dedup/l2/l3 四层，0 = 跟随内置默认；
+     *  思考档 high/max 的 ×4 放大在覆盖值之上照常生效。 */
+    distillBudgets: DistillBudgets;
+    /** 输入预算运行时覆盖（字符，≈token）：单次蒸馏调用的输入上限，L1 按此分块、
+     *  超限截断；0 = 跟随静态配置 llm.maxInputChars。 */
+    distillMaxInputChars: number;
 }
 export interface LiveSettingsHandle {
     /** settings 服务是否可用（不可用时 UI 侧隐藏开关面板） */

package/dist/settings.js

@@ -1,7 +1,17 @@
 import Schema from '@deepseek-ai/schemastery';
 import { settingsNamespace } from '@deepseek-ai/dsh-settings';
 const NS = settingsNamespace('dsh-memory');
-const ALWAYS_ON = { enabled: true, capture: true, distill: true, recall: true, reasoningEffort: '' };
+const ALWAYS_ON = {
+    enabled: true,
+    capture: true,
+    distill: true,
+    recall: true,
+    reasoningEffort: '',
+    distillProvider: '',
+    distillModel: '',
+    distillBudgets: { extract: 0, dedup: 0, l2: 0, l3: 0 },
+    distillMaxInputChars: 0,
+};
 /**
  * 进程内 scope 复用（fiber 重启重挂）。
  * dsh-settings 的 register 把注册挂在其**服务自身 ctx** 的 effect 上
@@ -20,12 +30,22 @@ let cachedScope;
 let cachedUnwatch;
 let cachedSvc;
 export function liveSettingsSchema() {
+    const budget = () => Schema.number().min(0).max(1_000_000).default(0);
     return Schema.object({
         enabled: Schema.boolean().default(true),
         capture: Schema.boolean().default(true),
         distill: Schema.boolean().default(true),
         recall: Schema.boolean().default(true),
         reasoningEffort: Schema.union(['', 'off', 'high', 'max']).default(''),
+        distillProvider: Schema.string().default(''),
+        distillModel: Schema.string().default(''),
+        distillBudgets: Schema.object({
+            extract: budget(),
+            dedup: budget(),
+            l2: budget(),
+            l3: budget(),
+        }).default({ extract: 0, dedup: 0, l2: 0, l3: 0 }),
+        distillMaxInputChars: Schema.number().min(0).max(1_000_000).default(0),
     });
 }
 export function registerLiveSettings(ctx, logger) {
@@ -42,8 +62,16 @@ export function registerLiveSettings(ctx, logger) {
         cachedUnwatch = scope.watch((next) => {
             const prev = current;
             current = resolveSettings(next);
+            const b = current.distillBudgets;
+            const budgetNote = (b.extract || b.dedup || b.l2 || b.l3)
+                ? `，输出预算=抽取 ${b.extract || '默认'}/去重 ${b.dedup || '默认'}/L2 ${b.l2 || '默认'}/L3 ${b.l3 || '默认'}`
+                : '';
+            const inputNote = current.distillMaxInputChars > 0 ? `，输入预算=${current.distillMaxInputChars}` : '';
             logger.info(`[memory] 记忆模式开关更新：总=${current.enabled} 捕获=${current.capture} 蒸馏=${current.distill} 召回=${current.recall}` +
-                `，蒸馏思考=${current.reasoningEffort || '跟随配置'}（此前 总=${prev.enabled}）`);
+                `，蒸馏思考=${current.reasoningEffort || '跟随配置'}（此前 总=${prev.enabled}）` +
+                (current.distillProvider && current.distillModel
+                    ? `，蒸馏模型=${current.distillProvider}/${current.distillModel}`
+                    : '') + budgetNote + inputNote);
         });
         return {
             supported: true,
@@ -127,6 +155,8 @@ function resolveSettings(value) {
         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 {
         enabled: v.enabled !== false,
         capture: v.capture !== false,
@@ -135,5 +165,14 @@ function resolveSettings(value) {
         reasoningEffort: typeof v.reasoningEffort === 'string' && efforts.includes(v.reasoningEffort)
             ? v.reasoningEffort
             : '',
+        distillProvider: typeof v.distillProvider === 'string' ? v.distillProvider : '',
+        distillModel: typeof v.distillModel === 'string' ? v.distillModel : '',
+        distillBudgets: {
+            extract: num(rawBudgets.extract),
+            dedup: num(rawBudgets.dedup),
+            l2: num(rawBudgets.l2),
+            l3: num(rawBudgets.l3),
+        },
+        distillMaxInputChars: num(v.distillMaxInputChars),
     };
 }

package/dist/stats.js

@@ -10,6 +10,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 { effectiveCfg } from './pipeline/runner.js';
+import { LAYER_DEFAULT_BUDGETS, resolveModelRoute } from './llm.js';
+import { errDetail } from './util/filelog.js';
 const require = createRequire(import.meta.url);
 export const PLUGIN_VERSION = require('../package.json').version;
 /** 注册状态 RPC（web 侧 connection 服务可选，缺失时跳过，不影响插件主体）。 */
@@ -30,6 +33,7 @@ export function registerMemoryRpc(ctx, cfg, stores, logger, status, live, modes,
         const dispose = connection.rpc.handle('/rpc', async (endpoint, payload) => {
             try {
                 const value = await handleEndpoint(endpoint, payload, {
+                    ctx,
                     cfg,
                     stores,
                     status,
@@ -157,9 +161,14 @@ async function handleEndpoint(endpoint, payload, deps) {
         }
         case 'dsh-memory/settings-get': {
             const s = live?.get();
+            const budgets = s?.distillBudgets ?? { extract: 0, dedup: 0, l2: 0, l3: 0 };
             return {
                 supported: live?.supported ?? false,
-                settings: s ?? { enabled: true, capture: true, distill: true, recall: true, reasoningEffort: '' },
+                settings: s ?? {
+                    enabled: true, capture: true, distill: true, recall: true,
+                    reasoningEffort: '', distillProvider: '', distillModel: '',
+                    distillBudgets: { extract: 0, dedup: 0, l2: 0, l3: 0 }, distillMaxInputChars: 0,
+                },
                 // 静态部署上限（cordis.patch.yml）：运行时开关与它取 AND
                 ceilings: { capture: cfg.capture.enabled, distill: cfg.extract.enabled, recall: cfg.recall.enabled },
                 // 蒸馏思考档位：current 是运行时覆盖（'' = 跟随配置），effective 是实际生效值
@@ -168,6 +177,23 @@ async function handleEndpoint(endpoint, payload, deps) {
                     effective: s?.reasoningEffort || cfg.llm.reasoningEffort,
                     fallback: cfg.llm.reasoningEffort,
                 },
+                // 分层输出预算：current 是运行时覆盖（0 = 跟随默认），defaults 是内置默认（UI 占位/提示用）
+                budgets: {
+                    current: budgets,
+                    defaults: { ...LAYER_DEFAULT_BUDGETS },
+                    effective: {
+                        extract: budgets.extract > 0 ? budgets.extract : LAYER_DEFAULT_BUDGETS.extract,
+                        dedup: budgets.dedup > 0 ? budgets.dedup : LAYER_DEFAULT_BUDGETS.dedup,
+                        l2: budgets.l2 > 0 ? budgets.l2 : LAYER_DEFAULT_BUDGETS.l2,
+                        l3: budgets.l3 > 0 ? budgets.l3 : LAYER_DEFAULT_BUDGETS.l3,
+                    },
+                },
+                // 输入预算（字符）：current 是运行时覆盖（0 = 跟随配置），fallback 是静态配置值
+                inputBudget: {
+                    current: s?.distillMaxInputChars ?? 0,
+                    fallback: cfg.llm.maxInputChars,
+                    effective: s && s.distillMaxInputChars > 0 ? s.distillMaxInputChars : cfg.llm.maxInputChars,
+                },
             };
         }
         case 'dsh-memory/settings-set': {
@@ -186,6 +212,37 @@ async function handleEndpoint(endpoint, payload, deps) {
                 }
                 clean.reasoningEffort = v;
             }
+            // 蒸馏模型运行时覆盖：供应商/模型 id 原样接受（不在此校验存在性——
+            // 供应商可被用户随后删除，解析侧按存在性回退并提示）
+            for (const key of ['distillProvider', 'distillModel']) {
+                if (patch[key] !== undefined) {
+                    const v = String(patch[key]);
+                    if (v.length > 200)
+                        throw new Error(`${key} 过长（≤200 字符）`);
+                    clean[key] = v;
+                }
+            }
+            // 分层输出预算：四键一起校验，非负整数 ≤ 100 万；0 = 跟随内置默认
+            if (patch.distillBudgets !== undefined) {
+                const raw = (patch.distillBudgets ?? {});
+                const budgets = {};
+                for (const key of ['extract', 'dedup', 'l2', 'l3']) {
+                    const n = Number(raw[key] ?? 0);
+                    if (!Number.isInteger(n) || n < 0 || n > 1_000_000) {
+                        throw new Error(`distillBudgets.${key} 须为 0~1000000 的整数（0 = 跟随默认）`);
+                    }
+                    budgets[key] = n;
+                }
+                clean.distillBudgets = budgets;
+            }
+            // 输入预算（字符）：0 = 跟随静态配置；正值须落在静态 schema 同款范围（1000~100 万）
+            if (patch.distillMaxInputChars !== undefined) {
+                const n = Number(patch.distillMaxInputChars);
+                if (!Number.isInteger(n) || n < 0 || n > 1_000_000 || (n > 0 && n < 1000)) {
+                    throw new Error('distillMaxInputChars 须为 0 或 1000~1000000 的整数（0 = 跟随配置）');
+                }
+                clean.distillMaxInputChars = n;
+            }
             if (Object.keys(clean).length === 0)
                 throw new Error('开关更新载荷为空');
             await live.update(clean);
@@ -270,6 +327,61 @@ async function handleEndpoint(endpoint, payload, deps) {
                 throw new Error('重建控制器未初始化');
             return rebuild.requestCancel();
         }
+        // ── 蒸馏模型选择器（用户已配置的供应商路由） ──
+        case 'dsh-memory/llm-providers': {
+            // 供应商目录（已注册适配器的活动路由）+ 默认选择 + 当前覆盖与实际生效路由
+            let providers = [];
+            try {
+                providers = deps.ctx.llm.listProviders();
+            }
+            catch (err) {
+                deps.logger.warn(`[memory] 供应商列表读取失败: ${errDetail(err)}`);
+            }
+            let def = null;
+            try {
+                const sel = deps.ctx.get('agentDefaultModel')?.currentSelection?.();
+                if (sel?.provider && sel?.model)
+                    def = { provider: sel.provider, model: sel.model };
+            }
+            catch {
+                /* 可选服务缺失 = 无默认选择 */
+            }
+            const s = live?.get();
+            const current = { provider: s?.distillProvider ?? '', model: s?.distillModel ?? '' };
+            let effective = null;
+            try {
+                effective = await resolveModelRoute(deps.ctx, effectiveCfg(cfg, live));
+            }
+            catch {
+                effective = null; // 无法解析（无默认选择且未覆盖）时 UI 显示占位
+            }
+            return {
+                supported: true,
+                providers,
+                default: def,
+                // 部署静态 pin（provider+model 双字段）优先于运行时选择，UI 据此禁用选择器
+                pinned: Boolean(cfg.llm.provider && cfg.llm.model),
+                current,
+                // 所选供应商是否仍在已注册路由中（用户删掉供应商后提示回退）
+                currentRegistered: current.provider === '' || providers.some((p) => p.id === current.provider),
+                effective,
+            };
+        }
+        case 'dsh-memory/llm-models': {
+            const p = (payload ?? {});
+            if (typeof p.provider !== 'string' || !p.provider)
+                throw new Error('provider 缺失');
+            // 两个内置适配器（deepseek/pi-ai）的 listModels 都读本地快照不触网；
+            // 仍加超时兜底，防第三方适配器实现为远端查询拖死 RPC 轮询
+            const models = await Promise.race([
+                deps.ctx.llm.listModels(p.provider),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('模型列表查询超时')), 8000)),
+            ]);
+            return {
+                provider: p.provider,
+                models: models.map((m) => ({ id: m.id, name: m.name, description: m.description ?? null })),
+            };
+        }
         // ── 嵌入源（远程/本地/关闭 三态）与模型管理 ──
         case 'dsh-memory/embedding-state-get': {
             if (!embedManager)

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

@@ -31,10 +31,18 @@ export interface DownloaderOptions {
     /** 下载镜像根（默认 https://hf-mirror.com，可配回 https://huggingface.co）。 */
     mirror: string;
     logger?: MemoryLogger;
-    /** 测试注入；默认全局 fetch。 */
+    /** 测试注入；默认 undici fetch（按需挂代理 dispatcher）。 */
     fetchImpl?: FetchLike;
     /** 测试注入磁盘剩余字节；默认 statfs。 */
     freeBytes?: () => Promise<number | null>;
+    /** 单文件失败的自动重试间隔（毫秒），长度即重试次数；默认 [1000, 3000]。
+     *  sha256 失配重试从零开始（污染断点已删除）；数量不吻合/网络错误保留断点续传。 */
+    retryDelaysMs?: number[];
+    /** 显式代理三态：''（默认）= 探测代理环境变量；'none' = 禁用强制直连；
+     *  其他值 = 代理 URL（如 http://127.0.0.1:7890）。镜像直连在国内网络
+     *  间歇不可达（真实事故：直连超时与污染字节交替），与 curl/npm 同语义地
+     *  走用户已配置的代理是可达性的底线。 */
+    proxy?: string;
 }
 export declare class ModelDownloadQueue {
     private readonly dataDir;
@@ -42,7 +50,15 @@ export declare class ModelDownloadQueue {
     private progress;
     private busy;
     private abort;
+    /** 代理 dispatcher（按需创建；dispose 关闭连接池）。 */
+    private agent;
+    /** 默认 fetch：undici（可挂代理 dispatcher）；测试注入优先。 */
+    private readonly defaultFetch;
     constructor(dataDir: string, opts: DownloaderOptions);
+    /** 镜像根（无尾斜杠）。 */
+    private mirrorUrl;
+    /** 释放代理连接池（插件 dispose 链调用；无代理时幂等无操作）。 */
+    dispose(): void;
     /** 当前进度快照（无任务时 null）。 */
     getProgress(): DownloadProgress | null;
     /** 是否有任务在跑（含校验阶段）。 */
@@ -64,8 +80,25 @@ export declare class ModelDownloadQueue {
     /** 取消当前任务：中断 fetch，保留 .part 断点。 */
     cancel(): boolean;
     private run;
-    /** 下载单文件到最终路径（含续传与校验），返回该文件贡献的字节数。 */
+    /** 下载单文件到最终路径（含续传与校验），返回该文件贡献的字节数。
+     *  单文件失败自动重试（默认 2 次）+ **重试换缓存键**：镜像链路
+     *  （Caddy×3 → CloudFront → Cloudflare）存在缓存对象污染窗口——同一时间窗内
+     *  同一 URL 确定性拿到错误字节（2026-08-19 embeddinggemma generation_config.json
+     *  连续错哈希的真实事故），普通重试会全打同一污染缓存；每次重试追加
+     *  `?dshmem-retry=N` 参数绕开缓存键另取对象，窗口期也能自愈。
+     *  - sha256 失配：downloadFileOnce 已删除断点 → 从零重下；
+     *  - 数量不吻合/网络错误：断点保留 → Range 续传重试；
+     *  - 取消：立即上抛不重试。 */
     private downloadFile;
+    /** 单次尝试：续传探测 → fetch（attempt>0 追加缓存键参数）→ 落盘 → 尺寸与 sha256 校验 → rename。 */
+    private downloadFileOnce;
     private freeBytes;
 }
+/**
+ * 解析下载代理（三态）：`''`（默认）= 探测代理环境变量（HTTPS_PROXY > ALL_PROXY >
+ * HTTP_PROXY，大小写双形态，尊重 NO_PROXY）；`'none'` = 禁用代理强制直连；
+ * 其他值 = 显式代理 URL。与 curl/npm 同语义——用户配置了代理 env 的机器上
+ * 镜像直连往往间歇不可达（真实事故：直连超时与污染字节交替出现）。
+ */
+export declare function resolveProxyUrl(setting: string | undefined, host: string): string;
 export {};

package/dist/store/download-queue.js

@@ -6,13 +6,15 @@
  * - 断点续传：写 .part 旁车文件，重试从断点 Range 续传；服务器不支持 Range（回 200）
  *   则从头重写；取消保留断点；
  * - 完整性：每文件下满后流式哈希整文件比对目录 sha256（续传无法增量哈希，落盘后
- *   单遍校验最简单且正确）；失配删文件整体重下；
+ *   单遍校验最简单且正确）；失配删文件整体重下；单文件失败自动重试（默认 2 次，
+ *   吸收镜像瞬态污染——sha 失配从零重下、网络类错误保留断点续传）；
  * - 磁盘门禁：下载前检查数据目录所在卷剩余空间 ≥ 模型体积 × 1.2（statfs 不可用时跳过）；
  * - 同一时刻只跑一个下载任务（串行队列），后续请求直接拒绝并说明。
  */
 import { createHash } from 'node:crypto';
 import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
+import { fetch as undiciFetch, ProxyAgent } from 'undici';
 import { catalogById, catalogTotalBytes, MODEL_CATALOG } from './model-catalog.js';
 const DISK_HEADROOM = 1.2;
 export class ModelDownloadQueue {
@@ -21,9 +23,40 @@ export class ModelDownloadQueue {
     progress = null;
     busy = false;
     abort = null;
+    /** 代理 dispatcher（按需创建；dispose 关闭连接池）。 */
+    agent;
+    /** 默认 fetch：undici（可挂代理 dispatcher）；测试注入优先。 */
+    defaultFetch;
     constructor(dataDir, opts) {
         this.dataDir = dataDir;
         this.opts = opts;
+        // 畸形 mirror（无 scheme 等）只跳过代理解析，不炸构造器（下载本身还会报清晰的 URL 错）
+        let host = '';
+        try {
+            host = new URL(this.mirrorUrl()).host;
+        }
+        catch {
+            /* ignore */
+        }
+        const proxy = resolveProxyUrl(opts.proxy, host);
+        if (proxy) {
+            this.agent = new ProxyAgent(proxy);
+            opts.logger?.info(`[memory] 模型下载走代理 ${proxy}（镜像直连在国内网络间歇不可达）`);
+        }
+        this.defaultFetch = ((u, init) => {
+            const dispatch = this.agent;
+            // undici fetch 的 init 接受 dispatcher；RequestInit 类型无此字段，断言透传
+            return undiciFetch(u, { ...init, ...(dispatch ? { dispatcher: dispatch } : {}) });
+        });
+    }
+    /** 镜像根（无尾斜杠）。 */
+    mirrorUrl() {
+        return this.opts.mirror.replace(/\/+$/, '');
+    }
+    /** 释放代理连接池（插件 dispose 链调用；无代理时幂等无操作）。 */
+    dispose() {
+        void this.agent?.close().catch(() => { });
+        this.agent = undefined;
     }
     /** 当前进度快照（无任务时 null）。 */
     getProgress() {
@@ -187,13 +220,46 @@ export class ModelDownloadQueue {
             prog.overallReceived = overall;
         }
     }
-    /** 下载单文件到最终路径（含续传与校验），返回该文件贡献的字节数。 */
+    /** 下载单文件到最终路径（含续传与校验），返回该文件贡献的字节数。
+     *  单文件失败自动重试（默认 2 次）+ **重试换缓存键**：镜像链路
+     *  （Caddy×3 → CloudFront → Cloudflare）存在缓存对象污染窗口——同一时间窗内
+     *  同一 URL 确定性拿到错误字节（2026-08-19 embeddinggemma generation_config.json
+     *  连续错哈希的真实事故），普通重试会全打同一污染缓存；每次重试追加
+     *  `?dshmem-retry=N` 参数绕开缓存键另取对象，窗口期也能自愈。
+     *  - sha256 失配：downloadFileOnce 已删除断点 → 从零重下；
+     *  - 数量不吻合/网络错误：断点保留 → Range 续传重试；
+     *  - 取消：立即上抛不重试。 */
     async downloadFile(entry, f, dir, onBytes) {
+        const delays = this.opts.retryDelaysMs ?? [1000, 3000];
+        let lastErr;
+        for (let attempt = 0;; attempt++) {
+            if (this.progress?.phase === 'cancelled')
+                throw new Error('已取消');
+            try {
+                return await this.downloadFileOnce(entry, f, dir, attempt, onBytes);
+            }
+            catch (err) {
+                lastErr = err;
+                // as 断言绕开 CFA 窄化——await 期间 cancel() 可能已改写 phase（同 downloadFileOnce 末段）
+                if (this.progress?.phase === 'cancelled')
+                    throw err;
+                if (attempt >= delays.length)
+                    throw err;
+                const msg = err instanceof Error ? err.message : String(err);
+                this.opts.logger?.warn(`[memory] 文件 ${f.path} 第 ${attempt + 1} 次尝试失败（${msg}），${delays[attempt]}ms 后自动重试（换缓存键）`);
+                await new Promise((r) => setTimeout(r, delays[attempt]));
+            }
+        }
+    }
+    /** 单次尝试：续传探测 → fetch（attempt>0 追加缓存键参数）→ 落盘 → 尺寸与 sha256 校验 → rename。 */
+    async downloadFileOnce(entry, f, dir, attempt, onBytes) {
         const finalPath = path.join(dir, f.path);
         const partPath = finalPath + '.part';
-        const base = this.opts.mirror.replace(/\/+$/, '');
-        const url = `${base}/${entry.repo}/resolve/${entry.revision}/${f.path}`;
-        const fetchImpl = this.opts.fetchImpl ?? ((u, init) => fetch(u, init));
+        const base = this.mirrorUrl();
+        // 重试追加缓存键参数：绕开镜像 CDN 的污染缓存对象（同窗口普通重试全打同一对象）
+        const cacheBust = attempt > 0 ? `?dshmem-retry=${attempt}` : '';
+        const url = `${base}/${entry.repo}/resolve/${entry.revision}/${f.path}${cacheBust}`;
+        const fetchImpl = this.opts.fetchImpl ?? this.defaultFetch;
         const prog = this.progress;
         let resumeFrom = 0;
         const partSize = await fileSize(partPath);
@@ -303,6 +369,37 @@ async function fileSize(p) {
         return null;
     }
 }
+/**
+ * 解析下载代理（三态）：`''`（默认）= 探测代理环境变量（HTTPS_PROXY > ALL_PROXY >
+ * HTTP_PROXY，大小写双形态，尊重 NO_PROXY）；`'none'` = 禁用代理强制直连；
+ * 其他值 = 显式代理 URL。与 curl/npm 同语义——用户配置了代理 env 的机器上
+ * 镜像直连往往间歇不可达（真实事故：直连超时与污染字节交替出现）。
+ */
+export function resolveProxyUrl(setting, host) {
+    const value = (setting ?? '').trim();
+    if (value.toLowerCase() === 'none')
+        return '';
+    if (value)
+        return value;
+    const noProxy = process.env.NO_PROXY ?? process.env.no_proxy ?? '';
+    if (noProxy) {
+        for (const raw of noProxy.split(',')) {
+            const entry = raw.trim().replace(/^\./, '').toLowerCase();
+            if (entry && (host.toLowerCase() === entry || host.toLowerCase().endsWith(`.${entry}`)))
+                return '';
+        }
+    }
+    const candidates = [
+        process.env.HTTPS_PROXY, process.env.https_proxy,
+        process.env.ALL_PROXY, process.env.all_proxy,
+        process.env.HTTP_PROXY, process.env.http_proxy,
+    ];
+    for (const c of candidates) {
+        if (c && c.trim())
+            return c.trim();
+    }
+    return '';
+}
 async function sha256File(p) {
     const { createReadStream } = await import('node:fs');
     const hash = createHash('sha256');

package/dist/store/model-catalog.js

@@ -43,7 +43,7 @@ export const MODEL_CATALOG = [
             { path: 'added_tokens.json', size: 35, sha256: '50b2f405ba56a26d4913fd772089992252d7f942123cc0a034d96424221ba946' },
             { path: 'special_tokens_map.json', size: 662, sha256: '2f7b0adf4fb469770bb1490e3e35df87b1dc578246c5e7e6fc76ecf33213a397' },
             { path: 'tokenizer_config.json', size: 1156830, sha256: '3ca953eea6c3c9fcda9cf3df22949ff18b216f7c74bd6459230f3f1013953f3a' },
-            { path: 'generation_config.json', size: 133, sha256: '1fb1efd221c1ca88a736b1b36cb47d754c177677e222acb3b1e5424c5d664870' },
+            { path: 'generation_config.json', size: 133, sha256: '1fb1efd221c1ca88a736d1b36cb47d754c177677e222acb3b1e5424c5d664870' },
             { path: 'tokenizer.json', size: 20323312, sha256: '4dda02faaf32bc91031dc8c88457ac272b00c1016cc679757d1c441b248b9c47' },
             { path: 'onnx/model_quantized.onnx', size: 567874, sha256: '172efde319fe1542dc41f31be6154910b05b78f7a861c265c4600eec906bd6d8' },
             { path: 'onnx/model_quantized.onnx_data', size: 308890624, sha256: '705626e28e4c23c82ade34566b4197d97f534c12275fa406dfb71e9937d388c0' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-layered-memory",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "L0~L3 分层蒸馏记忆插件 for DeepSeek Harness：自动捕获对话（L0）、抽取原子记忆（L1）、整合场景块（L2）、蒸馏核心画像/团队方法论（L3），并在模型步骤前自动召回注入。移植自 MemoryCore (TencentDB Agent Memory) 的管线设计。",
   "type": "module",
   "main": "dist/index.js",
@@ -32,7 +32,8 @@
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json && node scripts/copy-client.mjs",
-    "smoke": "node dist-smoke/smoke.js"
+    "smoke": "node dist-smoke/smoke.js",
+    "verify-catalog": "npm run build && node scripts/verify-catalog.mjs"
   },
   "engines": {
     "node": ">=22.16.0"
@@ -52,7 +53,8 @@
   "dependencies": {
     "@deepseek-ai/schemastery": "3.18.1",
     "@node-rs/jieba": "^2.0.2",
-    "sqlite-vec": "^0.1.7-alpha.2"
+    "sqlite-vec": "^0.1.7-alpha.2",
+    "undici": "^7.29.0"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
@@ -66,15 +68,15 @@
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "4.0.1",
-    "@deepseek-ai/dsh-agent": "0.1.0-rc.6",
-    "@deepseek-ai/dsh-agent-default-model": "0.1.0-rc.6",
-    "@deepseek-ai/dsh-client-connection": "0.1.0-rc.6",
-    "@deepseek-ai/dsh-home-paths": "0.1.0-rc.6",
-    "@deepseek-ai/dsh-llm": "0.1.0-rc.6",
-    "@deepseek-ai/dsh-session": "0.1.0-rc.6",
-    "@deepseek-ai/dsh-settings": "0.1.0-rc.6",
-    "@deepseek-ai/dsh-system-prompt": "0.1.0-rc.6",
-    "@deepseek-ai/dsh-tools": "0.1.0-rc.6",
+    "@deepseek-ai/dsh-agent": "0.1.0-rc.8",
+    "@deepseek-ai/dsh-agent-default-model": "0.1.0-rc.8",
+    "@deepseek-ai/dsh-client-connection": "0.1.0-rc.8",
+    "@deepseek-ai/dsh-home-paths": "0.1.0-rc.8",
+    "@deepseek-ai/dsh-llm": "0.1.0-rc.8",
+    "@deepseek-ai/dsh-session": "0.1.0-rc.8",
+    "@deepseek-ai/dsh-settings": "0.1.0-rc.8",
+    "@deepseek-ai/dsh-system-prompt": "0.1.0-rc.8",
+    "@deepseek-ai/dsh-tools": "0.1.0-rc.8",
     "@types/node": "^22.0.0",
     "typescript": "^5.6.0"
   }