dsh-prime-memory 0.25.0 → 0.26.0

package/dist/config.d.ts

@@ -123,12 +123,31 @@ export interface MemoryConfig {
         /** active 技能闲置多少天后自动归档（0 = 不做闲置归档）。 */
         idleArchiveDays: number;
     };
-    /** wing 存量回填护栏（默认 300 条/120s；想一次多跑点可调大，代价是后台占用更久）。 */
+    /**
+     * 存量回填护栏（wing / keyword / redistill 共用，默认 300 条 / 30min 总预算 / 串行 / 单条请求 240s）。
+     *
+     * 形状约定（用户定）：**按单元、串行、不合并**——一个请求只装一条记忆，跑完一条再发下一条。
+     * 实测单条 35B 只要 ~2.6s，而 20 条合并成一批要 200s+ 且一次空输出/截断就带走整批，
+     * 所以“批量”在这里不省时间只堆风险。`concurrency` 默认 1；拖高概览页滑块可临时多路在飞。
+     *
+     * 三个旋钮分工（别混淆）：
+     * - `maxRecords` = **一轮最多处理多少条**（防一次点击拖过久；真实队列没跑完的计入 deferred，
+     *   再点一次继续）。注意它**不是**请求批大小：逐条形状下每个请求只装 1 条。
+     * - `timeBudgetMs` = **本轮总墙钟预算**（防跑飞）。与 maxRecords 谁先到谁生效：
+     *   默认 300 条 × ~2.6s ≈ 13min < 30min，正常由 maxRecords 先结算。
+     * - `callTimeoutMs` = **一次 `callLLM`（含整条回退链）**的超时。不能沿用 `llm.timeoutMs`（120s）：
+     *   它是**整次调用**的预算而非每条路由各享一份——真机踩到主路由（9B）空输出吃 95s，
+     *   降到 35B 后只剩余量在线上被掐死（看似“35B 也跑不完”）。默认 240s 按「路由数 × 单路由耗时」留余量。
+     */
     backfill: {
         /** 单次回填处理条数上限。 */
         maxRecords: number;
-        /** 单次回填墙钟预算(ms)，超时剩留待再次触发。 */
+        /** 单次回填总墙钟预算(ms)，超时剩留待再次触发。 */
         timeBudgetMs: number;
+        /** LLM 批调用的并行度(1 = 串行)。 */
+        concurrency: number;
+        /** 一次 LLM 调用（含整条回退链）的超时(ms)，比对话蒸馏的 llm.timeoutMs 宽；按路由数留余量。 */
+        callTimeoutMs: number;
     };
     /**
      * 内容路由（workspace 归属）：按「这条记忆**谈到**哪个项目」给记录补 `workspace_id`。
@@ -205,6 +224,20 @@ export interface MemoryConfig {
     keyword: {
         enabled: boolean;
     };
+    /**
+     * 存量记忆重蒸馏整形（redistill）：**独立回填批扫**，把活跃且 `scoreSkeleton` 判「骨架不齐备」
+     * 的 L1 正文按 G2 分类型骨架重排，并顺带产 `dsh_keywords` / `dsh_usage_scenario`。由
+     * `dsh-memory/redistill-backfill` 端点触发，镜像 keyword/wing 回填（单飞/后台/有界）。
+     *
+     * **默认关**：关时不整形、content/FTS/投射逐字不变（零漂移）。护栏复用 `backfill`。
+     * 与 keyword 回填的关键差异：本项**改 content**，写回走 `L1Store.appendNew`（追加 JSONL 事实源
+     * + 重嵌 + FTS + 投射点火），且入口要求 `vectorsReady()`（embed 未就绪时改正文会静默丢向量）。
+     * 只有整形后骨架分严格更优才写回，并盖整形版本戳（`dsh_reshape_ver`）；未过闸的留原文**不打标记**，
+     * 下轮仍可再试——即只有「成功替换的」不再进入。
+     */
+    redistill: {
+        enabled: boolean;
+    };
     /**
      * 类型叙述模板（G2）：抽取时按 7 类型各自的“前因后果”骨架写 content。
      *

package/dist/config.js

@@ -80,6 +80,22 @@ export function liveSettingsSchema() {
         conflictFreeze: Schema.boolean().default(false),
         // 轨2 技能结晶总开关(看板可拨):默认 false。开=注册 memory_skill_* 工具 + 注入 active 技能 + skills-* 端点可用。
         skillsEnabled: Schema.boolean().default(false),
+        // 存量回填/进阶功能的启用开关（概览「存量回填与整形」区可拨）：默认 false，
+        // 与部署 cfg.<x>.enabled 取或（经 effectiveCfg）——部署可强制开，live 只能追加开。
+        // 存在的理由：这些面都有对应按钮/端点，若开关只住 YAML，用户点了只会报“未开启”却没处翻。
+        keywordEnabled: Schema.boolean().default(false),
+        redistillEnabled: Schema.boolean().default(false),
+        mdSyncEnabled: Schema.boolean().default(false),
+        memportEnabled: Schema.boolean().default(false),
+        /**
+         * 存量回填（keyword / redistill）LLM 批调用的**运行时并行度**覆盖：
+         * `0` = 跟随部署 `cfg.backfill.concurrency`；1–8 = 直接覆盖。
+         *
+         * 为什么要是 live 而不是只住 YAML：真机出过“3 并发把每请求拖过超时线、13 批全 abort”，
+         * 排查时需要的恰好是“立刻降到 1 串行再看一遍”——为此改 YAML + 重启不现实。
+         * 概览页 0–8 滑块写的就是它（0 = 跟随部署，默认部署值是 1 串行）。
+         */
+        backfillConcurrency: Schema.number().min(0).max(8).default(0),
         // 工具分组封印(v0.21.0):false = 该组工具不注册,从模型工具列表消失。
         // 核心读(memory_search/read_scene/receipts/conversation_search)与槽位三件不受控。
         toolRoom: Schema.boolean().default(true),
