dsh-prime-memory 0.25.0 → 0.26.1

package/dist/keyword-backfill.js

@@ -1,21 +1,76 @@
 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,
+    cancelled: false, scanned: 0, scanTotal: 0,
+};
+/**
+ * 人工中止信号。置位后：①池子不再派新活；②已发出的请求先拿**宽限**(cancelGraceMs)
+ * 自然收工（token 不白费、已写回的全入账）；③**宽限到期强杀**在飞请求——
+ * 没有③的话「中止」最坏要等满 callTimeoutMs(240s) 才生效，等于没中止。
+ */
+let abortRequested = false;
+/** 本轮在飞请求的强杀器（runOnce 入口新建）。 */
+let runAbort = null;
+/** 中止宽限计时器（一次性）。 */
+let graceTimer = null;
+/** 本轮生效的中止宽限（启动时从 cfg 读定，已钳位）。 */
+let graceMs = 15_000;
+/**
+ * 中止宽限钳位。**硬界 30s**（用户定：中止必须在 30s 内强停）——无论 YAML 写了多少，
+ * 都不会超过这个值；未配置/非法取默认 15s。
+ */
+function clampGraceMs(raw) {
+    const n = typeof raw === 'number' && Number.isFinite(raw) ? Math.round(raw) : 15_000;
+    return Math.min(30_000, Math.max(0, n));
+}
+/** 请求中止本轮（空闲时无副作用）；返回后中止是**有界**的：最多等 graceMs。 */
+export function cancelKeywordBackfill() {
+    if (!state.running)
+        return { cancelled: false, running: false };
+    abortRequested = true;
+    if (graceTimer === null) {
+        graceTimer = setTimeout(() => {
+            graceTimer = null;
+            if (state.running)
+                runAbort?.abort();
+        }, Math.max(0, graceMs));
+    }
+    return { cancelled: true, running: true };
+}
 export function keywordBackfillState() {
     return { ...state };
 }
 // ── SYSTEM 提示词（定稿版，由 tools/keyword-distill.prompt.md 的 ```text 块迁移） ──
 const SYSTEM_PROMPT = [
-    '你是记忆库的关键词与情景标注器。给定若干条记忆（每条含 id、标题、正文摘要），为每条提炼：',
+    '你是记忆库的关键词与情景标注器。给定**一条**记忆（含标题与正文），为它提炼：',
     '1) keywords：最能代表该记忆的检索词，用于精确命中；2) usage_scenario：未来「何时应当浮现这条记忆」的场景短语。',
     '',
     '严格规则：',
@@ -24,10 +79,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 +90,20 @@ 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.cancelled = false;
+    abortRequested = false;
+    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 };
 }
@@ -48,18 +113,32 @@ export function startKeywordBackfill(deps) {
  */
 export async function runKeywordBackfillOnce(deps) {
     const { cfg, backend, logger } = deps;
+    // 新一轮入口清中止信号（同 redistill：直调 runOnce 的路径不经过 startX 的复位）。
+    abortRequested = false;
+    state.cancelled = false;
+    if (graceTimer !== null) {
+        clearTimeout(graceTimer);
+        graceTimer = null;
+    }
+    runAbort = new AbortController();
     if (!cfg.keyword?.enabled) {
         logger.info('[memory] keyword 回填跳过：keyword.enabled = false（功能关，不回填）');
         return;
     }
     const MAX_RECORDS = cfg.backfill?.maxRecords ?? DEFAULT_MAX_RECORDS;
     const TIME_BUDGET_MS = cfg.backfill?.timeBudgetMs ?? DEFAULT_TIME_BUDGET_MS;
+    graceMs = clampGraceMs(cfg.backfill?.cancelGraceMs);
+    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) {
+        if (abortRequested)
+            break; // 中止：扫描段也当场退出（不把最后一页白扫完）
         const page = await backend.allLite(PAGE, offset);
         if (page.length === 0)
             break;
@@ -69,75 +148,138 @@ 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;
+        state.scanned = scanned;
+        state.scanTotal = total;
         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 labeled = await labelKeywordOne(deps.ctx, cfg, logger, rec, callTimeoutMs, runAbort?.signal);
+        if (!labeled) {
+            // 中止强杀导致的失败不计入 failed（不是模型/网络的错，是中止信号）
+            if (!abortRequested)
+                state.failed++;
         }
-        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))
+        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 (abortRequested)
+                return; // 中止：不再取新活（在飞的那条自然跑完）
+            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 && !abortRequested && inFlight.size < target && cursor < batch.length)
+            spawn();
+        if (inFlight.size === 0)
+            break;
+        await Promise.race(inFlight);
+    }
+    if (abortRequested) {
+        state.cancelled = true;
+        state.deferred += Math.max(0, batch.length - state.processed);
+        logger.info(`[memory] keyword 回填：已按请求中止（在飞请求跑完即收工）,本轮完成 ${state.processed} 条,剩 ${state.deferred} 条留待再触发`);
+    }
+    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, 
+/** 本轮中止信号（可选）：与单次超时**取或**，宽限到期后由它当场掐断请求。 */
+externalSignal) {
+    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',
+            // 关键词/情景标注是直答任务：显式关思考，否则思考模型会把 512 预算烧在
+            // reasoning 上、正文吐 0 字符（真机 156/162 次 `llm empty output` 皆为此）。
+            reasoningEffort: 'off',
             logger,
+            signal: (() => {
+                const t = AbortSignal.timeout(callTimeoutMs > 0 ? callTimeoutMs : DEFAULT_CALL_TIMEOUT_MS);
+                return externalSignal ? AbortSignal.any([t, externalSignal]) : t;
+            })(),
         });
