dsh-prime-memory 0.26.12 → 0.26.14

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # 更新日志（Changelog）
 
+## [0.26.14] — 2026-10-28
+
+> 修复 issue #15：「技能结晶」自上线以来**根本没有生产者**——`detectCandidates` 与 `SkillStore.create()` 在全仓**只有测试调用点**，所以 `skills.json` 永远不会被生成，看板恒为 0。用户打开 `skillsEnabled` 开关后拿到的是一个空盒子，而且不报错、不提示，只能翻源码才知道功能没接上。
+
+### 修复
+
+- **接入生产者（新增 `src/skills/producer.ts`）**，两条路径共用一套分组语义：
+  - **稳态增量**：挂在 `runner.runTurn` 的 L2 攒批块之后，吃本轮新出的 `work_method` 记录 + 本轮 `sessionId`。0 全表扫描、0 LLM、0 token，不新增 timer。
+  - **一次性回灌**（`backfill`）：分页 `allLite` 扫存量→`getByIds` 取正文→从 `metadata.dsh_source_anchors` 复原会话归属，让老库不必再跨 N 个会话才见第一条技能。**缺锚点的记录直接跳过并计数，绝不伪造会话**（那会虚增 distinct-session 骗过晋升门）。
+  - 两条路径共用 `crystallize.ts` 导出的 `groupKey`/`fnv1a`（新增单测直接断言两路算出的候选 id 逐字相同）——否则同一组会结晶出两个候选，幂等崩。
+- **`sessionCount` 只数 `evidence` 行**（不看 `evidenceRecordIds`）——所以上线版只 `create()` 不投证据的话，即使 `allowPromote` 打开也永不晋升。生产者逐记录 `appendEvidence`，去重键是 **(skill, session, record) 三元组**而非二元组：一条历史记录可映射到多个会话，按二元组去重会抹掉第 2、3 个会话。
+- **失败隔离**：技能写库异常全部内化为 `summary.errors` + `logger.warn`，**不得抛穿蒸馏轮次**；`MemoryStores.skills` 为可选字段，未装配时整条路径跳过（既有 186 个测试文件的 store 桩都不带该字段，全绿即零回归证据）。
+- **诚实化（issue 建议 2/3）**：
+  - 面板空态拆三态（旧宿主无 `producer` 字段 / 池里没原料 / 有原料但未达阈），不再用一句「暂无技能」糊过去；未启用文案去掉「重复工作流会固化为技能候选」这句当时做不到的承诺。
+  - `skillsEnabled=true` 但 `skills.json` 从未生成时，启动日志留一条可 grep 的 warning。
+  - 新增 `dsh-memory/skills-detect` RPC（需「高权限模式」，与 `skills-action` 同门）与面板「立即检测历史」按钮；`skills-list` 附 `producer` 健康态。
+- **`minEvidence` 首次真实生效**：此前三处（store / RPC / 检测）都没消费它。现在自动晋升需 distinct-session ≥ `minSessions` **且** 证据条数 ≥ `minEvidence`；人工晋升仍只卡会话数（人审是人的判断）。
+- **不变量保留**：`body`（人编辑区）不被机器侧覆盖，二次检测只重写 `steps`；技能仍不是 memory `type`（不碰 `ADD_TYPES` 与蒸馏 prompt 词表）；不给 `l1_records` 加列。
+- **默认行为不变**：`skills.enabled` 与 `allowPromote` **仍默认关**。本版只保证「开了开关就有生产者」；候选需人工审阅晋升（自动晋升需显式开启）。
+- **已知局限（另立轨 3 issue）**：分组键是精确 `(hall, scene_name)` + 字面去重，语义等价但措辞不同的方法会散到不同组（假阴性）。要修得靠 LLM 判同/命名，会破坏轨 2 的可解释性与 `skx-` 幂等 id 保证，因此独立演进。
+- 测试：新增 `tests/skill-producer.test.ts` 15 例（磁盘真落盘 + 证据非空、幂等、双阈两档、body 不被覆盖、backfill 分页/缺锚点/与增量不重复、失败隔离）；全量 **1858 例**/186 文件绿，三配置 typecheck 与 lint 零新增错。
+
+## [0.26.13] — 2026-10-28
+
+> 修复 issue #19：单条 L1 priority 越界（如 LLM 回 `-1`）经无夹取写点落库后，`memoryRecall` 投影的 `viewSchema` 严格校验（判非负整数）抛错 → 宿主把整会话包成 `SESSION_QUERY_CORRUPT_SESSION` → **一条脏数据打死整个会话历史**。
+
+### 修复
+
+- **双防线**：
+  - **写侧夹取（防新增）**：新建 `src/util/priority.ts` 单源 `clampPriority`（非有限→回落缺省、小数 `Math.round`、夹到整数 `[0,100]`），L1 抽取/合并构造（`pipeline/l1.ts` 两处）、upsert 绑定层（`store/sqlite.ts`，保留历史缺省 50）、MD 导入解析（`store/memory-md-parse.ts`）统一走同一夹取。
+  - **读侧兜底（自愈存量）**：投影 `makeView` 遇脏 priority 就地夹取并 `warn`（带 record id + 原值），绝不让单条脏字段打死整会话。因升级必重启宿主、`viewMemo`（进程内 WeakMap）随之清空，脏行读时被夹取 → **存量脏数据无需手动改库、无需迁移**。
+- 保留 `viewSchema` 严格校验（纵深防御仍在，只是喂进去的已是干净值）；合法 0–100 整数读写逐字不变；`slots.ts` 的同名私有 `clampPriority`（floor/50，memorySlots 另一条链）不受影响。
+- 本版叠加在 0.26.12（DSH 0.2.1-rc.4 适配）之上，`latest` 与 `dsh-0.2.1-rc.4` dist-tag 同指本版。
+
 ## [0.26.12] — 2026-10-28
 
 > 0.26.12: host enumeration addendum for DSH 0.2.1-rc.4 (declaration-only bump; contract plane zero diff). `engines.dsh`/`dsh.plugin.json`/README 同串补 `0.2.1-rc.4` 枚举行（19 档）。

package/dist/client.js

@@ -37020,10 +37020,19 @@ var __create = Object.create;
 		  return r && r.error && r.error.message ? r.error.message : "RPC 错误";
 		}
 		var TITLES = { candidate: "候选", active: "活跃", archived: "已归档" };
+		function emptyHint(data) {
+		  const p = data.producer;
+		  if (!p) return '暂无技能。技能从重复出现的"工作方法"记忆结晶而来。';
+		  if (p.workMethodCount === 0) {
+		    return "暂无技能：记忆池里还没有「工作方法」类记录。技能是从重复出现的工作方法结晶来的，请先到概览页确认蒸馏在正常产出记忆。";
+		  }
+		  return `暂无技能：池中已有 ${p.workMethodCount} 条「工作方法」，但还没重复到成候选的程度（需跨 ≥${p.minSessions} 个不同会话）。存量可点「立即检测历史」回灌。`;
+		}
 		function SkillsTab(props) {
 		  const rpc = props.rpc;
 		  const [data, setData] = (0, import_react4.useState)(null);
 		  const [error, setError] = (0, import_react4.useState)(null);
+		  const [notice, setNotice] = (0, import_react4.useState)(null);
 		  const [busy, setBusy] = (0, import_react4.useState)(false);
 		  const load = (0, import_react4.useCallback)(() => {
 		    rpc("dsh-memory/skills-list", {}).then((r) => {
@@ -37046,24 +37055,43 @@ var __create = Object.create;
 		      } else setError(errMsg2(r));
 		    }).catch((e) => setError(String(e?.message || e))).finally(() => setBusy(false));
 		  };
+		  const detect = () => {
+		    if (busy) return;
+		    setBusy(true);
+		    setNotice(null);
+		    rpc("dsh-memory/skills-detect", {}).then((r) => {
+		      if (r && r.ok) {
+		        setError(r.value.error ? `部分失败：${r.value.error}` : null);
+		        setNotice(r.value.notice || null);
+		        load();
+		      } else setError(errMsg2(r));
+		    }).catch((e) => setError(String(e?.message || e))).finally(() => setBusy(false));
+		  };
 		  if (data && !data.enabled) {
-		    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { style: S.intro, children: "技能结晶（程序性记忆）未启用。到「概览」页开启「技能」开关（或部署配置 skills.enabled），重复工作流会固化为技能候选，在此审阅晋升。" });
+		    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { style: S.intro, children: "技能结晶（程序性记忆）未启用。到「概览」页开启「技能」开关（或部署配置 skills.enabled）：开启后，跨会话重复出现的「工作方法」记忆会累积为技能候选，在此审阅并手动晋升。" });
 		  }