@@ -164,10 +180,14 @@ export const memorySchema = Schema.object({
         excerptChars: Schema.number().min(0).max(4000).default(240),
         idleArchiveDays: Schema.number().min(0).max(3650).default(90),
     }),
-    // wing 回填护栏：默认与旧行为一致(300 条 / 120s)，需一次多跑点时调大。
+    // wing/keyword/redistill 回填护栏。maxRecords 是“一轮处理多少条”，timeBudgetMs 是“本轮不跑飞”，
+    // callTimeoutMs 是“单次请求（含回退链）不撞线”；逐条形状下每请求只装 1 条（不是 20 条一批）。
+    // maxRecords 不得低于真实队列量级：真机活跃集里待整形真目标 251 条，砍到 40 就等于“点一次只动 40”。
     backfill: Schema.object({
         maxRecords: Schema.number().min(1).max(10_000).default(300),
-        timeBudgetMs: Schema.number().min(1000).max(1_800_000).default(120_000),
+        timeBudgetMs: Schema.number().min(1000).max(1_800_000).default(1_800_000),
+        concurrency: Schema.number().min(1).max(8).default(1),
+        callTimeoutMs: Schema.number().min(1000).max(1_800_000).default(240_000),
     }),
     /**
      * 内容路由：默认**开**（用户口径：谈到本仓/dsh 生态的记忆要归到本仓 workspace，
@@ -230,6 +250,10 @@ export const memorySchema = Schema.object({
     keyword: Schema.object({
         enabled: Schema.boolean().default(false),
     }),
+    // 存量记忆重蒸馏整形：默认关（关时不整形、content/FTS/投射逐字不变）；护栏复用 backfill。
+    redistill: Schema.object({
+        enabled: Schema.boolean().default(false),
+    }),
     // 类型叙述模板（G2）：默认**开**；开时抽取 prompt 追加分类型 content 骨架（关时仍逐字不变）。
     // 默认值从关改开的理由写在上方接口注释：只给定义实测骨架齐备 0/23，
     // 而"没前因后果就不算可用"是用户定的判据，所以默认值要按可用性定而不是按保守定。

package/dist/contract.d.ts

@@ -106,9 +106,20 @@ export interface MemoryLiveSettings {
     /** 轨2 技能结晶总开关（看板可拨）:true = 注册 memory_skill_* 工具、注入 active 技能、skills-* 端点可用。
      *  默认 false（新功能默认关）；与部署 cfg.skills.enabled 取或（任一开则生效）。 */
     skillsEnabled: boolean;
+    /** 关键词回填启用开关（概览区可拨）:true = 放行 dsh-memory/keyword-backfill。与部署 cfg.keyword.enabled 取或。 */
+    keywordEnabled: boolean;
+    /** 重蒸馏整形启用开关（概览区可拨）:true = 放行 dsh-memory/redistill-backfill。与部署 cfg.redistill.enabled 取或。 */
+    redistillEnabled: boolean;
+    /** md 反向同步启用开关（概览区可拨）:true = 放行 md-sync 回灌。与部署 cfg.mdSync.enabled 取或。 */
+    mdSyncEnabled: boolean;
+    /** 外部记忆来源 Connect 启用开关（概览区可拨）:true = 放行 memport-* 端点。与部署 cfg.memport.enabled 取或。 */
+    memportEnabled: boolean;
     /** md 投射/后缀收敛的单次动作护栏运行时覆盖:0 = 跟随部署 `cfg.memExport.maxRecords`（默认 2000）。
      *  存在的理由：一次点完多少条属于“回填历史时才改一下”的旋钮，不该要求改 YAML + 重启。 */
     mdExportMaxRecords: number;