+        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/llm.d.ts

@@ -17,6 +17,15 @@ export interface LlmCallOptions {
     maxTokens?: number;
     temperature?: number;
     signal?: AbortSignal;
+    /**
+     * **调用级思考档位覆盖**（可选）。非空时优先于路由/层链/全局解析出的档位。
+     *
+     * 为什么需要：回填批扫（整形/关键词/wing/room）是「重排 + 拎标识」的直答任务，
+     * 不需要推理；而思考模型默认开思考，会把整个 maxTokens 预算烧在 reasoning 上、
+     * 正文吐 0 字符（真机：156/162 次 `llm empty output` 都是这么来的）。
+     * 显式传 `off` 后预算全留给答案。档位仍过一遍模型能力钳制：模型不支持 off 时不传。
+     */
+    reasoningEffort?: string;
     /** 诊断日志(缺失时静默,不影响调用) */
     logger?: MemoryLogger;
 }

package/dist/llm.js

@@ -393,8 +393,10 @@ async function callRoute(ctx, cfg, opts, route) {
     const { provider, model } = route;
     const signal = opts.signal ?? AbortSignal.timeout(cfg.llm.timeoutMs);
     // 档位按模型能力决策(跨供应商 effort 兼容):不支持的档位不传 + 告警一次,
-    // 空配置 = 自动(模型默认 → high);路由的档位候选已在链解析时定好(条目 > 全局)
-    const effort = await planDistillEffort(ctx, provider, model, route.effort, opts.logger);
+    // 空配置 = 自动(模型默认 → high);路由的档位候选已在链解析时定好(条目 > 全局)。
+    // 调用级覆盖(opts.reasoningEffort)优先——批扫靠它关掉思考，避免预算被 reasoning 吃光。
+    const routeEffort = opts.reasoningEffort ?? route.effort;
+    const effort = await planDistillEffort(ctx, provider, model, routeEffort, opts.logger);
     // 输入预算兜底:任何蒸馏调用的用户 prompt 不超过 maxInputChars
     // (L1 已在数据层分块,这里是 L2/L3 与异常场景的最后一道网)
     const user = opts.user.length > cfg.llm.maxInputChars
@@ -406,9 +408,10 @@ async function callRoute(ctx, cfg, opts, route) {
     // 配置本身就是高档时不再放大(防 ×16 双乘)
     const baseMaxTokens = opts.maxTokens ?? cfg.llm.maxTokens;
     const highTiers = HIGH_EFFORT_TIERS;
-    const triggerEffort = opts.layer
+    // 触发档位也跟调用级覆盖走：显式 off 时不得被配置里的高档触发而 ×4。
+    const triggerEffort = opts.reasoningEffort ?? (opts.layer
         ? layerEffortTrigger(cfg, layerKeyFor(opts.layer))
-        : cfg.llm.primaryEffort || cfg.llm.reasoningEffort;
+        : cfg.llm.primaryEffort || cfg.llm.reasoningEffort);
     const maxTokens = highTiers.includes(effort.effort) && !highTiers.includes(triggerEffort)
         ? layerMaxTokens(baseMaxTokens, 'high')
         : baseMaxTokens;

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;