-		  const mutateHint = data && !data.memoryMutate ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { style: S.hint, children: "提示：晋升/归档/固定需在面板开启「高权限模式」。" }) : null;
+		  const mutateHint = data && !data.memoryMutate ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { style: S.hint, children: "提示：晋升/归档/固定/检测历史需在面板开启「高权限模式」。" }) : null;
+		  const promotable = data && data.producer ? data.skills.filter((s) => s.status === "candidate" && s.sessionCount >= data.producer.minSessions).length : 0;
 		  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { children: [
 		    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { style: { ...S.flexRow, marginBottom: 10 }, children: [
 		      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: S.muted, children: data ? `${data.skills.length} 个技能 · 自动晋升${data.allowPromote ? "开" : "关(人工审阅)"} · 需证据会话达阈` : "加载中…" }),
 		      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { style: S.grow }),
-		      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(NButton, { onClick: load, children: "刷新" })
+		      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(NButton, { onClick: detect, disabled: busy || !data?.memoryMutate, children: "立即检测历史" }),
+		      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(NButton, { onClick: load, style: { marginLeft: 6 }, children: "刷新" })
 		    ] }),
 		    mutateHint,
+		    notice ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { style: S.hint, children: notice }) : null,
 		    error ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { style: S.error, children: error }) : null,