+    /** 存量回填（keyword/redistill）LLM 批调用的运行时并行度覆盖：0 = 跟随部署
+     *  `cfg.backfill.concurrency`（默认 2）；1–8 = 直接覆盖。概览页 1–3 滑块写的就是它。 */
+    backfillConcurrency: number;
 }
 /** 召回停用原因(session-stats recall.enabled=false 时带出;短路序第一个为假的因子)。 */
 export type RecallDisabledReason = 'deploy' | 'global' | 'session' | 'mode';
@@ -641,12 +652,39 @@ export interface RoomAdminResponse {
     /** retire withRecords 实际退场的记录条数(软删,可恢复)。 */
     retiredRecords?: number;
 }
+/**
+ * 回填端点(wing/keyword/redistill)的请求体。三者都同时是「触发器 + 状态查询」：
+ * - `probe` 缺省/false：空闲时**启动**一轮；已在跑则只回状态(单飞)。
+ * - `probe: true`：**只读快照**,绝不启动——供 UI 离开区域再回来时恢复在途任务的进度
+ *   (否则计时器随组件卸载而清,回到页面只能看到卡住的最后一帧)。
+ */
+export interface BackfillTriggerRequest {
+    probe?: boolean;
+}
 /** dsh-memory/wing-backfill(一键回填,后台任务;端点立即返回,进度以 wing-overview 轮询)。 */
 export interface WingBackfillResponse {
     /** true = 本次触发启动了新任务;false = 已有任务在跑(单飞,不叠加)。 */
     started: boolean;
     running: boolean;
 }
