dsh-prime-memory 0.24.2 → 0.26.0

package/dist/pipeline/relabel.d.ts

@@ -5,9 +5,12 @@
  *    - Wing 合法性:metadata.hall 非空但不在词表(8 角 + general)→ 剥离非法值,转入 LLM 重标队列;
  *    - 认知 hall:按 type 静态映射(cognitive-hall.ts)可派生而 metadata.cogHall 缺失/不一致 → 补写修正;
  * 2. **LLM 重标定**(有界批,受 wing.enabled 门控):
- *    - 未打标 wing 的记录复用一键回填的标注器(labelWingChunk)补打;
+ *    - 未打标 wing 的记录复用一键回填的标注器(labelWingOne)补打;
  *    - 涌现标签(tags,Room 的前身):同一批记录由标注器顺带产出 1-3 个 slug 标签写 metadata.tags。
  *
+ * 形状约定(用户定):**按单元、串行、不合并** —— 一个请求只装一条记录
+ * (旧形状 20 条/请求,一次截断/空输出就带走整批)。
+ *
  * 安全边界与一键回填一致:LLM 失败只跳过当前块、原记录零改动;机械与 LLM 写回都有上限,防止单次跑飞。
  * 本阶段在反刍收尾(L2/L3 之后)执行,**任何失败不拖垮反刍整体**(只 warn + 计数)。
  */
@@ -38,27 +41,23 @@ export interface RelabelDeps {
     backend: MemoryBackend;
     logger: MemoryLogger;
 }
-/** 测试注入口:分别替换 wing 标注器与 tags 标注器(默认走真实 LLM 路径)。 */
+/** 测试注入口:分别替换 wing 标注器与 tags 标注器(默认走真实 LLM 路径)。
+ * 两个标注器都是**逐条**形状(一个请求一条):成功返回结果,失败返回 null。 */
 export interface RelabelOverrides {
-    wingLabeler?: (chunk: MemoryRecord[]) => Promise<Array<{
-        record: MemoryRecord;
-        wing: string;
-    }>>;
-    tagger?: (chunk: MemoryRecord[]) => Promise<Array<{
-        record: MemoryRecord;
-        tags: string[];
-    }>>;
+    wingLabeler?: (rec: MemoryRecord) => Promise<string | null>;
+    tagger?: (rec: MemoryRecord) => Promise<string[] | null>;
 }
 export interface RelabelOpts {
     /**
      * 批次进度回调(relabeling 阶段的 detail/子进度由此驱动)。
      *
      * 第 4 参 `label` 用于**区分机械段与 LLM 段**:机械巡检按 200 条/批推进,
-     * LLM 段按 20 条/批推进,两者粒度不同,面板必须能分辨(否则用户看到的是
+     * LLM 段**逐条**推进,两者粒度不同,面板必须能分辨(否则用户看到的是
      * 一个忽快忽慢的"重标定批次")。
      */
     progress?: (text: string, done: number, total: number, label?: string) => void;
-    /** LLM 段墙钟预算(毫秒);超时停止,剩余计入 deferred 留待下次反刍。默认 90s。 */
+    /** LLM 段墙钟预算(毫秒);超时停止,剩余计入 deferred 留待下次反刍。默认 180s（逐条形状下
+     *  约 60 条 × 2.6s 的余量）。 */
     timeBudgetMs?: number;
 }
 export declare function relabelPass(deps: RelabelDeps, overrides?: RelabelOverrides, opts?: RelabelOpts): Promise<RelabelStats>;

package/dist/pipeline/relabel.js

@@ -1,18 +1,16 @@
 import { cognitiveHallOf, COG_HALL_METADATA_KEY } from '../cognitive-hall.js';
 import { normWingEnabled } from '../config.js';
 import { WING_FALLBACK } from '../types.js';
-import { labelWingChunk, tagChunk } from '../wing-backfill.js';
+import { labelWingOne, tagOne } from '../wing-backfill.js';
 import { isWingId, normTags } from '../metadata-validators.js';
 import { yieldLoop } from '../util/yield.js';
 /** 机械写回上限(首次全量巡检可能上千条待补 cogHall;分次反刍消化,防单次跑飞)。 */
 const MECH_CAP = 800;