-		    data && data.skills.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { style: S.intro, children: '暂无技能。技能从重复出现的"工作方法"记忆结晶而来。' }) : null,
+		    data && promotable > 0 && !data.allowPromote ? /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { style: S.hint, children: [
+		      promotable,
+		      " 个候选的证据会话数已达阈，但自动晋升关闭——确认无误后可手动「晋升」。"
+		    ] }) : null,
+		    data && data.skills.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { style: S.intro, children: emptyHint(data) }) : null,
 		    (data?.skills || []).map((s) => /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "dsh-mem-card", style: S.card, children: [
 		      /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { style: S.cardHead, children: [
 		        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("strong", { children: s.title }),
 		        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "dsh-mem-tag", style: { marginLeft: 6 }, children: TITLES[s.status] }),
-		        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: S.muted, children: ` · 档:${s.tier}${s.pinned ? " · 已固定" : ""} · 覆盖 ${s.sessionCount} 会话` }),
+		        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: S.muted, children: ` · 档:${s.tier}${s.pinned ? " · 已固定" : ""} · 覆盖 ${s.sessionCount} 会话 / 证据 ${s.evidenceCount} 条` }),
 		        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { style: S.grow })
 		      ] }),
 		      /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { style: { display: "flex", gap: 6, flexWrap: "wrap", marginTop: 6 }, children: [

package/dist/contract.d.ts

@@ -1741,14 +1741,59 @@ export interface SkillView {
     tier: 'full' | 'excerpt' | 'hint';
     pinned: boolean;
     sessionCount: number;
+    /** 证据总条数（与 `sessionCount` 的 distinct 语义不同；面板用它算 minEvidence 进度）。 */
+    evidenceCount: number;
     updatedAt: string;
 }
+/**
+ * 生产者健康态（0.26.14+）——面板区分“空盒子”与“已接线但未达阈”的唯一依据。
+ *
+ * 旧版宿主不返此字段，面板按 `producer === undefined` 回到旧文案（不谎报已接线）。
+ */
+export interface SkillProducerView {
+    /** 本版起恒 true；字段保留是为了让面板能识别旧版（无生产者）现场。 */
+    wired: boolean;
+    /** 记忆池里的 work_method 记录数（为 0 = 蒸馏还没产出可结晶的原料）。 */
+    workMethodCount: number;
+    /** 已结晶的候选数（含 active/archived 之外的 candidate）。 */
+    candidateCount: number;
+    /** 晋升需 distinct session 数（来自 cfg.skills.minSessions）。 */
+    minSessions: number;
+    /** 自动晋升需证据条数（来自 cfg.skills.minEvidence；仅约束自动路径）。 */
+    minEvidence: number;
+    lastRoundAt?: string;
+    backfilledAt?: string;
+}
 export interface SkillsListResponse {
     enabled: boolean;
     /** 自动晋升总闸（allowPromote）；关时 promote 动作会被拒。 */
     allowPromote: boolean;
     memoryMutate: boolean;
     skills: SkillView[];
+    /** 生产者健康态（0.26.14+；旧宿主缺省）。 */
+    producer?: SkillProducerView;
+}
+/** dsh-memory/skills-detect：手动回灌历史（一次性扫描存量 work_method）。 */
+export interface SkillsDetectRequest {
+    /** 扫描上限（缺省 20000）；大库可调小先试水。 */
+    maxRecords?: number;
+}
+export interface SkillsDetectResponse {
+    ok: boolean;
+    /** 扫过的 L1 记录总数。 */
+    scanned: number;
+    /** 其中可用的 work_method 条数。 */
+    methods: number;
+    created: number;
+    appended: number;
+    promoted: number;
+    /** 因缺 `dsh_source_anchors` 而无法归属会话的记录数（不猜 provenance）。 */
+    skippedNoAnchor: number;
+    pages: number;
+    /** 是否因扫描上限被截断。 */
+    truncated: boolean;
+    notice: string;
+    error?: string;
 }
 export interface SkillsActionRequest {
     id: string;
@@ -1940,6 +1985,7 @@ export interface DshMemoryRequestMap {
     'dsh-memory/memory-sources-retire': MemorySourcesRetireRequest;
     'dsh-memory/memport-scan': MemportScanRequest;
     'dsh-memory/skills-list': Record<string, never>;
+    'dsh-memory/skills-detect': SkillsDetectRequest;
     'dsh-memory/session-recalled': SessionRecalledRequest;
     'dsh-memory/recall-feedback': RecallFeedbackRequest;
     'dsh-memory/workspace-relink': WorkspaceRelinkRequest;
@@ -2007,6 +2053,7 @@ export interface DshMemoryResponseMap {
     'dsh-memory/memory-sources-retire': MemorySourcesRetireResponse;
     'dsh-memory/memport-scan': MemportScanResponse;
     'dsh-memory/skills-list': SkillsListResponse;
+    'dsh-memory/skills-detect': SkillsDetectResponse;
     'dsh-memory/session-recalled': SessionRecalledResponse;
     'dsh-memory/recall-feedback': RecallFeedbackResponse;
     'dsh-memory/workspace-relink': WorkspaceRelinkResponse;

package/dist/index.js

@@ -42,6 +42,7 @@ import { registerObsoleteNotice } from './hooks/obsolete-notice.js';
 import { RoomRegistryStore } from './store/rooms-registry.js';
 import { MemorySourceStore } from './store/memory-sources.js';
 import { SkillStore } from './store/skill-store.js';
+import { createSkillProducer } from './skills/producer.js';
 import { registerSkillRecall } from './hooks/skill-recall.js';
 import { registerSkillTools } from './tools/skills.js';
 import { RecallUsageStore } from './store/recall-usage.js';
@@ -209,6 +210,8 @@ export async function apply(ctx, config) {
     const stores = {
         usage: undefined, // 装配于下方(依赖 dataDir 就绪)
         routeHealth: undefined, // R9 路由健康学习，装配于下方
+        // 轨2 技能结晶生产者（issue #15 的缺失环节）：装配于下方（依赖 skillStore 就绪）。
+        skills: undefined,
         // DRSC 客户端(T8.4 读切):蒸馏背景窗 + conversation_search 工具面的历史供给。
         // 硬依赖无本地回退(l0 表退役);trustedHosts 惰性读取(webStartup 可能晚到)。
         drsc: new DrscClient({ trustedHosts: () => readStartupTrustedHosts(ctx) }),
@@ -425,6 +428,19 @@ export async function apply(ctx, config) {
     // 技能存储（轨2；sidecar 无条件加载，但工具/注入均由 cfg.skills.enabled 默认关自 no-op）
     const skillStore = new SkillStore(dataDir, logger);
     await skillStore.init();
+    // 技能结晶生产者：稳态由 runner 在每轮 L2 之后喂（`stores.skills`），历史存量走
+    // 面板「立即检测历史」/`skills-detect` RPC。cfg 用函数取：面板改阈值下一轮即生效。
+    stores.skills = createSkillProducer({
+        skills: skillStore,
+        l1: stores.l1,
+        cfg: () => effectiveCfg(config, live).skills,
+        logger,
+    });
+    // 诚实化（issue #15 建议 3）：开关已开但 sidecar 从来没被写过，就是“无生产者”的
+    // 历史现场。以前这里静默为 0、界面看不出异常，用户只能猜是自己操作错了。
+    if (skillStore.wasAbsentAtBoot() && (config.skills.enabled || live.get().skillsEnabled)) {
+        logger.warn('[memory] 技能开关已开但 skills.json 尚不存在：将在首轮结晶后生成（存量可在技能页点「立即检测历史」回灌）');
+    }
     const ruminate = storageOk && !db.isDegraded() && ruminateFile
         ? new RuminateController(ctx, config, runner, stores, logger, live, ruminateFile, roomRegistry)
         : undefined;
@@ -497,7 +513,7 @@ export async function apply(ctx, config) {
     // memoryRecall 投影：本会话“已注入且未被压缩覆盖”的召回集（会话感知，init 取 header.id），
     // 与常驻槽位是两条轴：那个是手动 pin 的硬注入约定，这个是非常驻的相关性浮现结果。
     // 带上反馈面：条目要显示人已经打过的那一笔（rating）。
-    registerRecallProjection(ctx, stores.recalled, stores.l1, recallFeedback);
+    registerRecallProjection(ctx, stores.recalled, stores.l1, recallFeedback, logger);
     // 人打 -1 声明过时后，下一轮向模型一次性播报“这条已退场、别再依据它作答”。
     registerObsoleteNotice(ctx, config, obsoleteNotices, logger);
     void slotRecall;
@@ -514,7 +530,9 @@ export async function apply(ctx, config) {
         runnerView: (sid, mode) => runner.sessionView(sid, mode),
         l0Count: (sid) => stores.l0.countBySession(sid),
         capabilities: () => db.getCapabilities(),
-    }, ruminate, storageOk ? roomRegistry : undefined, storageOk ? memorySources : undefined, skillStore);
+    }, ruminate, storageOk ? roomRegistry : undefined, storageOk ? memorySources : undefined, skillStore, 
+    // 技能生产者：面板「立即检测历史」与 producer 健康态的数据源。
+    stores.skills);
     // bench 控制服务(config.benchControl 门控,默认关):仅基准/调试部署注册,
     // 供同进程的 bench-runner lifecycle 赛道触发 rebuild / 设置会话档位
     // (宿主侧 RPC 无 call(),见 bench-control.ts)

package/dist/pipeline/l1.js

@@ -14,6 +14,7 @@ import { buildConflictPair, conflictRejectId, DEFER_MAX, normalizeClaimKey, norm
 import { formatExtractionPrompt, getExtractMemoriesSystemPrompt } from '../prompts/l1-extraction.js';
 import { normTags, normUsageScenario, readCognitiveHall, readWing } from '../metadata-validators.js';
 import { acceptTitle } from '../util/md-name.js';
+import { clampPriority } from '../util/priority.js';
 import { formatBatchConflictPrompt, getConflictDetectionSystemPrompt } from '../prompts/l1-dedup.js';
 import { resolveSourceAnchors, withSourceAnchors } from './anchors.js';
 import { stampValidity, validToSourceOf } from '../store/validity.js';
@@ -196,7 +197,7 @@ export function toStoreRecord(m, now, ts, anchorMap) {
         id: m.record_id,
         content: m.content,
         type: m.type,
-        priority: Number(m.priority) || 60,
+        priority: clampPriority(m.priority),
         scene_name: m.scene_name,
         timestamps: [Number.isNaN(ts) ? now : ts],
         createdAt: now,
@@ -714,7 +715,7 @@ routeHealth) {
             id: m.record_id,
             content: mergedContent,
             type: decision.merged_type || m.type,
-            priority: Number(decision.merged_priority) || Number(m.priority) || 60,
+            priority: clampPriority(decision.merged_priority ?? m.priority),
             scene_name: m.scene_name,
             timestamps: Array.from(new Set(mergedTs)).sort((a, b) => a - b),
             createdAt: now,

package/dist/pipeline/runner.d.ts

@@ -24,6 +24,7 @@ import type { StateStore } from '../store/state.js';
 import type { ConversationMessage, ExtractMode, MemoryFamily, MemoryLogger } from '../types.js';
 import type { FamilyStates } from './l1.js';
 import type { RouteHealthStore } from '../store/route-health.js';
+import type { SkillProducer } from '../skills/producer.js';
 export interface MemoryStores {
     /**
      * DRSC 客户端(T8.4 读切):蒸馏背景窗的历史供给面(op=session&tail&redact=1)。
@@ -48,6 +49,13 @@ export interface MemoryStores {
     };
     /** R9 路由健康学习（可选）：未传则 runExtraction 不启用自适应块长学习。 */
     routeHealth?: RouteHealthStore;
+    /**
+     * 轨2 技能结晶的生产者（可选）：未装配时蒸馏轮次完全不做结晶，行为与改动前一致。
+     *
+     * 挂在 L2 之后而不是每轮开头：复用既有攒批节奏、不新增 timer，且失败只记日志
+     * （技能结晶不该把蒸馏轮次带崩）。
+     */
+    skills?: SkillProducer;
 }
 /** 管线任务(优先级调度:live > graph > rebuild)。 */
 export interface PipelineTask {

package/dist/pipeline/runner.js

@@ -759,6 +759,23 @@ export class MemoryRunner {
                 }
             }
         }
+        // ── 轨2 技能结晶：把本轮新出的 work_method 喂给生产者 ──
+        // 位置选在 L2 之后：不抢既有层链、`newRecords` 已在手且天然属于本轮 sessionId
+        // （L1 记录本身不存会话，这是 distinct-session 唯一可靠的来源）。
+        // 独立 try：技能写库失败绝不能影响 L1/L2/L3 落库与图谱泵。
+        if (distillOn && this.stores.skills !== undefined && newRecords.length > 0) {
+            try {
+                const s = await this.stores.skills.ingestRound(newRecords, sessionId, `run-${turnStart}`);
+                if (s.errors.length > 0)
+                    this.logger.warn(`[memory] 技能结晶部分失败(session=${sessionId}): ${s.errors.join(' | ')}`);
+                else if (s.candidatesTouched > 0) {
+                    this.logger.debug?.(`[memory] 技能结晶完成(session=${sessionId},触及 ${s.candidatesTouched} 候选/新建 ${s.created}/证据 +${s.appended})`);
+                }
+            }
+            catch (err) {
+                this.logger.warn(`[memory] 技能结晶失败(不影响蒸馏): ${errDetail(err)}`);
+            }
+        }
         if (cfg.l3.enabled && distillOn) {
             for (const family of ['chat', 'work']) {
                 const tL3 = Date.now();

package/dist/projection/recall.d.ts

@@ -116,5 +116,7 @@ export interface RecallFeedbackFace {
  * apply 是 O(1) 判脏（store.revision() 与反馈序号比对），任意已提交事件都会带进来看一眼。
  * @param feedback - 相关度反馈只读面；缺席时 view 不带 rating（旧行为）。
  */
-export declare function registerRecallProjection(ctx: Context, store: SessionRecalledStore, l1?: RecallL1Face, feedback?: RecallFeedbackFace): void;
+export declare function registerRecallProjection(ctx: Context, store: SessionRecalledStore, l1?: RecallL1Face, feedback?: RecallFeedbackFace, log?: {
+    warn(message: string): void;
+}): void;
 export {};

package/dist/projection/recall.js

@@ -1,5 +1,6 @@
 import { isRetired } from '../store/supersede.js';
 import { stateOfRecord } from '../store/validity.js';
+import { clampPriority, isDirtyPriority } from '../util/priority.js';
 export const MEMORY_RECALL_KEY = 'memoryRecall';
 /** view 最多透出条数（最近在上；超出部分只计入 count，防 wire 体量失控）。 */
 export const RECALL_VIEW_CAP = 20;
@@ -141,7 +142,7 @@ function sameIds(a, b) {
 }
 /** view 引用稳定：同一 state 恒返回同一对象（registry 按 Object.is 判发布）。 */
 const viewMemo = new WeakMap();
-function makeView(state, l1, feedback) {
+function makeView(state, l1, feedback, log) {
     const memoized = viewMemo.get(state);
     if (memoized !== undefined)
         return memoized;
@@ -163,11 +164,16 @@ function makeView(state, l1, feedback) {
         // 未退场行才会真判过时两档（退场行由 retired 键表达，validity 不再叠加）。
         const vState = isRetired(r) ? undefined : stateOfRecord(r, Date.now());
         const showValidity = vState === 'expired' || vState === 'expired_suspect';
+        // #19 读侧兜底：脏 priority（负/超界/非整数/非有限）就地夹取，绝不让 viewSchema
+        // 因单条脏字段抛错打死整会话；命中时 warn 留痕（静默夹取会掩盖上游 LLM 异常）。
+        const rawPriority = r.priority;
+        if (isDirtyPriority(rawPriority))
+            log?.warn(`[memory][recall] 脏 priority 回落 record=${r.id} raw=${String(rawPriority)}`);
         items.push({
             id: r.id,
             type: r.type,
             title: r.name || firstLine(r.content),
-            priority: r.priority,
+            priority: clampPriority(rawPriority),
             body: clampBody(r.content),
             ...(scenario !== undefined && scenario.length > 0 ? { scenario } : {}),
             ...(typeof rating === 'number' ? { rating } : {}),
@@ -196,7 +202,7 @@ function sessionIdOf(header) {
  * apply 是 O(1) 判脏（store.revision() 与反馈序号比对），任意已提交事件都会带进来看一眼。
  * @param feedback - 相关度反馈只读面；缺席时 view 不带 rating（旧行为）。
  */
-export function registerRecallProjection(ctx, store, l1, feedback) {
+export function registerRecallProjection(ctx, store, l1, feedback, log) {
     ctx.inject(['sessionProjections'], (injected) => {
         const registry = injected.sessionProjections;
         if (registry === undefined || typeof registry.register !== 'function')
@@ -208,9 +214,9 @@ export function registerRecallProjection(ctx, store, l1, feedback) {
             stateSchema,
             init: (header) => buildState(sessionIdOf(header), store, fbRev()),
             apply: (state) => buildState(state.sessionId, store, fbRev(), state),
-            wire: { viewSchema, view: (state) => makeView(state, l1, feedback) },
+            wire: { viewSchema, view: (state) => makeView(state, l1, feedback, log) },
             schema: viewSchema,
-            view: (state) => makeView(state, l1, feedback),
+            view: (state) => makeView(state, l1, feedback, log),
             stateVersion: 0,
         };
         registry.register(definition);

package/dist/skills/crystallize.d.ts

@@ -4,8 +4,10 @@
  * 从 `work_method` 记忆**派生技能候选**——技能不是 memory `type`（不碰 ADD_TYPES/prompt 词表，
  * S1/S2/S3 不触发），而是对"跨会话重复出现的工作方法"的聚合投影（对齐 ADR-0007 可重建投影）。
  *
- * 本轮定位：**只提供确定性检测函数 + 手动工具路径，不自动挂进 runner 每轮热路径**
- * （接入 runner 会给每轮蒸馏加活儿，且需与攒批/层链协调——留作显式 opt-in 的后续增强）。
+ * 本轮定位：**只提供确定性检测函数**，不自动挂进 runner 每轮热路径
+ * （接入 runner 会给每轮蒸馏加活儿，且需与攒批/层链协调）。
+ * 生产者在 `producer.ts`：稳态挂 L2 攒批轮次（`ingestRound`）+ 一次性历史回灌
+ * （`backfill`），两者共用本文件的 `groupKey`/`fnv1a` 以保证候选 id 同源。
  * 检测是纯规则：按 (hall, scene) 分组，够 distinct-session 且够条数才成候选；
  * 候选默认 `status:'candidate'`，晋升仍由 SkillStore.tryPromote（且 cfg.skills.allowPromote
  * 默认关）单独把关——检测与晋升解耦，和 conflictFreeze"不自动裁决"同哲学。
@@ -34,6 +36,19 @@ export interface DetectOptions {
     /** 每候选最多收录的步骤数（防单组爆炸）。 */
     maxSteps?: number;
 }
+/**
+ * 分组键：hall + scene（缺省归 'general'）；决定"同一类工作流"的判定粒度。
+ *
+ * 导出给 `producer.ts` 复用：增量路径与 backfill 路径必须算出**同一个** key，
+ * 否则同一组会结晶出两个不同 id 的候选，幂等直接崩。改这里等于改存量技能 id。
+ */
+export declare function groupKey(r: MethodRecord): string;
+/**
+ * 稳定短哈希（FNV-1a 32bit，零依赖、确定性），用于派生候选 id。
+ *
+ * 同 `groupKey`：单点导出供 producer 共用，禁止另写一份。
+ */
+export declare function fnv1a(s: string): string;
 /**
  * 检测候选：按 groupKey 聚合 work_method 记录，distinct-session ≥ minSessions 且
  * 去重后内容条数 ≥ minEvidence 的组，产出一条 candidate 提案（按 groupKey 排序，确定性）。

package/dist/skills/crystallize.js

@@ -4,18 +4,29 @@
  * 从 `work_method` 记忆**派生技能候选**——技能不是 memory `type`（不碰 ADD_TYPES/prompt 词表，
  * S1/S2/S3 不触发），而是对"跨会话重复出现的工作方法"的聚合投影（对齐 ADR-0007 可重建投影）。
  *
- * 本轮定位：**只提供确定性检测函数 + 手动工具路径，不自动挂进 runner 每轮热路径**
- * （接入 runner 会给每轮蒸馏加活儿，且需与攒批/层链协调——留作显式 opt-in 的后续增强）。
+ * 本轮定位：**只提供确定性检测函数**，不自动挂进 runner 每轮热路径
+ * （接入 runner 会给每轮蒸馏加活儿，且需与攒批/层链协调）。
+ * 生产者在 `producer.ts`：稳态挂 L2 攒批轮次（`ingestRound`）+ 一次性历史回灌
+ * （`backfill`），两者共用本文件的 `groupKey`/`fnv1a` 以保证候选 id 同源。
  * 检测是纯规则：按 (hall, scene) 分组，够 distinct-session 且够条数才成候选；
  * 候选默认 `status:'candidate'`，晋升仍由 SkillStore.tryPromote（且 cfg.skills.allowPromote
  * 默认关）单独把关——检测与晋升解耦，和 conflictFreeze"不自动裁决"同哲学。
  */
-/** 分组键：hall + scene（缺省归 'general'）；决定"同一类工作流"的判定粒度。 */
-function groupKey(r) {
+/**
+ * 分组键：hall + scene（缺省归 'general'）；决定"同一类工作流"的判定粒度。
+ *
+ * 导出给 `producer.ts` 复用：增量路径与 backfill 路径必须算出**同一个** key，
+ * 否则同一组会结晶出两个不同 id 的候选，幂等直接崩。改这里等于改存量技能 id。
+ */
+export function groupKey(r) {
     return `${r.hall ?? 'general'}\u0000${r.sceneName ?? ''}`;
 }
-/** 稳定短哈希（FNV-1a 32bit，零依赖、确定性），用于派生候选 id。 */
-function fnv1a(s) {
+/**
+ * 稳定短哈希（FNV-1a 32bit，零依赖、确定性），用于派生候选 id。
+ *
+ * 同 `groupKey`：单点导出供 producer 共用，禁止另写一份。
+ */
+export function fnv1a(s) {
     let h = 0x811c9dc5;
     for (let i = 0; i < s.length; i++) {
         h ^= s.charCodeAt(i);

package/dist/skills/producer.d.ts

@@ -0,0 +1,89 @@
+/**
+ * 技能结晶的生产者（issue #15 的缺失环节）。
+ *
+ * **为什么需要这个文件**：`crystallize.detectCandidates` 自 0.26.x 起就存在，但全仓
+ * 只有测试调用它，`SkillStore.create()` 同样零生产调用点 ⇒ `skills.json` 永远不会被
+ * 写入，看板恒为 0。本文件补的就是生产者。
+ *
+ * **两条路径，一套语义**：
+ * - `ingestRound`（稳态）：挂 `runner.runTurn` 的 L2 攒批轮次之后，吃本轮新记录 +
+ *   本轮 sessionId。0 全表扫描、0 IO 读、0 LLM。
+ * - `backfill`（一次性）：分页扫历史记录，从 `metadata.dsh_source_anchors` 复原会话
+ *   归属，让装了很久的老库不必再跨 N 个会话才见第一条技能。
+ * 两者共用 `crystallize` 的 `groupKey`/`fnv1a`，保证同一组在两条路径算出**同一个**
+ * 候选 id（否则会出现两个重复候选，幂等崩）。
+ *
+ * **三条不可让步的纪律**：
+ * 1. 必须投 `evidence`——`SkillStore.sessionCount` 只数 evidence 行、不看
+ *    `Skill.evidenceRecordIds`；只 create 不 appendEvidence 的话，技能永远停在
+ *    candidate 且 distinct-session 恒 0，**即使 allowPromote 打开也永不晋升**。
+ * 2. 只覆盖 `steps`，绝不传 `body`——`body` 是人编辑区（`skill-store.ts` 头部分列
+ *    不变量），机器侧只能重写 checklist 步骤。
+ * 3. 不调 `getAllL1()`/`l1.all()`——那两个方法一次性全量同步反序列化含正文，
+ *    在事件循环里会阻塞所有 RPC（`sqlite.ts` 里 `getAllL1Lite` 的存在理由注释已写明）。
+ *
+ * **候选首见即建，但不注入**：`appendEvidence` 要求技能已存在，所以无法"攒够阈再建"；
+ * 而 `status:'candidate'` 本身不进召回（`skill-recall` 只注入 active），因此早期建
+ * 候选没有注意力税。"是否达阈"由面板按 sessionCount/minSessions 如实显示。
+ */
+import type { MemoryConfig } from '../config.js';
+import type { L1Store } from '../store/l1.js';
+import type { SkillStore } from '../store/skill-store.js';
+import type { MemoryLogger, MemoryRecord } from '../types.js';
+type SkillsConfig = MemoryConfig['skills'];
+/** 一次投递的账目。`errors` 只收要人看的失败原因，不抛穿调用方。 */
+export interface SkillIngestSummary {
+    /** 入参记录总数（含被过滤掉的其它类型）。 */
+    scanned: number;
+    /** 其中 work_method 且正文非空的条数。 */
+    methods: number;
+    /** 本轮触及的候选数。 */
+    candidatesTouched: number;
+    created: number;
+    /** 新投的证据条数（去重后）。 */
+    appended: number;
+    promoted: number;
+    /** backfill 专用：因缺锚点而跳过的记录数（增量路径恒 0）。 */
+    skippedNoAnchor: number;
+    /** 是否因技能数达上限而提前停止。 */
+    stoppedAtCap: boolean;
+    errors: string[];
+}
+export interface SkillBackfillSummary extends SkillIngestSummary {
+    /** 实际翻页次数（可观测：判断大库回灌成本）。 */
+    pages: number;
+    /** 是否因扫描上限被截断。 */
+    truncated: boolean;
+}
+/** 生产者健康态：面板三态判定与 `skills-list` 透出的数据源。 */
+export interface SkillProducerStatus {
+    /** 本版起恒为 true；保留该字段是为了让面板能区分"有生产者"与旧版空盒子。 */
+    wired: true;
+    lastRoundAt?: string;
+    backfilledAt?: string;
+}
+export interface SkillProducer {
+    /** 稳态入口：本轮新记录 + 本轮 sessionId。 */
+    ingestRound(records: readonly MemoryRecord[], sessionId: string, runId: string): Promise<SkillIngestSummary>;
+    /** 一次性历史回灌（面板「立即检测历史」按钮与 `skills-detect` RPC 的落点）。 */
+    backfill(opts?: {
+        maxRecords?: number;
+        page?: number;
+    }): Promise<SkillBackfillSummary>;
+    status(): SkillProducerStatus;
+}
+export interface SkillProducerDeps {
+    skills: SkillStore;
+    l1: L1Store;
+    /** 函数式取配置：面板改阈值后下一轮即生效，不必重启。 */
+    cfg: () => SkillsConfig;
+    logger?: MemoryLogger;
+}
+/**
+ * 建一个技能生产者。
+ *
+ * 所有失败都在内部消化成 `summary.errors` + warn 日志，**不抛穿调用方**——
+ * 蒸馏轮次不该因为技能结晶失败而丢记忆。
+ */
+export declare function createSkillProducer(deps: SkillProducerDeps): SkillProducer;
+export {};

package/dist/skills/producer.js

@@ -0,0 +1,274 @@
+import { ANCHOR_METADATA_KEY } from '../pipeline/anchors.js';
+import { fnv1a, groupKey } from './crystallize.js';
+/** L1 词表里的「工作方法」类型字面量（技能只从这一类派生，不新增类型）。 */
+const WORK_METHOD_TYPE = 'work_method';
+/** 证据行的来源标记：区分蒸馏轮次投的与人工补的。 */
+const EVIDENCE_KIND = 'distill';
+/** backfill 分页大小与扫描上限：大库必须可截断，不许无界扫。 */
+const BACKFILL_PAGE = 500;
+const BACKFILL_MAX_RECORDS = 20_000;
+/** 单候选最多收录的步骤数与证据 id 数（与 crystallize 的默认口径一致）。 */
+const MAX_STEPS = 20;
+const EVIDENCE_IDS_CAP = 200;
+/** 候选 body 的首段截取长度（steps[0] 的摘要，人可后续编辑）。 */
+const BODY_LEAD_CHARS = 200;
+/**
+ * 把 L1 记录归一成检测用的视图：`hall` 住在 `metadata.hall`（Wings 关时缺省 ⇒
+ * groupKey 回落 'general'），`scene_name` 是 snake_case 列，`sessionId` 由调用方注入
+ * （**记录本身不存 sessionId**，这是本文件存在的关键约束之一）。
+ */
+function toViews(records, sessionId) {
+    const out = [];
+    for (const r of records) {
+        if (!r || r.type !== WORK_METHOD_TYPE)
+            continue;
+        if (typeof r.content !== 'string' || r.content.trim() === '')
+            continue;
+        const hall = typeof r.metadata?.['hall'] === 'string' ? r.metadata['hall'] : undefined;
+        out.push({ id: r.id, content: r.content, sessionId, hall, sceneName: r.scene_name });
+    }
+    return out;
+}
+/**
+ * 从锚点展开一条历史记录到「每会话一条视图」。
+ *
+ * 无锚点或锚点里 sessionId 全空 ⇒ 返回空数组（调用方计入 `skippedNoAnchor`）。
+ * **绝不回落成 `'default'`**：伪造的会话归属会虚增 distinct-session，直接骗过晋升门。
+ */
+function viewsFromAnchors(r) {
+    if (!r || r.type !== WORK_METHOD_TYPE)
+        return { views: [], sessions: 0 };
+    if (typeof r.content !== 'string' || r.content.trim() === '')
+        return { views: [], sessions: 0 };
+    const raw = r.metadata?.[ANCHOR_METADATA_KEY];
+    if (!Array.isArray(raw))
+        return { views: [], sessions: 0 };
+    const hall = typeof r.metadata?.['hall'] === 'string' ? r.metadata['hall'] : undefined;
+    const seen = new Set();
+    const views = [];
+    for (const a of raw) {
+        const sid = typeof a?.sessionId === 'string' ? a.sessionId.trim() : '';
+        if (sid === '' || seen.has(sid))
+            continue;
+        seen.add(sid);
+        views.push({ id: r.id, content: r.content, sessionId: sid, hall, sceneName: r.scene_name });
+    }
+    return { views, sessions: seen.size };
+}
+function buildGroups(views) {
+    const m = new Map();
+    for (const v of views) {
+        const key = groupKey(v);
+        const g = m.get(key);
+        if (g)
+            g.views.push(v);
+        else
+            m.set(key, { key, id: 'skx-' + fnv1a(key), hall: v.hall, sceneName: v.sceneName, views: [v] });
+    }
+    // 按 key 排序：与 detectCandidates 同口径，让日志与快照可复现。
+    return [...m.values()].sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
+}
+/** 归一化去重步骤（空白折叠 + 小写比较，保留首次出现顺序）。 */
+function dedupe(views) {
+    const seen = new Set();
+    const steps = [];
+    const recordIds = [];
+    for (const v of views) {
+        const norm = v.content.replace(/\s+/g, ' ').trim();
+        if (norm === '')
+            continue;
+        const probe = norm.toLowerCase();
+        if (seen.has(probe))
+            continue;
+        seen.add(probe);
+        if (steps.length < MAX_STEPS)
+            steps.push(norm);
+        if (recordIds.length < EVIDENCE_IDS_CAP && !recordIds.includes(v.id))
+            recordIds.push(v.id);
+    }
+    return { steps, recordIds };
+}
+/** 候选标题：与 detectCandidates 的 label 公式逐字一致（两处漂移会让同一组显示两个名字）。 */
+function titleOf(g) {
+    const label = g.hall && g.hall !== 'general' ? `${g.hall} 流程` : g.sceneName ? `${g.sceneName} 流程` : '通用流程';
+    return `技能：${label}`;
+}
+/**
+ * 建一个技能生产者。
+ *
+ * 所有失败都在内部消化成 `summary.errors` + warn 日志，**不抛穿调用方**——
+ * 蒸馏轮次不该因为技能结晶失败而丢记忆。
+ */
+export function createSkillProducer(deps) {
+    const { skills, l1, logger } = deps;
+    let lastRoundAt;
+    let backfilledAt;
+    /** 空账目（开关关时直接返回，全程零动作）。 */
+    const emptySummary = () => ({
+        scanned: 0,
+        methods: 0,
+        candidatesTouched: 0,
+        created: 0,
+        appended: 0,
+        promoted: 0,
+        skippedNoAnchor: 0,
+        stoppedAtCap: false,
+        errors: [],
+    });
+    /**
+     * 把一组视图落成「一个候选 + 若干证据」，并按需尝试晋升。
+     * 返回 false 表示应当中止外层循环（达 SKILLS_CAP）。
+     */
+    const absorbGroup = async (g, runId, cfg, s) => {
+        const { steps, recordIds } = dedupe(g.views);
+        if (steps.length === 0)
+            return true;
+        let exists = skills.get(g.id) !== undefined;
+        if (!exists) {
+            try {
+                await skills.create({
+                    id: g.id,
+                    title: titleOf(g),
+                    body: (steps[0] ?? '').slice(0, BODY_LEAD_CHARS),
+                    steps,
+                    trigger: { hall: g.hall, sceneName: g.sceneName },
+                    status: 'candidate',
+                    family: 'work',
+                    evidenceRecordIds: recordIds,
+                });
+                s.created += 1;
+                exists = true;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                if (msg.includes('上限')) {
+                    s.stoppedAtCap = true;
+                    s.errors.push('技能数已达上限，本轮停止结晶（可在面板归档部分技能）');
+                    logger?.warn('[memory] 技能结晶停止：技能数已达上限');
+                    return false;
+                }
+                if (!msg.includes('已存在')) {
+                    s.errors.push(`建候选失败: ${msg}`);
+                    logger?.warn(`[memory] 技能候选创建失败(${g.id}): ${msg}`);
+                    return true;
+                }
+                // 并发下另一轮刚建好：当作已存在，继续走证据路径
+                exists = true;
+            }
+        }
+        else {
+            // 机器侧只重写 steps；body 是人编辑区，传进去就破坏了分列不变量。
+            try {
+                await skills.update(g.id, { steps });
+            }
+            catch (err) {
+                s.errors.push(`更新步骤失败: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        s.candidatesTouched += 1;
+        // 证据：sessionCount 的唯一来源。三元组去重，重复轮次不重复投。
+        const at = new Date().toISOString();
+        for (const v of g.views) {
+            if (v.sessionId === '')
+                continue;
+            if (skills.hasEvidence(g.id, v.sessionId, v.id))
+                continue;
+            try {
+                await skills.appendEvidence({ skillId: g.id, runId, recordId: v.id, sessionId: v.sessionId, at, kind: EVIDENCE_KIND });
+                s.appended += 1;
+            }
+            catch (err) {
+                s.errors.push(`投证据失败: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        // 自动晋升：双阈同时满足才动（minEvidence 此前无人消费，这里让它真实生效）。
+        // 人工晋升走 skills-action，只卡 sessionCount——人审是人的判断，不重复机械门。
+        if (cfg.allowPromote && exists) {
+            if (skills.sessionCount(g.id) >= cfg.minSessions && skills.evidenceCount(g.id) >= cfg.minEvidence) {
+                if (await skills.tryPromote(g.id, cfg.minSessions, { allowPromote: true }))
+                    s.promoted += 1;
+            }
+        }
+        return true;
+    };
+    const drainGroups = async (groups, runId, cfg, s) => {
+        for (const g of groups) {
+            if (!(await absorbGroup(g, runId, cfg, s)))
+                return;
+        }
+    };
+    return {
+        async ingestRound(records, sessionId, runId) {
+            const s = emptySummary();
+            const cfg = deps.cfg();
+            s.scanned = records.length;
+            if (!cfg.enabled || records.length === 0)
+                return s;
+            const views = toViews(records, sessionId);
+            s.methods = views.length;
+            if (views.length === 0)
+                return s;
+            try {
+                await drainGroups(buildGroups(views), runId, cfg, s);
+                lastRoundAt = new Date().toISOString();
+            }
+            catch (err) {
+                s.errors.push(err instanceof Error ? err.message : String(err));
+            }
+            if (s.candidatesTouched > 0 || s.created > 0) {
+                logger?.info(`[memory] 技能结晶：触及 ${s.candidatesTouched} 候选（新建 ${s.created}、证据 +${s.appended}${s.promoted > 0 ? `、晋升 ${s.promoted}` : ''}）`);
+            }
+            return s;
+        },
+        async backfill(opts) {
+            const s = { ...emptySummary(), pages: 0, truncated: false };
+            const cfg = deps.cfg();
+            if (!cfg.enabled)
+                return s;
+            const page = opts?.page !== undefined && opts.page > 0 ? opts.page : BACKFILL_PAGE;
+            const maxRecords = opts?.maxRecords !== undefined && opts.maxRecords > 0 ? opts.maxRecords : BACKFILL_MAX_RECORDS;
+            // 累积全部会话的视图后一次性分组：跨页分裂的同组记录必须合成一个候选，
+            // 所以不能在页内直接落库。上限由 maxRecords 兜住，内存里只放视图引用。
+            const views = [];
+            try {
+                for (let offset = 0;; offset += page) {
+                    const lite = l1.allLite(page, offset);
+                    s.pages += 1;
+                    if (lite.length === 0)
+                        break;
+                    s.scanned += lite.length;
+                    const ids = lite.filter((r) => r.type === WORK_METHOD_TYPE).map((r) => r.id);
+                    if (ids.length > 0) {
+                        for (const r of l1.getByIds(ids)) {
+                            const { views: vs } = viewsFromAnchors(r);
+                            if (vs.length === 0) {
+                                if (r.content.trim() !== '' && r.type === WORK_METHOD_TYPE)
+                                    s.skippedNoAnchor += 1;
+                                continue;
+                            }
+                            views.push(...vs);
+                        }
+                    }
+                    if (s.scanned >= maxRecords) {
+                        s.truncated = true;
+                        break;
+                    }
+                    // 让出事件循环：大库回灌期间面板 RPC 不能被独占（对齐 allLite 的存在理由）。
+                    await new Promise((resolve) => setImmediate(resolve));
+                }
+                s.methods = new Set(views.map((v) => v.id)).size;
+                await drainGroups(buildGroups(views), `backfill-${Date.now().toString(36)}`, cfg, s);
+                backfilledAt = new Date().toISOString();
+            }
+            catch (err) {
+                s.errors.push(err instanceof Error ? err.message : String(err));
+                logger?.warn(`[memory] 技能历史回灌失败: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            logger?.info(`[memory] 技能历史回灌：扫 ${s.scanned} 条记录（${s.pages} 页${s.truncated ? '，达上限截断' : ''}）→ 触及 ${s.candidatesTouched} 候选（新建 ${s.created}、证据 +${s.appended}${s.skippedNoAnchor > 0 ? `、${s.skippedNoAnchor} 条缺锚点跳过` : ''}）`);
+            return s;
+        },
+        status() {
+            return { wired: true, ...(lastRoundAt === undefined ? {} : { lastRoundAt }), ...(backfilledAt === undefined ? {} : { backfilledAt }) };
+        },
+    };
+}

package/dist/stats.d.ts

@@ -6,6 +6,7 @@ import type { RuminateController } from './pipeline/ruminate.js';
 import type { RoomRegistryStore } from './store/rooms-registry.js';
 import type { MemorySourceStore } from './store/memory-sources.js';
 import type { SkillStore } from './store/skill-store.js';
+import type { SkillProducer } from './skills/producer.js';
 import type { RecallUsageStore } from './store/recall-usage.js';
 import { type LiveSettingsHandle } from './settings.js';
 import type { GraphStore } from './store/graph-store.js';
@@ -89,6 +90,8 @@ interface MemoryRpcSources {
     memorySources?: MemorySourceStore;
     /** 技能存储（轨2；未装配 = skills-* 不可用）。 */
     skillStore?: SkillStore;
+    /** 技能结晶生产者（未装配 = skills-detect 不可用、skills-list 不带 producer 态）。 */
+    skillProducer?: SkillProducer;
 }
 /** 端点 deps 的注入面(ctx/cfg/stores/logger 由调用方绑定,其余由此处决定)。 */
 export type EndpointDepsInput = Omit<EndpointDeps, 'ctx' | 'cfg' | 'stores' | 'logger'>;
@@ -118,7 +121,9 @@ roomRegistry?: RoomRegistryStore,
 /** 外部来源注册表（轨3 Connect；经 buildEndpointDeps 落入 deps.memorySources）。 */
 memorySources?: MemorySourceStore, 
 /** 技能存储（轨2；经 buildEndpointDeps 落入 deps.skillStore）。 */
-skillStore?: SkillStore): void;
+skillStore?: SkillStore, 
+/** 技能结晶生产者（轨2；经 buildEndpointDeps 落入 deps.skillProducer）。 */
+skillProducer?: SkillProducer): void;
 export interface EndpointDeps {
     ctx: Context;
     cfg: MemoryConfig;
@@ -157,6 +162,8 @@ export interface EndpointDeps {
     memorySources?: MemorySourceStore;
     /** 技能存储（轨2；未装配 = skills-* 不可用）。 */
     skillStore?: SkillStore;
+    /** 技能结晶生产者（轨2；未装配 = skills-detect 不可用，面板据此区分新旧版）。 */
+    skillProducer?: SkillProducer;
 }
 /** 端点分发表(导出供测试直调:可精确注入 rebuild/ruminate 等可选控制器,验证 deps 接线)。 */
 export declare function handleEndpoint(endpoint: string, payload: unknown, deps: EndpointDeps): Promise<unknown>;

package/dist/stats.js

@@ -139,6 +139,7 @@ export const MEMORY_ENDPOINTS = [
     'dsh-memory/memory-sources-retire',
     'dsh-memory/memport-scan',
     'dsh-memory/skills-list',
+    'dsh-memory/skills-detect',
     'dsh-memory/session-recalled',
     'dsh-memory/recall-feedback',
     'dsh-memory/workspace-relink',
@@ -247,6 +248,7 @@ export function buildEndpointDeps(base, sources, controller) {
         roomRegistry: sources.roomRegistry,
         memorySources: sources.memorySources,
         skillStore: sources.skillStore,
+        skillProducer: sources.skillProducer,
     };
     return { ...base, ...injected };
 }
@@ -258,7 +260,9 @@ roomRegistry,
 /** 外部来源注册表（轨3 Connect；经 buildEndpointDeps 落入 deps.memorySources）。 */
 memorySources, 
 /** 技能存储（轨2；经 buildEndpointDeps 落入 deps.skillStore）。 */
-skillStore) {
+skillStore, 
+/** 技能结晶生产者（轨2；经 buildEndpointDeps 落入 deps.skillProducer）。 */
+skillProducer) {
     /** 当前是否持有一段有效注册(dispose 完成后清空,允许服务重上线时重注册)。 */
     let holding = false;
     /** 当前 handle 绑定的 connection 实例(internal/service 第二参;用于识别实例替换)。 */
@@ -279,7 +283,7 @@ skillStore) {
                     const value = await handleEndpoint(endpoint, payload, buildEndpointDeps({ ctx, cfg, stores, logger }, 
                     // roomRegistry 必须随 sources 下发——漏带 = 面板侧 room-* 恒"未装配"
                     // (工具面直传不受影响;2026-10-02 beta.9 实测回归)
-                    { status, live, modes, dataDir, rebuild, embedManager, sessionInfo, roomRegistry, memorySources, skillStore }, ruminate));
+                    { status, live, modes, dataDir, rebuild, embedManager, sessionInfo, roomRegistry, memorySources, skillStore, skillProducer }, ruminate));
                     return { ok: true, value };
                 }
                 catch (err) {
@@ -427,7 +431,7 @@ function sanitizeSettings(s) {
 }
 /** 端点分发表(导出供测试直调:可精确注入 rebuild/ruminate 等可选控制器,验证 deps 接线)。 */
 export async function handleEndpoint(endpoint, payload, deps) {
-    const { cfg, stores, status, live, modes, dataDir, rebuild, ruminate, embedManager, sessionInfo, roomRegistry, memorySources, skillStore } = deps;
+    const { cfg, stores, status, live, modes, dataDir, rebuild, ruminate, embedManager, sessionInfo, roomRegistry, memorySources, skillStore, skillProducer } = deps;
     // 退场/恢复/新增的文件跟随已收口在 `L1Store` 的汇流口（`store/memory-md-sync.ts`），
     // 本分发层不再自己建点火器——那 8 处事件挂钩已被真机证伪（会漏）。
     switch (endpoint) {
@@ -923,10 +927,55 @@ export async function handleEndpoint(endpoint, payload, deps) {
                         tier: s.injectionTier,
                         pinned: s.pinned,
                         sessionCount: skillStore.sessionCount(s.id),
+                        evidenceCount: skillStore.evidenceCount(s.id),
                         updatedAt: s.updatedAt,
                     }))
                     : [],
             };
+            // 生产者健康态：面板靠它区分“旧版空盒子”与“已接线但未达阈”。
+            // 未装配生产者（测试缝/降级）时不附此字段，面板回到旧文案而不谎报已接线。
+            if (enabled && skillProducer && cfg.skills) {
+                const st = skillProducer.status();
+                const producer = {
+                    wired: st.wired,
+                    workMethodCount: stores.l1.countByType('work_method'),
+                    candidateCount: skillStore?.list().filter((s) => s.status === 'candidate').length ?? 0,
+                    minSessions: cfg.skills.minSessions,
+                    minEvidence: cfg.skills.minEvidence,
+                    ...(st.lastRoundAt === undefined ? {} : { lastRoundAt: st.lastRoundAt }),
+                    ...(st.backfilledAt === undefined ? {} : { backfilledAt: st.backfilledAt }),
+                };
+                v.producer = producer;
+            }
+            return v;
+        }
+        // 手动回灌历史：一次性扫存量 work_method，从锚点复原会话归属。
+        // 写库动作，所以与 skills-action 同走「高权限模式」门。
+        case 'dsh-memory/skills-detect': {
+            if (!(cfg.skills?.enabled === true || live?.get().skillsEnabled === true))
+                throw new Error('技能功能未启用（在概览页开启「技能」开关，或 config skills.enabled）。');
+            if (!skillProducer)
+                throw new Error('技能生产者未装配（本版本不应出现）。');
+            if (!live?.get().memoryMutate)
+                throw new Error('记忆写删未开放：请在记忆库面板开启「高权限模式」后才能回灌技能。');
+            const p = (payload ?? {});
+            const r = await skillProducer.backfill(p.maxRecords !== undefined ? { maxRecords: p.maxRecords } : undefined);
+            const notice = r.truncated
+                ? `已扫 ${r.scanned} 条（达上限截断）：新建 ${r.created} 候选、补投证据 ${r.appended} 条。`
+                : `已扫 ${r.scanned} 条：新建 ${r.created} 候选、补投证据 ${r.appended} 条${r.skippedNoAnchor > 0 ? `（${r.skippedNoAnchor} 条缺会话锚点已跳过）` : ''}。`;
+            const v = {
+                ok: r.errors.length === 0,
+                scanned: r.scanned,
+                methods: r.methods,
+                created: r.created,
+                appended: r.appended,
+                promoted: r.promoted,
+                skippedNoAnchor: r.skippedNoAnchor,
+                pages: r.pages,
+                truncated: r.truncated,
+                notice,
+                ...(r.errors.length === 0 ? {} : { error: r.errors.join(' | ') }),
+            };
             return v;
         }
         case 'dsh-memory/skills-action': {

package/dist/store/l1.d.ts

@@ -112,6 +112,13 @@ export declare class L1Store {
     /** 旧版单文件 records.jsonl 一次性导入检索库,成功后改名 .imported。 */
     private importLegacy;
     get size(): number;
+    /**
+     * 按类型计数（索引级，不拉正文）。
+     *
+     * 当前唯一消费方是技能面板的诚实化判定：要区分“池里没有可结晶的工作方法”
+     * 与“有但未达阈”，两者给用户的处置建议完全不同。
+     */
+    countByType(type: string): number;
     /** 全量读取(调试/迁移用;检索请走 search)。 */
     all(): MemoryRecord[];
     /**

package/dist/store/l1.js

@@ -134,6 +134,15 @@ export class L1Store {
     get size() {
         return this.db.countL1();
     }
+    /**
+     * 按类型计数（索引级，不拉正文）。
+     *
+     * 当前唯一消费方是技能面板的诚实化判定：要区分“池里没有可结晶的工作方法”
+     * 与“有但未达阈”，两者给用户的处置建议完全不同。
+     */
+    countByType(type) {
+        return this.db.countL1ByType(type);
+    }
     /** 全量读取(调试/迁移用;检索请走 search)。 */
     all() {
         return this.db.getAllL1();

package/dist/store/memory-md-parse.js

@@ -13,6 +13,7 @@
  * 与正文本体是否一致（`hashValid`），不替调用方决定怎么处置——那属于同步侧的裁决。
  */
 import { contentHash } from './memory-md.js';
+import { clampPriority } from '../util/priority.js';
 /** 取 frontmatter 块：首行必须是 `---`，到下一个 `---` 为止。 */
 function splitFrontmatter(text) {
     // BOM 与 CRLF 都要先吃掉：人在记事本里改一行就会引入 \r，而 `\r` 会让 key 匹配不上。
@@ -71,7 +72,7 @@ export function parseMdFile(text) {
     return {
         name: str(fields.get('name')),
         type: str(fields.get('type')),
-        priority: Number.isFinite(prio) ? prio : 60,
+        priority: clampPriority(prio),
         createdAt: str(fields.get('createdAt')),
         updatedAt: str(fields.get('updatedAt')),
         usageScenario: scenario,

package/dist/store/skill-store.d.ts

@@ -57,6 +57,7 @@ export declare class SkillStore {
     private evidence;
     private rev;
     private loaded;
+    private fileAbsentAtBoot;
     private degraded;
     private degradedLogged;
     private writeChain;
@@ -75,6 +76,26 @@ export declare class SkillStore {
     update(id: string, patch: Partial<Pick<Skill, 'title' | 'body' | 'steps' | 'injectionTier' | 'pinned'>>): Promise<boolean>;
     /** 追加一条证据（只追加）；返回该技能当前的 distinct-session 数。 */
     appendEvidence(ev: SkillEvidence): Promise<number>;
+    /**
+     * 启动时 `skills.json` 是否不存在（缺文件是合法空表，但供诚实化诊断用）。
+     * 取的是 **boot 快照**，不随本轮写入变化——开关开了但文件一直没生出来，
+     * 就是"无生产者"的历史现场，启动日志据此提 warning。
+     */
+    wasAbsentAtBoot(): boolean;
+    /**
+     * 该技能是否已收录过这条证据三元组 (skill, session, record)。
+     *
+     * 存在的必要：`appendEvidence` 是**纯追加**，而 `evidence` 数组触顶
+     * （`EVIDENCE_CAP`）时会 `splice` 掉最老的行。backfill 与增量轮次对同一证据
+     * 重复投，会把真实历史挤出去——所以投前必过这道门（producer 两条路径同源）。
+     *
+     * 为何是三元组而不是 (skill, record)：backfill 下一条历史记录可经
+     * `metadata.dsh_source_anchors` 映射到**多个**会话，按二元组去重会抹掉
+     * 第 2、3 个会话，而 distinct-session 正是晋升判据。
+     */
+    hasEvidence(skillId: string, sessionId: string, recordId: string): boolean;
+    /** 某技能的证据总条数（`minEvidence` 的度量；与 `sessionCount` 的 distinct 语义不同）。 */
+    evidenceCount(skillId: string): number;
     /** 某技能的 distinct session 计数（晋升判据的唯一来源，与 LLM 判断解耦）。 */
     sessionCount(skillId: string): number;
     /**

package/dist/store/skill-store.js

@@ -75,6 +75,7 @@ export class SkillStore {
     evidence = [];
     rev = 0;
     loaded = false;
+    fileAbsentAtBoot = false;
     degraded;
     degradedLogged = false;
     writeChain = Promise.resolve();
@@ -87,7 +88,9 @@ export class SkillStore {
         await ensureDir(path.dirname(this.file));
         const read = await readJsonStrict(this.file);
         if (!read.ok) {
-            if (read.reason !== 'missing') {
+            if (read.reason === 'missing')
+                this.fileAbsentAtBoot = true;
+            else {
                 this.degraded = `${read.reason}${'detail' in read && read.detail ? `: ${read.detail}` : ''}`;
                 this.logger?.warn(`[memory] 技能存储只读降级（内存态照常，停止回写）: ${this.degraded}`);
             }
@@ -221,6 +224,42 @@ export class SkillStore {
         await this.persist();
         return this.sessionCount(ev.skillId);
     }
+    /**
+     * 启动时 `skills.json` 是否不存在（缺文件是合法空表，但供诚实化诊断用）。
+     * 取的是 **boot 快照**，不随本轮写入变化——开关开了但文件一直没生出来，
+     * 就是"无生产者"的历史现场，启动日志据此提 warning。
+     */
+    wasAbsentAtBoot() {
+        return this.fileAbsentAtBoot;
+    }
+    /**
+     * 该技能是否已收录过这条证据三元组 (skill, session, record)。
+     *
+     * 存在的必要：`appendEvidence` 是**纯追加**，而 `evidence` 数组触顶
+     * （`EVIDENCE_CAP`）时会 `splice` 掉最老的行。backfill 与增量轮次对同一证据
+     * 重复投，会把真实历史挤出去——所以投前必过这道门（producer 两条路径同源）。
+     *
+     * 为何是三元组而不是 (skill, record)：backfill 下一条历史记录可经
+     * `metadata.dsh_source_anchors` 映射到**多个**会话，按二元组去重会抹掉
+     * 第 2、3 个会话，而 distinct-session 正是晋升判据。
+     */
+    hasEvidence(skillId, sessionId, recordId) {
+        this.ensureLoaded();
+        for (const e of this.evidence) {
+            if (e.skillId === skillId && e.sessionId === sessionId && e.recordId === recordId)
+                return true;
+        }
+        return false;
+    }
+    /** 某技能的证据总条数（`minEvidence` 的度量；与 `sessionCount` 的 distinct 语义不同）。 */
+    evidenceCount(skillId) {
+        this.ensureLoaded();
+        let n = 0;
+        for (const e of this.evidence)
+            if (e.skillId === skillId)
+                n++;
+        return n;
+    }
     /** 某技能的 distinct session 计数（晋升判据的唯一来源，与 LLM 判断解耦）。 */
     sessionCount(skillId) {
         this.ensureLoaded();

package/dist/store/sqlite.d.ts

@@ -220,6 +220,13 @@ export declare class MemoryDb {
      */
     clearL1(): boolean;
     countL1(): number;
+    /**
+     * 按类型计数（`idx_l1_type` 已建，索引级廉价查询，不拉正文）。
+     *
+     * 用途单一：技能面板要区分“池里根本没有 work_method 原料”与“有但未达阈”，
+     * 这两态的文案与处置动作完全不同，不能都用“暂无技能”糊过去。
+     */
+    countL1ByType(type: string): number;
     /**
      * 按外部导入幂等键查已存在记录 id(轨3-P0 幂等 pre-check)。
      * 空键/降级一律返回 undefined;未迁移旧库(无 ext_key 列)由 catch 兜底 undefined(fail-open)。

package/dist/store/sqlite.js

@@ -26,6 +26,7 @@ import { normApplicability } from '../repo-scope.js';
 import { normalizeWorkspacePath } from '../workspace.js';
 import { bm25RankToScore, buildFtsQuery, tokenizeForFts } from './search-utils.js';
 import { describeTokenizer, ensureTokenizer, tokenizerStamp } from '../util/tokenizer.js';
+import { clampPriority } from '../util/priority.js';
 const require = createRequire(import.meta.url);
 const TAG = '[memory][sqlite]';
 /**
@@ -992,7 +993,7 @@ export class MemoryDb {
         // 无法绑定(node:sqlite 拒绝绑定),曾致旧版导入逐条全挂、每次启动无限重试。
         // 主表与 FTS 两条语句共用同源归一化值;type 归一化后 familyForType 也不再收到 undefined。
         const type = record.type ?? '';
-        const priority = record.priority ?? 50;
+        const priority = clampPriority(record.priority, 50);
         const sceneName = record.scene_name ?? '';
         const family = record.family ?? familyForType(type);
         // §E 写入侧兜底归一,并维持一条**不变量**:`scope='global'` 的记录 `workspace_id` 恒为空串。
@@ -1272,6 +1273,23 @@ export class MemoryDb {
             return 0;
         }
     }
+    /**
+     * 按类型计数（`idx_l1_type` 已建，索引级廉价查询，不拉正文）。
+     *
+     * 用途单一：技能面板要区分“池里根本没有 work_method 原料”与“有但未达阈”，
+     * 这两态的文案与处置动作完全不同，不能都用“暂无技能”糊过去。
+     */
+    countL1ByType(type) {
+        if (this.degraded)
+            return 0;
+        try {
+            const row = this.db.prepare('SELECT COUNT(*) AS n FROM l1_records WHERE type = ?').get(type);
+            return row?.n ?? 0;
+        }
+        catch {
+            return 0;
+        }
+    }
     /**
      * 按外部导入幂等键查已存在记录 id(轨3-P0 幂等 pre-check)。
      * 空键/降级一律返回 undefined;未迁移旧库(无 ext_key 列)由 catch 兜底 undefined(fail-open)。

package/dist/util/priority.d.ts

@@ -0,0 +1,22 @@
+/**
+ * L1 记忆 priority 的归一单源（issue #19）。
+ *
+ * 存在理由：priority 是磁盘契约列，且被 memoryRecall 投影的 `viewSchema` 严格校验
+ * （`requireCounter` 判非负整数）。任一写入口把 LLM 回传的负数/超界/小数原样落库，
+ * 投影出网即抛 → 宿主把整会话包成 `SESSION_QUERY_CORRUPT_SESSION` → **一条脏数据
+ * 打死整个会话历史**。故所有喂进 `l1_records.priority` 的路径必须过同一夹取。
+ *
+ * 语义（用户选定）：非有限值→`fallback`；小数 `Math.round`；结果夹到整数 `[0,100]`。
+ * `fallback` 形参是为保留各写点既有的缺省差异（upsert 绑定层历史上用 50，抽取用 60），
+ * 避免为修范围而把某处的默认值静默漂移。
+ *
+ * 注意：**不动** `store/slots.ts` 里的同名私有 `clampPriority`（floor/50，服务 memorySlots
+ * 另一条链）；本文件只服务 L1 记忆 priority。
+ */
+export declare const PRIORITY_DEFAULT = 60;
+export declare const PRIORITY_MIN = 0;
+export declare const PRIORITY_MAX = 100;
+/** 夹取到 `[PRIORITY_MIN, PRIORITY_MAX]` 的整数；非有限值回落 `fallback`。 */
+export declare function clampPriority(value: unknown, fallback?: number): number;
+/** 是否会被夹取改变（负 / 超界 / 非整数 / 非有限 / 缺失）——供读侧判定要不要 warn。 */
+export declare function isDirtyPriority(value: unknown): boolean;

package/dist/util/priority.js

@@ -0,0 +1,36 @@
+/**
+ * L1 记忆 priority 的归一单源（issue #19）。
+ *
+ * 存在理由：priority 是磁盘契约列，且被 memoryRecall 投影的 `viewSchema` 严格校验
+ * （`requireCounter` 判非负整数）。任一写入口把 LLM 回传的负数/超界/小数原样落库，
+ * 投影出网即抛 → 宿主把整会话包成 `SESSION_QUERY_CORRUPT_SESSION` → **一条脏数据
+ * 打死整个会话历史**。故所有喂进 `l1_records.priority` 的路径必须过同一夹取。
+ *
+ * 语义（用户选定）：非有限值→`fallback`；小数 `Math.round`；结果夹到整数 `[0,100]`。
+ * `fallback` 形参是为保留各写点既有的缺省差异（upsert 绑定层历史上用 50，抽取用 60），
+ * 避免为修范围而把某处的默认值静默漂移。
+ *
+ * 注意：**不动** `store/slots.ts` 里的同名私有 `clampPriority`（floor/50，服务 memorySlots
+ * 另一条链）；本文件只服务 L1 记忆 priority。
+ */
+export const PRIORITY_DEFAULT = 60;
+export const PRIORITY_MIN = 0;
+export const PRIORITY_MAX = 100;
+/** 夹取到 `[PRIORITY_MIN, PRIORITY_MAX]` 的整数；非有限值回落 `fallback`。 */
+export function clampPriority(value, fallback = PRIORITY_DEFAULT) {
+    const sanitize = (x) => Math.max(PRIORITY_MIN, Math.min(PRIORITY_MAX, Math.round(x)));
+    // null/undefined 显式回落（Number(null) 得 0，若不当缺省处理会把旧 `?? 50` 漂移成 0）。
+    if (value === null || value === undefined)
+        return sanitize(fallback);
+    const n = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(n))
+        return sanitize(fallback);
+    return sanitize(n);
+}
+/** 是否会被夹取改变（负 / 超界 / 非整数 / 非有限 / 缺失）——供读侧判定要不要 warn。 */
+export function isDirtyPriority(value) {
+    if (value === null || value === undefined)
+        return true;
+    const n = typeof value === 'number' ? value : Number(value);
+    return !Number.isInteger(n) || n < PRIORITY_MIN || n > PRIORITY_MAX;
+}

package/dsh.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "dsh-prime-memory",
   "name": "dsh-prime-memory",
-  "version": "0.26.12",
+  "version": "0.26.14",
   "description": {
     "en": "Layered distilled memory plugin (L0 capture → L1 atomic memory → L2 scenes → L3 persona) with automatic recall injection before each model step.",
     "zh": "L0~L3 分层蒸馏记忆插件:自动捕获对话、抽取原子记忆、整合场景块、蒸馏核心画像,并在模型步骤前自动召回注入。"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-prime-memory",
-  "version": "0.26.12",
+  "version": "0.26.14",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public",