+/** 回填批扫的逐条进度（keyword/redistill 共用）：后台任务一轮可达几分钟，没有它 UI 只能转圈圈。 */
+export interface BackfillProgress {
+    /** 每个请求处理的条数（两个回填都已改成逐条 = 1；保留字段供未来批量形状复用）。 */
+    chunk: number;
+    /** 扫描阶段确定的**真目标**总数（扫描未完成时为已发现数）。 */
+    candidates: number;
+    /** 本次已完成（送过 LLM 且已提交结果）条数。 */
+    processed: number;
+    /** 仍在扫描阶段（此阶段报「扫描中」而不是「第 N 条」）。 */
+    scanning: boolean;
+    /** 已完成条数 / 本次要处理的总条数。 */
+    batchesDone: number;
+    batchTotal: number;
+    /** LLM 批调用并行度（cfg.backfill.concurrency）。 */
+    concurrency: number;
+    /** 预算/上限用尽未处理、留下次的条数（跟“跑完了”区分开的关键一个数）。 */
+    deferred: number;
+}
 /** dsh-memory/keyword-backfill（关键词蒸馏回填，后台任务；门控关时 enabled=false 不启动）。 */
 export interface KeywordBackfillResponse {
     /** true = 本次触发启动了新任务；false = 已有任务在跑或门控关。 */
@@ -658,6 +696,24 @@ export interface KeywordBackfillResponse {
     updated: number;
     /** 失败/跳过数。 */
     failed: number;
+    /** 分批进度（运行期轮询显示用）。 */
+    progress: BackfillProgress;
+}
+/** dsh-memory/redistill-backfill（存量记忆重蒸馏整形，后台任务；门控关时 enabled=false 不启动）。 */
+export interface RedistillBackfillResponse {
+    /** true = 本次触发启动了新任务；false = 已有任务在跑或门控关。 */
+    started: boolean;
+    running: boolean;
+    /** 门控 `cfg.redistill.enabled`；关时不启动。 */
+    enabled: boolean;
+    /** 本进程累计整形写回条数（重启归零；观测用）。 */
+    updated: number;
+    /** 质量闸判不写（留原文）条数。 */
+    skipped: number;
+    /** 失败/跳过数（LLM 失败、id 配不上、embed 掉线）。 */
+    failed: number;
+    /** 分批进度（运行期轮询显示用）。 */
+    progress: BackfillProgress;
 }
 /** dsh-memory/session-stats(悬浮卡信息区;热路径端点)。 */
 export interface SessionStatsRequest {
@@ -892,6 +948,38 @@ export interface UiRecord {
      */
     userRelevance?: number;
 }
+/** dsh-memory/records-meta（按 ID 批量查元数据，供 .memory.md 查看器拼接 Qoder 风格条目）。 */
+export interface RecordsMetaRequest {
+    /** L1 record_id 列表（上限 50）。 */
+    ids: string[];
+}
+/** 单条轻量元数据（含正文，供 .memory.md 查看器拼接头部条）。 */
+export interface RecordMeta {
+    id: string;
+    /** 名称蒸馏产出的短标题；无 name 时为 null。 */
+    name: string | null;
+    type: string;
+    priority: number;
+    /** 正文全文（markdown）。 */
+    content: string;
+    maturity?: 'low' | 'mid' | 'high';
+    createdAt: string | null;
+    updatedAt: string | null;
+    scene: string;
+    scope: 'global' | 'workspace';
+    workspaceId: string | null;
+    /** 关键词（metadata.dsh_keywords）。 */
+    keywords?: string[];
+    /** 使用场景（metadata.dsh_usage_scenario）。 */
+    usageScenario?: string[];
+    /** 投射文件相对路径 `<type>/<stem>.memory.md`。 */
+    filePath: string;
+    /** 是否已退场（软删）。 */
+    retired: boolean;
+}
+export interface RecordsMetaResponse {
+    items: RecordMeta[];
+}
 export interface ListRecordsResponse {
     items: UiRecord[];
     hasMore: boolean;
@@ -1661,12 +1749,14 @@ export interface DshMemoryRequestMap {
     'dsh-memory/rooms-export': RoomsExportRequest;
     'dsh-memory/room-register': RoomRegisterRequest;
     'dsh-memory/room-admin': RoomAdminRequest;
-    'dsh-memory/wing-backfill': Record<string, never>;
-    'dsh-memory/keyword-backfill': Record<string, never>;
+    'dsh-memory/wing-backfill': BackfillTriggerRequest;
+    'dsh-memory/keyword-backfill': BackfillTriggerRequest;
+    'dsh-memory/redistill-backfill': BackfillTriggerRequest;
     'dsh-memory/session-stats': SessionStatsRequest;
     'dsh-memory/settings-get': Record<string, never>;
     'dsh-memory/settings-set': SettingsSetRequest;
     'dsh-memory/list-records': ListRecordsRequest;
+    'dsh-memory/records-meta': RecordsMetaRequest;
     'dsh-memory/records-delete': RecordsDeleteRequest;
     'dsh-memory/receipts': ReceiptsRequest;
     'dsh-memory/conflicts': ConflictsRequest;
@@ -1726,10 +1816,12 @@ export interface DshMemoryResponseMap {
     'dsh-memory/room-admin': RoomAdminResponse;
     'dsh-memory/wing-backfill': WingBackfillResponse;
     'dsh-memory/keyword-backfill': KeywordBackfillResponse;
+    'dsh-memory/redistill-backfill': RedistillBackfillResponse;
     'dsh-memory/session-stats': SessionStatsResponse;
     'dsh-memory/settings-get': SettingsGetResponse;
     'dsh-memory/settings-set': SettingsSetResponse;
     'dsh-memory/list-records': ListRecordsResponse;
+    'dsh-memory/records-meta': RecordsMetaResponse;
     'dsh-memory/records-delete': RecordsDeleteResponse;
     'dsh-memory/receipts': ReceiptsResponse;
     'dsh-memory/conflicts': ConflictsResponse;

package/dist/keyword-backfill.d.ts

@@ -1,13 +1,13 @@
 /**
  * 关键词蒸馏回填（keyword axis 产出方）。
  *
- * 职责：从 L1 记录中找「缺 dsh_keywords」的存量记录，按 chunk 20 条一批送 LLM 提炼关键词
+ * 职责：从 L1 记录中找「缺 dsh_keywords」的存量记录，**一条一个请求**送 LLM 提炼关键词
  * 与使用场景，归一后写 `metadata.dsh_keywords` + `metadata.dsh_usage_scenario`，
  * 并用 `patchMetadataAndReindex` 保证新关键词**立即进 FTS BM25 轴**。
  *
  * 安全边界（继承 wing-backfill）：
  * - 单飞：同时最多一个回填任务,重复触发直接返回 running(不排队不叠加)
- * - 后台执行：端点立即返回,逐块推进(每块 20 条),不阻塞 RPC/管线
+ * - 后台执行：端点立即返回,**逐条推进、跑完一条再发下一条**,不阻塞 RPC/管线
  * - 失败可退：LLM 失败/输出不合法只跳过当前块,原记录零改动(标签只写成功的)
  * - 有界：单次任务最多处理 cfg.backfill.maxRecords 条,防止一次跑飞;其余可再次触发
  * - 门控关（`cfg.keyword.enabled = false`）：run() 入口立即跳过——无回填、FTS 逐字不变
@@ -21,11 +21,33 @@ export interface KeywordBackfillDeps {
     cfg: MemoryConfig;
     backend: MemoryBackend;
     logger: MemoryLogger;
+    /**
+     * 运行时**生效并发**读取器（可选）：给正在跑的任务即时改并发用——池子每完成一条重读一次。
+     * 缺省 = 启动时读一次 `cfg.backfill.concurrency`（旧行为）。
+     */
+    concurrency?: () => number | undefined;
 }
 export interface KeywordBackfillState {
     running: boolean;
     updated: number;
     failed: number;
+    /** 分批进度（UI 轮询据此显示「扫描中 / 第几条」，否则运行期只有一个「回填中…」）： */
+    /** 每个请求处理的条数——已改逐条，永远为 1（与 redistill 同形状）。 */
+    chunk: number;
+    /** 扫描阶段确定的真目标总数（缺关键词；扫描未完成时为已发现数）。 */
+    candidates: number;
+    /** 本次已完成（送过 LLM 且已写回）**在请求完成时才自增**，否则“全失败”跟“全成功”看起来一样。 */
+    processed: number;
+    /** 仍在扫描阶段。 */
+    scanning: boolean;
+    /** 已完成条数（与 processed 同值）。 */
+    batchesDone: number;
+    /** 本次要处理的总条数。 */
+    batchTotal: number;
+    /** LLM 批调用并行度。 */
+    concurrency: number;
+    /** 预算/上限用尽未处理、留下次的条数。 */
+    deferred: number;
 }
 export declare function keywordBackfillState(): KeywordBackfillState;
 /** 启动后台关键词回填；已在运行返回 false（单飞）。 */
@@ -38,9 +60,16 @@ export declare function startKeywordBackfill(deps: KeywordBackfillDeps): {
  * 门控关（`cfg.keyword.enabled = false`）时入口立即返回，不碰任何记录与 fts。
  */
 export declare function runKeywordBackfillOnce(deps: KeywordBackfillDeps): Promise<void>;
-/** 关键词标注器（导出供单测）。 */
-export declare function labelKeywordChunk(ctx: Context, cfg: MemoryConfig, logger: MemoryLogger, chunk: MemoryRecord[]): Promise<Array<{
-    record: MemoryRecord;
+/** 单条标注结果。 */
+export interface KeywordOneResult {
     keywords: string[];
-    usageScenario?: string[];
-}>>;
+    usageScenario: string[];
+}
+/**
+ * 标注**一条**记忆的关键词与情景（一个请求只装一条）。失败/无合法关键词返回 null。
+ *
+ * 旧名 `labelKeywordChunk`（多条一次）已废：合并请求下一次截断/空输出就整批丢弃，
+ * 而逐条只花秒级。记账（state.failed 等）全部归调用方——标注器不再动全局状态，
+ * 否则同一条会被两处各计一次。
+ */
+export declare function labelKeywordOne(ctx: Context, cfg: MemoryConfig, logger: MemoryLogger, rec: MemoryRecord, callTimeoutMs?: number): Promise<KeywordOneResult | null>;

package/dist/keyword-backfill.js

@@ -1,21 +1,41 @@
 import { callLLM, parseJsonLogged } from './llm.js';
 import { normKeywords, normUsageScenario, KEYWORDS_METADATA_KEY } from './metadata-validators.js';
 import { yieldLoop } from './util/yield.js';
-/** 每块条数（一次 LLM 调用判定的记录数；与 wing-backfill 同口径）。 */
-const CHUNK = 20;
+// 一个请求只装**一条**记忆（旧形状是 20 条/次，已改）。与 redistill 同口径：
+// 合并请求把爆炸半径从 1 条放大到 20 条（一次截断/空输出就整批丢弃），而实测单条
+// 在本地端点上只是秒级，合并并不省时间。
 /** 扫描页大小（轻量投影分页；与 wing-backfill 一致）。 */
 const PAGE = 200;
 /** 单次任务默认处理上限（cfg.backfill.maxRecords 优先）。 */
-const DEFAULT_MAX_RECORDS = 300;
-/** 墙钟默认预算（cfg.backfill.timeBudgetMs 优先）。 */
-const DEFAULT_TIME_BUDGET_MS = 120_000;
-const state = { running: false, updated: 0, failed: 0 };
+const DEFAULT_MAX_RECORDS = 40;
+/** 总墙钟默认预算（cfg.backfill.timeBudgetMs 优先）。 */
+const DEFAULT_TIME_BUDGET_MS = 1_800_000;
+/** 默认并行度（cfg.backfill.concurrency 优先）：1 = 串行逐条（用户定的形状）。 */
+const DEFAULT_CONCURRENCY = 1;
+/**
+ * 一次调用（含整条回退链）的默认超时（cfg.backfill.callTimeoutMs 优先）。
+ * 不能沿用 `llm.timeoutMs`（120s）：它是整次调用的预算而不是每条路由各享一份，
+ * 主路由空转一轮再降级就会撞线。
+ */
+const DEFAULT_CALL_TIMEOUT_MS = 240_000;
+/** 单条关键词标注的输出预算（5 关键词 + 3 情景，实测远低于此）。 */
+const LABEL_MAX_TOKENS = 512;
+/** 并发度钳位（与 schema 的 min1/max8 同口径）。 */
+function clampConcurrency(raw) {
+    const n = typeof raw === 'number' && Number.isFinite(raw) ? Math.round(raw) : DEFAULT_CONCURRENCY;
+    return Math.min(8, Math.max(1, n));
+}
+const state = {
+    running: false, updated: 0, failed: 0,
+    chunk: 1, candidates: 0, processed: 0,
+    scanning: false, batchesDone: 0, batchTotal: 0, concurrency: DEFAULT_CONCURRENCY, deferred: 0,
+};
 export function keywordBackfillState() {
     return { ...state };
 }
 // ── SYSTEM 提示词（定稿版，由 tools/keyword-distill.prompt.md 的 ```text 块迁移） ──
 const SYSTEM_PROMPT = [
-    '你是记忆库的关键词与情景标注器。给定若干条记忆（每条含 id、标题、正文摘要），为每条提炼：',
+    '你是记忆库的关键词与情景标注器。给定**一条**记忆（含标题与正文），为它提炼：',
     '1) keywords：最能代表该记忆的检索词，用于精确命中；2) usage_scenario：未来「何时应当浮现这条记忆」的场景短语。',
     '',
     '严格规则：',
@@ -24,10 +44,9 @@ const SYSTEM_PROMPT = [
     '- keywords：2–5 个（宁少勿滥，够区分即可）；每个 2–6 词或 1 个复合术语；不得与标题字面重复、不得互相近义堆叠、不收停用词/整句。',
     '- usage_scenario：1–3 条；每条 5–10 词的短场景描述（不是完整命令句）；彼此必须可区分，相似的合并成更泛化的一条。',
     '- 语言跟随该记忆正文：中文记忆产出中文（技术标识符、API 名、错误码原样保留），英文记忆产出英文。',
-    '- id 必须原样照抄，不得改写、截断或改用序号；一条记忆只产一组，不要拆分。',
     '',
-    '输出：只输出一个 JSON 数组，不要多余文字、不要解释。每项形如：',
-    '{"id":"<原id>","keywords":["…","…"],"usage_scenario":["…","…"]}',
+    '输出：只输出**一个 JSON 对象**（不是数组），不要多余文字、不要解释。形如：',
+    '{"keywords":["…","…"],"usage_scenario":["…","…"]}',
 ].join('\n');
 /** 启动后台关键词回填；已在运行返回 false（单飞）。 */
 export function startKeywordBackfill(deps) {
@@ -36,9 +55,18 @@ export function startKeywordBackfill(deps) {
     state.running = true;
     state.updated = 0;
     state.failed = 0;
+    state.candidates = 0;
+    state.processed = 0;
+    state.scanning = true;
+    state.batchesDone = 0;
+    state.batchTotal = 0;
+    state.deferred = 0;
+    state.concurrency = clampConcurrency(deps.cfg.backfill?.concurrency);
     void runKeywordBackfillOnce(deps).finally(() => {
         state.running = false;
-        deps.logger.info(`[memory] keyword 回填结束:成功 ${state.updated} 条,失败 ${state.failed} 条`);
+        state.scanning = false;
+        deps.logger.info(`[memory] keyword 回填结束:成功 ${state.updated} 条,失败 ${state.failed} 条`
+            + (state.deferred > 0 ? `,留待下次 ${state.deferred} 条` : ''));
     });
     return { started: true, running: true };
 }
@@ -54,11 +82,14 @@ export async function runKeywordBackfillOnce(deps) {
     }
     const MAX_RECORDS = cfg.backfill?.maxRecords ?? DEFAULT_MAX_RECORDS;
     const TIME_BUDGET_MS = cfg.backfill?.timeBudgetMs ?? DEFAULT_TIME_BUDGET_MS;
+    const LIMIT = clampConcurrency(cfg.backfill?.concurrency);
+    state.concurrency = LIMIT;
     const startedAt = Date.now();
-    // ── 扫描阶段（轻量投影，不反序列化正文）──
+    // ── 扫描阶段（轻量投影，不反序列化正文；分页 + 每页让位，不设墙钟）──
     const total = await backend.size();
     const pendingIds = [];
     let scanned = 0;
+    state.scanning = true;
     for (let offset = 0;; offset += PAGE) {
         const page = await backend.allLite(PAGE, offset);
         if (page.length === 0)
@@ -69,75 +100,119 @@ export async function runKeywordBackfillOnce(deps) {
                 pendingIds.push(r.id);
         }
         scanned += page.length;
-        if (Date.now() - startedAt > TIME_BUDGET_MS) {
-            logger.info(`[memory] keyword 回填：墙钟预算(${TIME_BUDGET_MS / 1000}s)在扫描阶段用尽(已扫 ${scanned}/${total}),留待再触发`);
-            return;
-        }
+        state.candidates = pendingIds.length;
         await yieldLoop();
     }
-    let budget = Math.min(pendingIds.length, MAX_RECORDS);
-    logger.info(`[memory] keyword 回填启动：缺关键词 ${pendingIds.length} 条,本次上限 ${budget} 条`);
-    // ── 标注阶段（补水→LLM→归一→写回）──
-    for (let offset = 0; offset < pendingIds.length && budget > 0; offset += CHUNK) {
-        if (Date.now() - startedAt > TIME_BUDGET_MS) {
-            logger.info(`[memory] keyword 回填：墙钟预算用尽,剩余 ${pendingIds.length - offset} 条留待再触发`);
-            break;
+    state.scanning = false;
+    const batch = pendingIds.slice(0, MAX_RECORDS);
+    state.candidates = batch.length;
+    state.batchTotal = batch.length;
+    state.deferred = Math.max(0, pendingIds.length - batch.length);
+    const callTimeoutMs = cfg.backfill?.callTimeoutMs ?? DEFAULT_CALL_TIMEOUT_MS;
+    logger.info(`[memory] keyword 回填启动：已扫 ${scanned}/${total} 行,缺关键词 ${pendingIds.length} 条,本次处理 ${batch.length} 条,并行度 ${LIMIT}`);
+    /** 一条一个请求：取一条 → 标注 → **即时写回**（含 fts 重索引）。 */
+    const labelAndCommit = async (id) => {
+        const [rec] = await backend.getByIds([id]);
+        if (!rec || !rec.content || rec.content.trim() === '') {
+            state.processed++;
+            state.batchesDone++;
+            return;
         }
-        const hydrated = await backend.getByIds(pendingIds.slice(offset, offset + CHUNK));
-        const chunk = hydrated.filter((r) => r.content && r.content.trim() !== '');
-        if (chunk.length === 0)
-            continue;
-        budget -= chunk.length;
-        const labeled = await labelKeywordChunk(deps.ctx, cfg, logger, chunk);
-        for (const { record, keywords, usageScenario } of labeled) {
-            const meta = { ...(record.metadata ?? {}) };
-            meta[KEYWORDS_METADATA_KEY] = keywords;
-            if (usageScenario && usageScenario.length > 0)
-                meta.dsh_usage_scenario = usageScenario;
-            if (await backend.patchMetadataAndReindex(record.id, meta))
+        const labeled = await labelKeywordOne(deps.ctx, cfg, logger, rec, callTimeoutMs);
+        if (!labeled) {
+            state.failed++;
+        }
+        else {
+            const meta = { ...(rec.metadata ?? {}) };
+            meta[KEYWORDS_METADATA_KEY] = labeled.keywords;
+            if (labeled.usageScenario.length > 0)
+                meta.dsh_usage_scenario = labeled.usageScenario;
+            if (await backend.patchMetadataAndReindex(rec.id, meta))
                 state.updated++;
             else
                 state.failed++;
-            await yieldLoop();
         }
+        // 完成才计数（同 redistill）：否则“全失败”在面板上跟“全成功”长得一样。
+        state.processed++;
+        state.batchesDone++;
+        await yieldLoop();
+    };
+    /**
+     * 弹性工作池（与 redistill 同构）：每完成一条重读一次**生效并发**，拖概览页滑块即时生效。
+     * 拖高立刻补 worker；拖低则各自干完手头那条后自然收工。缺省 getter = 启动值。
+     * 预算只在**条前**检查，中途不挖已烧 token 的那条。
+     */
+    const readLimit = () => {
+        const raw = deps.concurrency ? deps.concurrency() : undefined;
+        return clampConcurrency(raw ?? cfg.backfill?.concurrency);
+    };
+    let cursor = 0;
+    let budgetHit = false;
+    const work = async () => {
+        for (;;) {
+            if (budgetHit || Date.now() - startedAt > TIME_BUDGET_MS) {
+                budgetHit = true;
+                return;
+            }
+            const i = cursor++;
+            if (i >= batch.length)
+                return;
+            await labelAndCommit(batch[i]);
+        }
+    };
+    const inFlight = new Set();
+    const spawn = () => {
+        const p = work().finally(() => inFlight.delete(p));
+        inFlight.add(p);
+    };
+    for (;;) {
+        const target = Math.max(1, Math.min(readLimit(), batch.length));
+        state.concurrency = target; // 面板「并行 N」跟实时值走
+        while (!budgetHit && inFlight.size < target && cursor < batch.length)
+            spawn();
+        if (inFlight.size === 0)
+            break;
+        await Promise.race(inFlight);
+    }
+    if (budgetHit) {
+        state.deferred += Math.max(0, batch.length - state.processed);
+        logger.info(`[memory] keyword 回填：墙钟预算(${Math.round(TIME_BUDGET_MS / 1000)}s)用尽,累计留待再触发 ${state.deferred} 条`);
     }
 }
-/** 关键词标注器（导出供单测）。 */
-export async function labelKeywordChunk(ctx, cfg, logger, chunk) {
-    const list = chunk.map((r, i) => `${i + 1}. id=${r.id}\n标题：${r.name ?? ''}\n正文：${r.content.slice(0, 300)}`).join('\n\n');
-    const user = '记忆列表:\n' + list;
+/**
+ * 标注**一条**记忆的关键词与情景（一个请求只装一条）。失败/无合法关键词返回 null。
+ *
+ * 旧名 `labelKeywordChunk`（多条一次）已废：合并请求下一次截断/空输出就整批丢弃，
+ * 而逐条只花秒级。记账（state.failed 等）全部归调用方——标注器不再动全局状态，
+ * 否则同一条会被两处各计一次。
+ */
+export async function labelKeywordOne(ctx, cfg, logger, rec, callTimeoutMs = DEFAULT_CALL_TIMEOUT_MS) {
+    const user = `记忆:\n标题：${rec.name ?? ''}\n正文：${rec.content.slice(0, 900)}`;
+    const t0 = Date.now();
+    const secs = () => Math.round((Date.now() - t0) / 10);
     try {
         const raw = await callLLM(ctx, cfg, {
             system: SYSTEM_PROMPT,
             user,
-            maxTokens: 4096,
+            maxTokens: LABEL_MAX_TOKENS,
             layer: 'l1-extract',
             logger,
+            signal: AbortSignal.timeout(callTimeoutMs > 0 ? callTimeoutMs : DEFAULT_CALL_TIMEOUT_MS),
         });
+        logger.debug?.(`[memory] keyword 单条耗时 ${(Date.now() - t0) / 1000}s(id=${rec.id})`);
         const parsed = parseJsonLogged(raw, 'keyword 回填', logger);
-        if (!Array.isArray(parsed))
-            return [];
-        const byId = new Map(chunk.map((r) => [r.id, r]));
-        const out = [];
-        for (const item of parsed) {
-            const record = typeof item?.id === 'string' ? byId.get(item.id) : undefined;
-            if (!record) {
-                logger.warn(`[memory] keyword 回填:id 配对失败,已丢弃(id=${String(item?.id).slice(0, 40)})`);
-                continue;
-            }
-            const keywords = normKeywords(item.keywords, 5);
-            if (keywords.length === 0) {
-                logger.warn(`[memory] keyword 回填:normKeywords 结果为空,已跳过(id=${record.id})`);
-                continue;
-            }
-            const usageScenario = normUsageScenario(item.usage_scenario, 3);
-            out.push({ record, keywords, usageScenario: usageScenario.length > 0 ? usageScenario : undefined });
+        const obj = Array.isArray(parsed) ? parsed[0] : parsed;
+        if (!obj || typeof obj !== 'object')
+            return null;
+        const keywords = normKeywords(obj.keywords, 5);
+        if (keywords.length === 0) {
+            logger.warn(`[memory] keyword 回填:normKeywords 结果为空,已跳过(id=${rec.id})`);
+            return null;
         }
-        return out;
+        return { keywords, usageScenario: normUsageScenario(obj.usage_scenario, 3) };
     }
     catch (err) {
-        logger.warn(`[memory] keyword 回填块失败(跳过 ${chunk.length} 条,原记录未改): ${err instanceof Error ? err.message : String(err)}`);
-        state.failed += chunk.length;
-        return [];
+        logger.warn(`[memory] keyword 单条失败(id=${rec.id},已等 ${secs() / 10}s,原记录未改): ${err instanceof Error ? err.message : String(err)}`);
+        return null;
     }
 }

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>;