-/** LLM 重标定批上限(每块 20 条由标注器内部控制)。 */
+/** LLM 重标定批上限(本次最多处理多少条待重标记录)。 */
 const LLM_CAP = 60;
-/** LLM 批大小(一次调用判定的记录数;批次进度/预算/让位都以此为粒度)。 */
-const LLM_CHUNK = 20;
 export async function relabelPass(deps, overrides = {}, opts = {}) {
     const { ctx, cfg, backend, logger } = deps;
-    const timeBudgetMs = opts.timeBudgetMs ?? 90_000;
+    const timeBudgetMs = opts.timeBudgetMs ?? 180_000;
     const stats = {
         checked: 0,
         cogHallFixed: 0,
@@ -106,95 +104,85 @@ export async function relabelPass(deps, overrides = {}, opts = {}) {
         return stats;
     logger.info(`[memory] 反刍重标定:未打标/待重标 ${needWingIds.length} 条,本次 LLM 处理 ${batch.length} 条(候选 ${[...wingEnabled, WING_FALLBACK].join(' / ')})`);
     const wingLabeler = overrides.wingLabeler ??
-        ((chunk) => labelWingChunk(ctx, cfg, logger, chunk, [...wingEnabled, WING_FALLBACK].join(' / ')));
-    // ── LLM wing 重标定:20 条/批逐批推进,批间让位 + 墙钟预算 + 批次进度回显 ──
+        ((rec) => labelWingOne(ctx, cfg, logger, rec, [...wingEnabled, WING_FALLBACK].join(' / ')));
+    // ── LLM wing 重标定:逐条推进,条间让位 + 墙钟预算 + 条序进度回显 ──
     const startedAt = Date.now();
     const overBudget = () => Date.now() - startedAt > timeBudgetMs;
-    const chunks = [];
-    for (let i = 0; i < batch.length; i += LLM_CHUNK)
-        chunks.push(batch.slice(i, i + LLM_CHUNK));
     let doneCount = 0;
     const taggedPool = [];
-    for (let i = 0; i < chunks.length; i++) {
+    for (let i = 0; i < batch.length; i++) {
         if (overBudget()) {
             stats.deferred += batch.length - doneCount;
             opts.progress?.(`重标定:时间预算(${Math.round(timeBudgetMs / 1000)}s)用尽,剩余 ${batch.length - doneCount} 条留待下次反刍`, doneCount, batch.length);
             logger.info(`[memory] 反刍重标定:时间预算用尽,deferred ${stats.deferred} 条`);
             return stats;
         }
-        opts.progress?.(`重标定:LLM 补 wing 第 ${i + 1}/${chunks.length} 批(已完成 ${doneCount}/${batch.length} 条)`, doneCount, batch.length, '补 Wing');
-        let rows;
+        opts.progress?.(`重标定:LLM 补 wing 第 ${i + 1}/${batch.length} 条(已完成 ${doneCount}/${batch.length} 条)`, doneCount, batch.length, '补 Wing');
+        let wing;
         try {
-            rows = await wingLabeler(chunks[i]);
+            wing = await wingLabeler(batch[i]);
         }
         catch (err) {
-            // labelWingChunk 自身已兜底(不向调用方抛);能走到这里只可能是注入桩抛错。
+            // labelWingOne 自身已兜底(不向调用方抛);能走到这里只可能是注入桩抛错。
             // 即便如此也必须留痕——静默吞掉批次是本次「整批丢弃却无日志」的直接教训。
-            stats.llmSkipped += chunks[i].length;
-            doneCount += chunks[i].length;
-            logger.warn(`[memory] 重标定第 ${i + 1}/${chunks.length} 批标注器抛错,跳过 ${chunks[i].length} 条: ${err instanceof Error ? err.message : String(err)}`);
+            stats.llmSkipped++;
+            doneCount++;
+            logger.warn(`[memory] 重标定第 ${i + 1}/${batch.length} 条标注器抛错,跳过: ${err instanceof Error ? err.message : String(err)}`);
             continue;
         }
-        const dropped = chunks[i].length - rows.length;
-        if (dropped > 0) {
-            logger.warn(`[memory] 重标定第 ${i + 1}/${chunks.length} 批丢弃 ${dropped} 条(详见上方 wing 回填日志)`);
+        if (wing === null) {
+            // 标注器已 warn(字段缺失/非法值/单条失败),这里只记账。
+            stats.llmSkipped++;
+            doneCount++;
+            continue;
         }
-        stats.llmSkipped += dropped;
-        stats.wingLabeled += rows.length;
         // 写前重读:机械阶段可能已写过 cogHall,标注器持有旧副本——以库内最新为基线合并
-        const freshRows = await backend.getByIds(rows.map(({ record }) => record.id));
-        const freshById = new Map(freshRows.map((r) => [r.id, r]));
-        for (const { record, wing } of rows) {
-            const current = freshById.get(record.id) ?? record;
-            const meta = { ...(current.metadata ?? {}) };
-            meta.hall = wing;
-            try {
-                await backend.patchMetadata(current.id, meta);
-                taggedPool.push(current);
-            }
-            catch {
-                stats.wingLabeled--;
-                stats.llmSkipped++;
-            }
-            await yieldLoop();
+        const [fresh] = await backend.getByIds([batch[i].id]);
+        const current = fresh ?? batch[i];
+        const meta = { ...(current.metadata ?? {}) };
+        meta.hall = wing;
+        try {
+            await backend.patchMetadata(current.id, meta);
+            stats.wingLabeled++;
+            taggedPool.push(current);
+        }
+        catch {
+            stats.llmSkipped++;
         }
-        doneCount += chunks[i].length;
+        doneCount++;
+        await yieldLoop();
     }
-    // ── 涌现标签(tags,Room 前身):同批有界 40 条,同样分批 + 预算 + 进度 ──
+    // ── 涌现标签(tags,Room 前身):同批有界 40 条,同样逐条 + 预算 + 进度 ──
     const tagBatch = taggedPool.slice(0, 40);
-    const tagger = overrides.tagger ?? ((chunk) => tagChunk(ctx, cfg, logger, chunk));
-    const tagChunks = [];
-    for (let i = 0; i < tagBatch.length; i += LLM_CHUNK)
-        tagChunks.push(tagBatch.slice(i, i + LLM_CHUNK));
-    for (let i = 0; i < tagChunks.length; i++) {
+    const tagger = overrides.tagger ?? ((rec) => tagOne(ctx, cfg, logger, rec));
+    for (let i = 0; i < tagBatch.length; i++) {
         if (overBudget())
             break;
-        opts.progress?.(`重标定:提炼涌现标签 第 ${i + 1}/${tagChunks.length} 批`, doneCount, batch.length, '提炼标签');
-        let tagRows;
+        opts.progress?.(`重标定:提炼涌现标签 第 ${i + 1}/${tagBatch.length} 条`, doneCount, batch.length, '提炼标签');
+        let rawTags;
         try {
-            tagRows = await tagger(tagChunks[i]);
+            rawTags = await tagger(tagBatch[i]);
         }
         catch (err) {
-            logger.warn(`[memory] 重标定 tags 第 ${i + 1}/${tagChunks.length} 批标注器抛错,跳过 ${tagChunks[i].length} 条: ${err instanceof Error ? err.message : String(err)}`);
+            logger.warn(`[memory] 重标定 tags 第 ${i + 1}/${tagBatch.length} 条标注器抛错,跳过: ${err instanceof Error ? err.message : String(err)}`);
             continue;
         }
-        const freshTagRows = await backend.getByIds(tagRows.map(({ record }) => record.id));
-        const freshForTags = new Map(freshTagRows.map((r) => [r.id, r]));
-        for (const { record, tags: rawTags } of tagRows) {
-            const tags = normTags(rawTags); // 归一+校验在写回点强制:无论标签来自真实 LLM 还是注入桩
-            if (tags.length === 0)
-                continue;
-            const current = freshForTags.get(record.id) ?? record;
-            const meta = { ...(current.metadata ?? {}) };
-            meta.tags = tags;
-            try {
-                await backend.patchMetadata(current.id, meta);
-                stats.tagged++;
-                await yieldLoop();
-            }
-            catch {
-                /* 标签写失败不影响主流程 */
-            }
+        if (!rawTags)
+            continue;
+        const tags = normTags(rawTags); // 归一+校验在写回点强制:无论标签来自真实 LLM 还是注入桩
+        if (tags.length === 0)
+            continue;
+        const [fresh] = await backend.getByIds([tagBatch[i].id]);
+        const current = fresh ?? tagBatch[i];
+        const meta = { ...(current.metadata ?? {}) };
+        meta.tags = tags;
+        try {
+            await backend.patchMetadata(current.id, meta);
+            stats.tagged++;
+            await yieldLoop();
+        }
+        catch {
+            /* 标签写失败不影响主流程 */
         }
     }
     return stats;

package/dist/pipeline/runner.js

@@ -121,17 +121,40 @@ export function effectiveCfg(cfg, live) {
     const cfOverride = s?.conflictFreeze !== undefined
         ? { conflictFreeze: { ...(cfg.conflictFreeze ?? {}), enabled: s.conflictFreeze } }
         : null;
+    // 存量回填/进阶功能启用开关：live 与部署 cfg.<x>.enabled 取或（部署强制开、live 追加开，
+    // 任一为真即放行）。关关关时保持逐字 false（零漂移不破）。
+    const kwOverride = s?.keywordEnabled !== undefined
+        ? { keyword: { ...(cfg.keyword ?? {}), enabled: cfg.keyword?.enabled === true || s.keywordEnabled === true } }
+        : null;
+    const rdOverride = s?.redistillEnabled !== undefined
+        ? { redistill: { ...(cfg.redistill ?? {}), enabled: cfg.redistill?.enabled === true || s.redistillEnabled === true } }
+        : null;
+    const mdsOverride = s?.mdSyncEnabled !== undefined
+        ? { mdSync: { ...(cfg.mdSync ?? {}), enabled: cfg.mdSync?.enabled === true || s.mdSyncEnabled === true } }
+        : null;
+    const mpOverride = s?.memportEnabled !== undefined
+        ? { memport: { ...(cfg.memport ?? {}), enabled: cfg.memport?.enabled === true || s.memportEnabled === true } }
+        : null;
     // md 投射/后缀收敛的单次动作护栏运行时覆盖(0 = 跟随部署 cfg.memExport.maxRecords)。
     // 只覆盖条数护栏，不动 enabled/root——开关与根路径仍属部署配置。
     const mdx = s?.mdExportMaxRecords ?? 0;
     const memExportOverride = mdx > 0 ? { memExport: { ...(cfg.memExport ?? {}), maxRecords: mdx } } : null;
-    if (!override && !budgets && !maxInput && !fallbacksTakeover && !chainEffort && !chainFallbacks && !effortInject && !layerChains && !hasChannel && !embedOverride && !cfOverride && !memExportOverride)
+    // 回填并行度运行时覆盖(0 = 跟随部署 cfg.backfill.concurrency)：只改并发度，
+    // 不动 maxRecords/timeBudgetMs/callTimeoutMs——那三个仍属部署护栏，要改得改 YAML。
+    const bf = s?.backfillConcurrency ?? 0;
+    const backfillOverride = bf > 0 ? { backfill: { ...(cfg.backfill ?? {}), concurrency: bf } } : null;
+    if (!override && !budgets && !maxInput && !fallbacksTakeover && !chainEffort && !chainFallbacks && !effortInject && !layerChains && !hasChannel && !embedOverride && !cfOverride && !memExportOverride && !backfillOverride && !kwOverride && !rdOverride && !mdsOverride && !mpOverride)
         return cfg;
     return {
         ...cfg,
         ...(embedOverride ?? {}),
         ...(cfOverride ?? {}),
+        ...(kwOverride ?? {}),
+        ...(rdOverride ?? {}),
+        ...(mdsOverride ?? {}),
+        ...(mpOverride ?? {}),
         ...(memExportOverride ?? {}),
+        ...(backfillOverride ?? {}),
         llm: {
             ...cfg.llm,
             ...(effortInject ?? {}),

package/dist/projection/recall.d.ts

@@ -92,9 +92,10 @@ export declare const stateSchema: SchemaLike<RecallProjectionState>;
 /** view 校验（出网前调用；未知键容忍，同 slots 投影的语义边界）。 */
 export declare const viewSchema: SchemaLike<RecallView>;
 /** 投影需要的 L1 只读面（结构化声明，避免跨模块类型耦合）。
- *  判退场要 `validTo`/`metadata`，故直接 Pick 自 MemoryRecord，不在投影里自写时间比较。 */
+ *  判退场要 `validTo`/`metadata`，故直接 Pick 自 MemoryRecord，不在投影里自写时间比较。
+ *  `name` 是名称蒸馏产出的短标题，优先作为展示标题。 */
 export interface RecallL1Face {
-    getByIds(ids: string[]): Array<Pick<MemoryRecord, 'id' | 'type' | 'content' | 'priority' | 'metadata' | 'validTo'>>;
+    getByIds(ids: string[]): Array<Pick<MemoryRecord, 'id' | 'type' | 'content' | 'priority' | 'metadata' | 'validTo' | 'name'>>;
 }
 /** 投影需要的反馈只读面（缺席 = view 不带 rating，旧行为）。 */
 export interface RecallFeedbackFace {

package/dist/projection/recall.js

@@ -77,11 +77,32 @@ export const viewSchema = {
         return value;
     },
 };
-/** 正文首行 → 标题（投影内不引 client 的 format 工具，保持服务端自足）。 */
+/**
+ * 正文首行 → 标题（投影内不引 client 的 format 工具，保持服务端自足）。
+ * 按 markdown 语义解析：
+ * - H1（`# xxx`）是文档标题，直接作为记忆名称；
+ * - H2+（`## xxx`）是正文分节标记，跳过它取第一个实质文本行。
+ * 全部行都是 heading 时回落到第一个非空行。
+ */
 function firstLine(content) {
-    const line = content.split('\n').find((l) => l.trim().length > 0) ?? content;
-    const trimmed = line.trim();
-    return trimmed.length > TITLE_MAX ? trimmed.slice(0, TITLE_MAX) : trimmed;
+    const lines = content.split('\n');
+    // 优先取 H1（文档级标题）
+    const h1 = lines.find((l) => /^#\s/.test(l.trim()));
+    if (h1)
+        return clampTitle(h1.trim());
+    // 无 H1 时跳过 H2+ 分节 heading，取第一个实质文本行
+    const body = lines.find((l) => {
+        const t = l.trim();
+        return t.length > 0 && !/^#{2,6}\s/.test(t);
+    });
+    if (body)
+        return clampTitle(body.trim());
+    // 全是 heading 的极端情况：回落第一个非空行
+    const fallback = lines.find((l) => l.trim().length > 0) ?? content;
+    return clampTitle(fallback.trim());
+}
+function clampTitle(s) {
+    return s.length > TITLE_MAX ? s.slice(0, TITLE_MAX) : s;
 }
 /** 正文全文 → 泡泡用（去首尾空白，超长截断补省略号）。 */
 function clampBody(content) {
@@ -132,7 +153,7 @@ function makeView(state, l1, feedback) {
         items.push({
             id: r.id,
             type: r.type,
-            title: firstLine(r.content),
+            title: r.name || firstLine(r.content),
             priority: r.priority,
             body: clampBody(r.content),
             ...(scenario !== undefined && scenario.length > 0 ? { scenario } : {}),

package/dist/projection/slots.d.ts

@@ -36,6 +36,15 @@ export interface SlotsViewSlot {
 export interface SlotRefView {
     ref: string;
     title: string;
+    /**
+     * 记忆文件相对路径（`<type>/<name>.memory.md`）。
+     * 拼接绝对地址：
+     * - 有 workspaceId → `<workspaceId>/.agents/memory/<filePath>`
+     * - 无 workspaceId → `<memoriesRoot>/<filePath>`（由消费方自行解析根目录）
+     */
+    filePath?: string;
+    /** 记忆归属的工作区绝对路径；空串/undefined = global（无 workspace）。 */
+    workspaceId?: string;
 }
 export interface SlotsProjectionState {
     rev: number;
@@ -76,6 +85,8 @@ export interface L1LookupFace {
         id: string;
         content: string;
         type: string;
+        name?: string;
+        workspaceId?: string;
     }>;
 }
 export declare function registerSlotsProjection(ctx: Context, store: SlotStore, l1?: L1LookupFace): void;

package/dist/projection/slots.js

@@ -1,4 +1,5 @@
 import { SLOT_KINDS, SLOT_STATUSES } from '../store/slots.js';
+import { relPathFor } from '../store/memory-md.js';
 export const MEMORY_SLOTS_KEY = 'memorySlots';
 function invalid(what, detail) {
     throw new Error(`${what}: ${detail}`);
@@ -100,9 +101,18 @@ function resolveRefViewsUnsafe(recordRefs, l1) {
         const record = byId.get(ref);
         if (record === undefined)
             continue;
-        const firstLine = record.content.split('\n', 1)[0] ?? '';
-        const summary = firstLine.length > REF_TITLE_MAX ? firstLine.slice(0, REF_TITLE_MAX) + '…' : firstLine;
-        views.push({ ref, title: '[' + record.type + '] ' + summary });
+        // 优先用 name 字段（名称蒸馏产出的短标题），无 name 时回落 content 首行截断。
+        const raw = record.name || (record.content.split('\n', 1)[0] ?? '');
+        const summary = raw.length > REF_TITLE_MAX ? raw.slice(0, REF_TITLE_MAX) + '…' : raw;
+        // 投射相对路径走单一事实源 `relPathFor`，与写盘/records-meta 端点同算法。
+        const filePath = relPathFor(record);
+        const ws = (record.workspaceId ?? '').trim();
+        views.push({
+            ref,
+            title: '[' + record.type + '] ' + summary,
+            filePath,
+            ...(ws.length > 0 ? { workspaceId: ws } : {}),
+        });
     }
     return views.length > 0 ? views : undefined;
 }

package/dist/redistill-backfill.d.ts

@@ -0,0 +1,133 @@
+/**
+ * 存量记忆重蒸馏整形回填（redistill）。
+ *
+ * 职责：对**活跃**且 `scoreSkeleton` 判「骨架不齐备」的 L1 记录，**一条一个请求**送 LLM
+ * 把正文重排成 G2 分类型的 `## 节名` 分节骨架，并顺带产 `dsh_keywords` / `dsh_usage_scenario`；
+ * 只有**整形后骨架分严格更优且无空心标题**才写回（并盖当前整形版本戳），否则留原文**不打标记**——
+ * 下轮仍可再试（用户定：「成功替换的」才不再进入重蒸馏）。
+ *
+ * 与 keyword-backfill 的关键差异（为什么它更重一档）：
+ * - **改 content** ⇒ 写回必须走 `L1Store.appendNew`（追加 JSONL 事实源 + upsertL1 重嵌+FTS +
+ *   fireFileSync 重导出），**不能**走 `MemoryBackend.patchMetadata*`（只改元数据、不动正文），
+ *   也**不能**走 worker backend（`memory-backend.ts` 明示 upsert 会重嵌、worker 拿不到
+ *   embedding service 会写零向量毁数据）。故本模块 deps 直取 `l1: L1Store`（进程内）。
+ * - **入口 `vectorsReady()` 守卫**：`upsertL1InTx` 先删向量行、仅非零 embedding 才插回；
+ *   embed 未就绪时改正文会静默丢该记录向量。故向量未就绪 ⇒ 整轮回跳过（整形是可选优化，不抢这个险）。
+ *
+ * 安全边界（继承 keyword/wing 回填）：
+ * - 单飞：同时最多一个任务，重复触发返回 running（不排队不叠加）
+ * - 后台执行：端点立即返回，逐条推进并**每条即时提交**，不阻塞 RPC/管线
+ * - 失败可退：LLM 失败/输出非法/质量闸不过 ⇒ 原记录零改动（写回只发生在严格更优且 embed 就绪时）
+ * - 有界：单次最多 cfg.backfill.maxRecords 条 + timeBudgetMs 墙钟；其余计入 deferred 可再触发
+ * - 排除靠**版本戳**：成功写回盖 `dsh_reshape_ver = RESHAPE_SCHEMA_VERSION`；扫描只排「当前版本
+ *   已整过」的（存量兼容：只有旧布尔 `dsh_reshape_tried` 且正文确为 `## 分节`式也算已整）。
+ *   整形规则/提示词改变时把 `RESHAPE_SCHEMA_VERSION` 递增，旧产物即自动重新入列。
+ * - 门控关（`cfg.redistill.enabled = false`）：入口立即跳过——不动 content、FTS、投射逐字不变
+ *
+ * 形状约定（用户定）：**按单元、串行、不合并**——一个请求只装一条记忆，跑完一条再发下一条。
+ * 扫描期就用 SQL 退场判据 + 骨架判据筛出真目标（旧实现收 1221 条候选、每批 20 条只命中 ~4 条）。
+ * `cfg.backfill.concurrency` 默认 1（串行）；拖高概览页滑块可临时多路在飞（上限 8）。
+ * 注意：本任务直接调 `callLLM`、不进 runner 队列，拿不到“live 优先”的让位保护。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { L1Store } from './store/l1.js';
+import type { MemoryConfig } from './config.js';
+import type { MemoryLogger, MemoryRecord } from './types.js';
+/**
+ * 整形**版本戳**：只在**成功替换**时写入，值为当前整形规则版本（`RESHAPE_SCHEMA_VERSION`）。
+ * 扫描阶段据此排除「已按当前规则整过形」的记录——见 `isReshapedAtCurrentVersion`。
+ */
+export declare const RESHAPE_VER_KEY = "dsh_reshape_ver";
+/**
+ * 当前整形规则版本。**改动整形骨架/提示词/输出契约时必须 +1**，否则旧产物不会重跑。
+ * v1 = 行内标签式（`规则：/触发时机：`，已废）；v2 = `## 节名` 分节 + 空心标题闸。
+ */
+export declare const RESHAPE_SCHEMA_VERSION = 2;
+export interface RedistillBackfillDeps {
+    ctx: Context;
+    cfg: MemoryConfig;
+    /** 直取 L1Store（进程内）：改 content 要 appendNew 重嵌 + 追加 JSONL + 投射点火，不经 worker backend。 */
+    l1: L1Store;
+    logger: MemoryLogger;
+    /**
+     * 运行时**生效并发**读取器（可选）：给正在跑的任务即时改并发用——池子每完成一条重读一次。
+     * 缺省 = 启动时读一次 `cfg.backfill.concurrency`（旧行为）。
+     */
+    concurrency?: () => number | undefined;
+}
+export interface RedistillBackfillState {
+    running: boolean;
+    /** 整形成功写回条数。 */
+    updated: number;
+    /** 质量闸判不写（留原文）条数。 */
+    skipped: number;
+    /** 失败/跳过（LLM 失败、id 配不上、embed 掉线）条数。 */
+    failed: number;
+    /** 分批进度（UI 轮询据此显示「扫描中 / 第几条」，否则运行期只有一个「整形中…」）： */
+    /** 每个请求处理的条数——本任务已改成逐条，永远为 1（保留字段与 keyword 同形状）。 */
+    chunk: number;
+    /** 扫描阶段确定的**真目标**总数（骨架不齐备且未试过；扫描未完成时为已发现数）。 */
+    candidates: number;
+    /** 本次已完成（送过 LLM 且已提交结果）条数。**在请求完成时才自增**——
+     *  在开始处加会让“全部超时失败”跟“全部成功”长得一模一样。 */
+    processed: number;
+    /** 仍在扫描阶段（此阶段 candidates 还在动，UI 应报「扫描中」而非「第 N 条」）。 */
+    scanning: boolean;
+    /** 已完成条数（与 processed 同值，保留为与 keyword 共用的进度形状）。 */
+    batchesDone: number;
+    /** 本次要处理的总条数。 */
+    batchTotal: number;
+    /** LLM 批调用并行度。 */
+    concurrency: number;
+    /** 预算/上限用尽未处理、留下次的条数。 */
+    deferred: number;
+}
+export declare function redistillBackfillState(): RedistillBackfillState;
+/**
+ * 空心标题检测：某个 `## 节名` 到下一标题之间没有实质文字。
+ *
+ * 为什么需要它：判定器（`scoreSkeleton`）按子串命中认骨架，而标题词本身就是那个子串——
+ * 只写 `## 触发时机` 不写内容就能白得一个命中。不堵这个闸，“加分才写回”会退化成
+ * “加空标题就写回”，正文反而被掏空了。
+ */
+export declare function hasHollowHeading(content: string): boolean;
+/** 质量闸：整形后骨架命中数严格上升（或旧不齐备且新齐备）且正文非空、无空心标题 → 判可写。 */
+export declare function reshapePassesGate(type: string, oldContent: string, newContent: string): boolean;
+/**
+ * 是否已按**当前版本**整理过 → 扫描阶段排除（用户定：「成功替换的」才不再进入）。
+ *
+ * 判据：
+ * - 带当前版本戳（`dsh_reshape_ver === RESHAPE_SCHEMA_VERSION`）⇒ 已成功替换，排除；
+ * - 旧存量兼容：只有布尔 `dsh_reshape_tried`（成功与留原文都打过，无法区分）+ 正文确实是
+ *   `## 分节`式 ⇒ 视为已整形排除；**不带标题的则重新入列**（它们是「试过但没改成」的，
+ *   或首轮行内标签式产物，都该重跑）。
+ */
+export declare function isReshapedAtCurrentVersion(meta: Record<string, unknown> | undefined, content: string): boolean;
+/** 启动后台重蒸馏回填；已在运行返回 false（单飞）。 */
+export declare function startRedistillBackfill(deps: RedistillBackfillDeps): {
+    started: boolean;
+    running: boolean;
+};
+/**
+ * 回填主体（导出供单测 await 到完成；生产走 `startRedistillBackfill` 的单飞后台包装）。
+ * 门控关或向量未就绪 ⇒ 入口即返回，不碰任何记录、FTS、投射。
+ *
+ * 阶段划分对齐反刍重标定（`pipeline/relabel.ts`）：**机械扫描期把筛子下推到底**，
+ * LLM 期只吃真目标、逐条推进、**每条即时提交**、条间受墙钟预算约束。
+ * 形状约定（用户定）：**按单元、串行、不合并**——`concurrency` 默认 1（跑完一条再发下一条），
+ * 拖高概览页滑块只是临时提速。旧形状（20 条一批）真机把单请求拖到 200s+ 并在超时线上被掐。
+ */
+export declare function runRedistillBackfillOnce(deps: RedistillBackfillDeps): Promise<void>;
+/** 单条整形结果。 */
+export interface ReshapeOneResult {
+    content: string;
+    keywords: string[];
+    usageScenario: string[];
+}
+/**
+ * 整形**一条**记忆（一个请求只装一条）。失败/输出非法返回 null（原记录不动）。
+ *
+ * 导出不带 ctx/cfg 以外的参数，供单测注入桩 LLM。旧名 `reshapeChunk`（多条一次）已废：
+ * 合并请求把爆炸半径从 1 条放大到 20 条，而实测逐条只花 2.6s，合并毫无收益。
+ */
+export declare function reshapeOne(ctx: Context, cfg: MemoryConfig, logger: MemoryLogger, rec: MemoryRecord, callTimeoutMs?: number): Promise<ReshapeOneResult | null>;