dsh-prime-memory 0.26.29 → 0.26.30

package/dist/pipeline/l1.js

@@ -16,6 +16,7 @@ import { normTags, normUsageScenario, readCognitiveHall, readWing } from '../met
 import { acceptTitle } from '../util/md-name.js';
 import { clampPriority } from '../util/priority.js';
 import { formatBatchConflictPrompt, getConflictDetectionSystemPrompt } from '../prompts/l1-dedup.js';
+import { preDedupeBatch } from './intra-dedupe.js';
 import { resolveSourceAnchors, withSourceAnchors } from './anchors.js';
 import { stampValidity, validToSourceOf } from '../store/validity.js';
 import { familyForType, normPersistence, normScope, resolveRecordFamily, resolveRecordScope, WING_FALLBACK } from '../types.js';
@@ -456,10 +457,30 @@ routeHealth) {
         markExtracted(states, mode, lastScene);
         return { stored: 0, skipped: false, sceneName: lastScene, newRecords: [], failedMessages: [] };
     }
+    // ── Step 1.5: 批内自去重（同轮/同会话）──
+    // 根因：候选池只来自库，同批 extracted[] 之间从不互比 → 同一段对话抽出的多条碎片
+    // 全被塞进同一条 LLM 批，只能靠模型的 merged_content 把内容"撬在一起"。
+    // 逻辑全在 `preDedupeBatch`（可注入 embedMany，故不必驱动 LLM 就能单测接线）。
+    const pre = await preDedupeBatch(extracted, (texts) => store.embedMany(texts), {
+        enabled: cfg.extract.intraBatchDedupe !== false,
+        tau: cfg.extract.intraBatchCosine ?? 0.92,
+        onWarn: (m) => logger.warn(m),
+    });
+    const effective = pre.effective;
+    /** 代表项 record_id → 其**本正文**的向量（候选召回与写侧复用同一份，免二次嵌入）。 */
+    const vecByRecordId = pre.vectors;
+    /** 批内吸收关系（被吸收 record_id → 代表 record_id），给 receipt 审计用。 */
+    const intraAbsorbedBy = pre.absorbedBy;
+    if (cfg.extract.intraBatchDedupe !== false) {
+        logger.info(`[memory] L1 批内自去重:raw=${pre.raw} exact=${pre.exact} ` +
+            `vector=${pre.vector} effective=${effective.length}（吸收 ${Object.keys(intraAbsorbedBy).length} 条）`);
+    }
     // ── Step 2: 去重(batch 冲突检测;候选只在本族内召回,去重永不跨族) ──
-    const matches = await Promise.all(extracted.map(async (m) => ({
+    const matches = await Promise.all(effective.map(async (m) => ({
         newMemory: m,
-        candidates: await store.searchCandidates(m.content, cfg.extract.candidatePool, m.family, wsFilter),
+        candidates: await store.searchCandidates(m.content, cfg.extract.candidatePool, m.family, wsFilter, {
+            queryVector: vecByRecordId.get(m.record_id),
+        }),
     })));
     // 按固定条数切块发送,失败半径与上下文同时可控(#10 去重侧同精)
     const dedupBatches = [];
@@ -492,12 +513,12 @@ routeHealth) {
     }
     // 去重决策统计:无决策的记录按 skip 处理,聚合成单行日志便于排查
     const actionCount = {};
-    for (const m of extracted) {
+    for (const m of effective) {
         const action = byRecord.get(m.record_id)?.action ?? 'skip(未返回)';
         actionCount[action] = (actionCount[action] ?? 0) + 1;
     }
     const candidateTotal = matches.reduce((n, m) => n + m.candidates.length, 0);
-    logger.info(`[memory] L1 去重判定:${extracted.length} 条候选记忆召回 ${candidateTotal} 条已有记录,决策 ${Object.entries(actionCount)
+    logger.info(`[memory] L1 去重判定:${effective.length} 条候选记忆召回 ${candidateTotal} 条已有记录,决策 ${Object.entries(actionCount)
         .map(([k, v]) => `${k}=${v}`)
         .join(' ')}`);
     // ── §B 决策凭证:在应用决策前留痕(旁路设施,写失败绝不中断蒸馏) ──
@@ -512,12 +533,21 @@ routeHealth) {
     const runId = newRunId();
     let byKind;
     {
-        const items = extracted.map((m, i) => ({
+        const items = effective.map((m, i) => ({
             recordId: m.record_id,
             candidateIds: (matches[i]?.candidates ?? []).map((c) => c.id),
             action: byRecord.get(m.record_id)?.action,
         }));
-        const rows = buildReceipts(runId, new Date().toISOString(), items);
+        // 批内被吸收的条目也必须留痕：否则「这条为何没进库」在库里完全查不到（skip 是现有
+        // 唯一零痕迹分支，批内吸收不能重蹈）。用既有 `kind='merge'` + candidateIds=[代表 id]：
+        // 不新增表列、不扩词表，回答“本条被批内哪条吸收”只需一次 (runId, recordId) 回溯。
+        // 关闭特性时 intraAbsorbedBy 为空 ⇒ 凭证与改动前逐字节一致。
+        const absorbedItems = Object.entries(intraAbsorbedBy).map(([absorbedId, repId]) => ({
+            recordId: absorbedId,
+            candidateIds: [repId],
+            action: 'merge',
+        }));
+        const rows = buildReceipts(runId, new Date().toISOString(), [...items, ...absorbedItems]);
         persistReceiptsSafely((rows) => store.recordReceipts(rows), rows, logger);
         // §F 追踪捎带:六值决策词表聚合(与凭证同源,runner 侧并入 distill_run 事件)
         byKind = rows.reduce((acc, r) => {
@@ -544,7 +574,7 @@ routeHealth) {
      *    不成对而回落 store**(2026-09-18 取证确认,见 findings R6 / Agent A);
      * ② 队满自动了结的护栏 —— 败方若属本批新记忆,不得自动退场(见下方分支)。
      */
-    const batchIds = new Set(extracted.map((e) => e.record_id));
+    const batchIds = new Set(effective.map((e) => e.record_id));
     /**
      * update/merge 取代掉的旧记录 → **取代它的**新记录 id。
      * 用 Map 而非 Set:退场标记要带 `by`,否则"被谁取代"只能靠时间猜。
@@ -560,7 +590,7 @@ routeHealth) {
      */
     const rejected = [];
     const now = Date.now();
-    for (const m of extracted) {
+    for (const m of effective) {
         const decision = byRecord.get(m.record_id);
         if (!decision || decision.action === 'skip')
             continue;
@@ -746,7 +776,14 @@ routeHealth) {
         stampValidity(mergedRec, now, mt.validToSource);
         added.push(mergedRec);
     }
-    await store.appendNew(added);
+    await store.appendNew(added, {
+        vectors: added.map((r) => {
+            // 写侧复用：代表项正文未被改写 → 复用批内向量（免掉同一条记忆的第二次嵌入）。
+            // merge/update 产出的 merged_content 是**新文本**，同 record_id 也不得复用。
+            const orig = effective.find((m) => m.record_id === r.id)?.content;
+            return orig !== undefined && orig === r.content ? vecByRecordId.get(r.id) : undefined;
+        }),
+    });
     if (supersededBy.size > 0) {
         // **软删**(取代):不是物理删除——主表行保留 + 取代标记(marker 单源，门1 解耦后
         // 不再闭合 valid_to)，FTS/向量撤出检索面。于是"合并错了"也能恢复,而不必去
@@ -826,7 +863,7 @@ routeHealth) {
         states[f].memoriesSinceL3 += addedByFamily[f];
     }
     markExtracted(states, mode, lastScene);
-    logger.info(`[memory] L1 抽取完成(mode=${mode}):消息 ${pending.length} 条,抽取 ${extracted.length} 条,去重后新增 ${added.length} 条(取代退场 ${supersededBy.size} 条,chat=${addedByFamily.chat}/work=${addedByFamily.work}),累计 chat=${states.chat.totalExtracted}/work=${states.work.totalExtracted}`);
+    logger.info(`[memory] L1 抽取完成(mode=${mode}):消息 ${pending.length} 条,抽取 ${extracted.length} 条(批内收拢 ${effective.length}),去重后新增 ${added.length} 条(取代退场 ${supersededBy.size} 条,chat=${addedByFamily.chat}/work=${addedByFamily.work}),累计 chat=${states.chat.totalExtracted}/work=${states.work.totalExtracted}`);
     return { stored: added.length, skipped: false, sceneName: lastScene, newRecords: added, runId, byKind, failedMessages };
 }
 /** auto 档取最近活跃的族 checkpoint(情境链/计数锚点)。 */

package/dist/stats.js

@@ -18,6 +18,7 @@ import { EFFORT_CHOICES, resolveDataDir } from './config.js';
 import { typeCatalogEntries } from './memory-types.js';
 import { effectiveCfg } from './pipeline/runner.js';
 import { emptyRecallStats } from './hooks/recall.js';
+import { probeDrscHealth } from './clients/drsc-inproc.js';
 import { buildRouteChain, decideSendableEffort, LAYER_DEFAULT_BUDGETS, layerChainOrNull, resolveModelContextWindow, resolveModelEfforts, resolveModelRoute } from './llm.js';
 import { mergeRoom, renameRoom, mergeRoomCatalog } from './room-review.js';
 import { scanSources } from './memport/scan.js';
@@ -122,6 +123,7 @@ export const MEMORY_ENDPOINTS = [
     'dsh-memory/llm-providers',
     'dsh-memory/llm-models',
     'dsh-memory/embedding-state-get',
+    'dsh-memory/drsc-health',
     'dsh-memory/embedding-source-set',
     'dsh-memory/embedding-download-start',
     'dsh-memory/embedding-download-cancel',
@@ -2354,6 +2356,11 @@ export async function handleEndpoint(endpoint, payload, deps) {
             const v = { supported: true, ...(await embedManager.snapshot()) };
             return v;
         }
+        // DRSC 健康（设置面板 banner）：纯观测，不改读写路径，故不依赖 ctx/embedManager。
+        case 'dsh-memory/drsc-health': {
+            const v = await probeDrscHealth();
+            return v;
+        }
         case 'dsh-memory/embedding-source-set': {
             if (!embedManager)
                 throw new Error('嵌入管理器未初始化(存储不可用)');

package/dist/store/embedding-source.d.ts

@@ -69,7 +69,9 @@ export declare function makeLocalServiceFactory(installer: RuntimeInstaller, dow
 /** 测试注入缝:子进程资产路径(源码态下 dist 产物不存在,显式指向 resources 源文件)。 */
 childPath?: string, 
 /** 本地推理 token 预算(config `embedding.maxInputTokens`;0/缺省 = 按模型窗口与硬上限推导)。 */
-maxInputTokens?: number): (modelId: string) => LocalEmbeddingService | null;
+maxInputTokens?: number, 
+/** 崩溃有界自愈开关(config `embedding.respawnOnCrash`;缺省 true,与 LocalEmbeddingService 内默认一致)。 */
+respawnOnCrash?: boolean): (modelId: string) => LocalEmbeddingService | null;
 export interface EmbeddingManagerDeps {
     dataDir: string;
     cfg: MemoryConfig;

package/dist/store/embedding-source.js

@@ -159,7 +159,9 @@ export function makeLocalServiceFactory(installer, downloader, logger, maxInputC
 /** 测试注入缝:子进程资产路径(源码态下 dist 产物不存在,显式指向 resources 源文件)。 */
 childPath, 
 /** 本地推理 token 预算(config `embedding.maxInputTokens`;0/缺省 = 按模型窗口与硬上限推导)。 */
-maxInputTokens) {
+maxInputTokens, 
+/** 崩溃有界自愈开关(config `embedding.respawnOnCrash`;缺省 true,与 LocalEmbeddingService 内默认一致)。 */
+respawnOnCrash) {
     return (modelId) => {
         const entry = catalogById(modelId);
         if (!entry)
@@ -170,6 +172,7 @@ maxInputTokens) {
             logger,
             maxInputChars,
             maxInputTokens,
+            respawnOnCrash,
         });
     };
 }
@@ -250,7 +253,7 @@ export class EmbeddingManager {
     /** 构造绑定真实运行时 loader 的本地服务(deps.makeLocal 可注入,测试替换)。 */
     makeLocalService(modelId) {
         const factory = this.deps.makeLocal ??
-            makeLocalServiceFactory(this.installer, this.downloader, this.deps.logger, this.deps.cfg.embedding.maxInputChars, undefined, this.deps.cfg.embedding.maxInputTokens);
+            makeLocalServiceFactory(this.installer, this.downloader, this.deps.logger, this.deps.cfg.embedding.maxInputChars, undefined, this.deps.cfg.embedding.maxInputTokens, this.deps.cfg.embedding.respawnOnCrash);
         return factory(modelId);
     }
     /** 活切换请求:验证通过即接受,后台执行应用链(进度轮询可见)。 */

package/dist/store/l1.d.ts

@@ -335,10 +335,18 @@ export declare class L1Store {
     }): ConflictPair[];
     /** §C 打上裁决结论(已裁决的不覆盖)。 */
     resolveConflictPending(pairId: string, resolution: ConflictResolution, resolvedAt: string): number;
-    /** 新记忆落盘:JSONL 按天追加(事实源)+ 检索库 upsert + 向量。 */
-    appendNew(records: MemoryRecord[]): Promise<void>;
-    /** 去重 update/merge 产出的记录:只更新检索库(JSONL 事实源不改写,官方语义)。 */
-    upsert(record: MemoryRecord): Promise<void>;
+    /** 新记忆落盘:JSONL 按天追加(事实源)+ 检索库 upsert + 向量。
+     *
+     *  `opts.vectors`:调用方（L1 批内自去重）已算好的向量；非 undefined 位直接复用，
+     *  其余现嵌。长度不等时**整批回落实嵌**（不猜位置，宁可多嵌一次）。 */
+    appendNew(records: MemoryRecord[], opts?: {
+        vectors?: Array<Float32Array | undefined>;
+    }): Promise<void>;
+    /** 去重 update/merge 产出的记录:只更新检索库(JSONL 事实源不改写,官方语义)。
+     *  `opts.vector`:同 `appendNew`，merge 产出的**新正文**通常不复用（调用方不传即现嵌）。 */
+    upsert(record: MemoryRecord, opts?: {
+        vector?: Float32Array;
+    }): Promise<void>;
     /** 活切换嵌入源:同步换底层服务(嵌入源三态切换用)。 */
     setEmbeddingService(svc: EmbeddingService): void;
     /** 向量写入能力是否就绪。`reindex` 在未就绪时**静默短路**成 0/0/0
@@ -500,6 +508,14 @@ export declare class L1Store {
     scanAllMetadata(cb: (recordId: string, metadata: Record<string, unknown> | null) => void): number;
     /** 查询向量(域软门禁用):复用既有嵌入源;失败/未就绪返回 undefined,调用方降级。 */
     embedText(text: string, timeoutMs?: number): Promise<Float32Array | undefined>;
+    /**
+     * 批量取向量（批内自去重用）：走与写侧同一条 `helper.batch`。
+     *
+     * 为什么不用逐条 `embedText`：批内代表项的向量要同时喂给「候选召回」与「写入腿」，
+     * 一次取回才能把「同一条记忆嵌两次」压成一次；且熔断态下 `batch` 统一返回 undefined，
+     * 调用方能自然降级为「只做精确层」，不必各自判错。
+     */
+    embedMany(texts: string[]): Promise<Array<Float32Array | undefined>>;
     /**
      * 去重候选召回(官方 3 级):空库跳过 → 向量优先 → FTS 兜底。
      * 传入 family 时只在同族记录里召回(去重永不跨族);传入 workspaceId 时
@@ -509,7 +525,14 @@ export declare class L1Store {
      * 理由:候选池决定**新的去重决策**,若此处跨工作区,产出的是「项目 B 里看不见、
      * 但已经决定了项目 A 记忆去向」的记录——比不隔离更糟。
      */
-    searchCandidates(query: string, limit: number, family?: MemoryFamily, workspaceId?: string): Promise<MemoryRecord[]>;
+    searchCandidates(query: string, limit: number, family?: MemoryFamily, workspaceId?: string, 
+    /**
+     * 调用方已算好的查询向量（批内自去重场景）：给了就不再内部重嵌一次。
+     * 不传 → 维持旧行为（内部 `helper.query`）。增参不改旧签名，既有调用零改动。
+     */
+    opts?: {
+        queryVector?: Float32Array;
+    }): Promise<MemoryRecord[]>;
     /**
      * 增量重嵌入(embedding 配置变化 / 周期性补齐用):只处理缺失向量的记录,
      * 排除已判定"当前 provider 不可嵌入"的 skip 集。返回写入/失败/跳过数——

package/dist/store/l1.js

@@ -486,8 +486,11 @@ export class L1Store {
     resolveConflictPending(pairId, resolution, resolvedAt) {
         return this.db.resolveConflictPending(pairId, resolution, resolvedAt);
     }
-    /** 新记忆落盘:JSONL 按天追加(事实源)+ 检索库 upsert + 向量。 */
-    async appendNew(records) {
+    /** 新记忆落盘:JSONL 按天追加(事实源)+ 检索库 upsert + 向量。
+     *
+     *  `opts.vectors`:调用方（L1 批内自去重）已算好的向量；非 undefined 位直接复用，
+     *  其余现嵌。长度不等时**整批回落实嵌**（不猜位置，宁可多嵌一次）。 */
+    async appendNew(records, opts) {
         if (records.length === 0)
             return;
         // 写侧标注汇流口(task_3.2):所有新写路径(pipeline / memory_add / import / memport /
@@ -512,7 +515,19 @@ export class L1Store {
         for (const [day, list] of byDay) {
             await appendJsonl(path.join(this.recordsDir, `${day}.jsonl`), list);
         }
-        const vecs = await this.helper.batch(records.map((r) => r.content));
+        const reuse = opts?.vectors;
+        let vecs;
+        if (reuse && reuse.length === records.length && reuse.some((v) => v !== undefined)) {
+            const missing = records.map((_, i) => i).filter((i) => reuse[i] === undefined);
+            const fresh = missing.length > 0 ? await this.helper.batch(missing.map((i) => records[i].content)) : [];
+            vecs = reuse.slice();
+            missing.forEach((ri, k) => {
+                vecs[ri] = fresh[k];
+            });
+        }
+        else {
+            vecs = await this.helper.batch(records.map((r) => r.content));
+        }
         // 单事务批量写:逐条开事务在 WAL FULL 下每条一次 fsync。
         // 双写失败闭环:JSONL 事实源已先行追加,DB 缺行 = 这批记忆检索不可见、
         // 去重候选缺失(重复记忆会累积)。upsert 内部已有逐条 warn,这里升 error
@@ -524,15 +539,16 @@ export class L1Store {
         // 写对称:新增也即时上盘(不阻塞、失败只 warn)——否则「文件树 = 库当前状态」只对删成立。
         this.fireFileSync(records.map((r) => r.id), 'appendNew');
     }
-    /** 去重 update/merge 产出的记录:只更新检索库(JSONL 事实源不改写,官方语义)。 */
-    async upsert(record) {
+    /** 去重 update/merge 产出的记录:只更新检索库(JSONL 事实源不改写,官方语义)。
+     *  `opts.vector`:同 `appendNew`，merge 产出的**新正文**通常不复用（调用方不传即现嵌）。 */
+    async upsert(record, opts) {
         if (!record.family)
             record.family = familyForType(record.type);
         // 写侧标注汇流口(与 appendNew 同口径):merge 分支会继承胜方的 name；
         // 两边都没名字时在这里补上，别让新铸的行继续带空名。
         stampValidity(record, Date.now());
         this.assignMissingNames([record], { persist: false });
-        const vec = (await this.helper.batch([record.content]))[0];
+        const vec = opts?.vector ?? (await this.helper.batch([record.content]))[0];
         if (!this.db.upsertL1(record, vec)) {
             this.logger?.error(`[memory] L1 检索库写入失败 id=${record.id}(JSONL 事实源完好),该记忆暂不可检索,重建可修复`);
         }
@@ -923,6 +939,16 @@ export class L1Store {
     embedText(text, timeoutMs) {
         return this.helper.query(text, timeoutMs);
     }
+    /**
+     * 批量取向量（批内自去重用）：走与写侧同一条 `helper.batch`。
+     *
+     * 为什么不用逐条 `embedText`：批内代表项的向量要同时喂给「候选召回」与「写入腿」，
+     * 一次取回才能把「同一条记忆嵌两次」压成一次；且熔断态下 `batch` 统一返回 undefined，
+     * 调用方能自然降级为「只做精确层」，不必各自判错。
+     */
+    embedMany(texts) {
+        return this.helper.batch(texts);
+    }
     /**
      * 去重候选召回(官方 3 级):空库跳过 → 向量优先 → FTS 兜底。
      * 传入 family 时只在同族记录里召回(去重永不跨族);传入 workspaceId 时
@@ -932,7 +958,12 @@ export class L1Store {
      * 理由:候选池决定**新的去重决策**,若此处跨工作区,产出的是「项目 B 里看不见、
      * 但已经决定了项目 A 记忆去向」的记录——比不隔离更糟。
      */
-    async searchCandidates(query, limit, family, workspaceId) {
+    async searchCandidates(query, limit, family, workspaceId, 
+    /**
+     * 调用方已算好的查询向量（批内自去重场景）：给了就不再内部重嵌一次。
+     * 不传 → 维持旧行为（内部 `helper.query`）。增参不改旧签名，既有调用零改动。
+     */
+    opts) {
         // 治理哨兵(治理 W0 T0.2):标记去重候选路径;治理权重误入即抛(dev/test)。
         return markDedupPath(async () => {
             if (this.db.countL1() === 0)
@@ -940,7 +971,7 @@ export class L1Store {
             const caps = this.db.getCapabilities();
             if (caps.vectorSearch && this.helper.vectorReady()) {
                 try {
-                    const vec = await this.helper.query(query);
+                    const vec = opts?.queryVector ?? (await this.helper.query(query));
                     if (vec) {
                         const hits = this.db.searchL1Vector(vec, limit, family, workspaceId);
                         if (hits.length > 0)
@@ -997,12 +1028,16 @@ export class L1Store {
             }
             const pending = [];
             chunk.forEach((c, j) => {
-                if (isZeroVector(vecs[j])) {
+                // #22 机理刀:断点续试只补「尾部未完段」,头 ack 段的向量随崩溃子进程一起丢了
+                // → embedBatch 对这些位返回空洞(undefined)。这里必须当作「本 chunk 暂未取到向量」跳过
+                // (交后台 backfill 逐条补),否则 undefined 进 isZeroVector 会抛 TypeError 打断整轮重嵌。
+                const vec = vecs[j];
+                if (vec == null || isZeroVector(vec)) {
                     skipped++;
                     skippedNow.push(c.id);
                     return;
                 }
-                pending.push({ id: c.id, embedding: vecs[j] });
+                pending.push({ id: c.id, embedding: vec });
             });
             if (pending.length > 0) {
                 const ok = this.db.updateL1VecBatch(pending);

package/dist/store/local-embedding.d.ts

@@ -24,9 +24,10 @@ export type EmbedWorkerCall = {
 } | {
     type: 'embed';
     texts: string[];
-    priority: boolean;
+    priority: boolean; /** 服务侧关联号(#22 断点续试进度归属;透传回 embedProgress) */
+    cid?: number;
 };
-/** worker → 主线程的应答。 */
+/** worker → 主线程的应答(仅请求-应答配对;embedProgress 是单向实时进度、不在此列,否则并集成员无 ok 会破掉窄化)。 */
 export type EmbedWorkerReply = {
     id: number;
     ok: true;
@@ -41,12 +42,20 @@ export type EmbedWorkerReply = {
     type: 'embedded';
     vectors: Float32Array[];
     tokensMax?: number;
+    ack?: number;
 } | {
     id: number;
     ok: false;
     stage: 'load' | 'infer';
     error: string;
 };
+/** 通道消息全集 = 请求应答 + 单向实时进度(#22 断点续试;progress 带 cid,不进 pending 配对)。 */
+export type EmbedWorkerMessage = EmbedWorkerReply | {
+    id: number;
+    cid?: number;
+    type: 'embedProgress';
+    done: number;
+};
 /** worker 通道抽象(测试缝:注入假实现验证协议与状态机)。 */
 export interface EmbedWorkerChannel {
     request(call: EmbedWorkerCall): Promise<EmbedWorkerReply>;
@@ -54,6 +63,10 @@ export interface EmbedWorkerChannel {
     terminate(): void;
     /** worker 意外崩溃通知(此后所有未决请求已被通道拒绝)。 */
     setOnCrash(cb: (error: string) => void): void;
+    /** 通道是否可用(#22 断点续试判定;假通道不实现,服务侧对 undefined 按「可用」处理)。 */
+    isAlive?(): boolean;
+    /** 指定 cid 的多条目批最后实时断点(#22;failAll 不清进度,崩溃后仍可读)。 */
+    lastProgressFor?(cid: number): number | undefined;
 }
 /**
  * 退出描述归一化(issue #22 取证面):被信号硬杀时 Node 给的是 `code===null` + `signal`,
@@ -85,15 +98,49 @@ export interface LocalEmbeddingOptions {
      * `HARD_CAP_TOKENS` 自动推导。超限只 clamp + warn,不抛错。
      */
     maxInputTokens?: number;
+    /**
+     * 崩溃有界自愈开关(config `embedding.respawnOnCrash`,默认 true)。
+     * 关闭后回到旧行为:崩一次停摆到宿主重启/换源(#22 机理刀前的语义)。
+     */
+    respawnOnCrash?: boolean;
 }
 export declare class LocalEmbeddingService implements EmbeddingService {
     private state;
     private loadError;
-    private readonly channel;
+    private channel;
     private readonly entry;
     private readonly logger?;
+    /** 通道重建上下文(构造期固化;respawn 时原样重建,不重新推导预算)。 */
+    private readonly cfgObj;
+    private readonly useWorker;
+    private readonly workerPath;
+    private readonly childPath;
+    private readonly injectedChannel;
+    private readonly respawnOnCrash;
+    /** 生效 token 预算(留痕用，见 embedding-source 的 recordTokenBudget 调用点)。 */
+    private readonly tokenBudgetTokens;
+    /** 自愈发起时刻滚动窗(60s ≤2 次;只允许 crashCb 单点读写)。 */
+    private readonly respawnTimes;
+    /** 服务侧请求关联号(#22 断点续试:多条目批带 cid,进度按 cid 归属)。 */
+    private nextCid;
+    /** 在飞自愈合流点——非空期间所有崩溃事件归并到同一次重建(防 fork 风暴)。 */
+    private respawnPromise;
     constructor(entry: CatalogEntry, modelDir: string, opts: LocalEmbeddingOptions);
+    /** 真通道工厂(构造与自愈共用同一重建路径;假通道注入缝原样返回同一实例,不重建)。 */
+    private createChannel;
+    /** 60s 滚动窗内是否还允许一次自愈(调用即计入,先占位后重建)。 */
+    private respawnAllowed;
+    /**
+     * 单点自愈：关旧通道→新通道→重预热→markReady。
+     * 不变量：在飞期间 `respawnPromise` 非空且 `state='loading'`（isReady 为假），
+     * 现有 vectorsReady 门/EmbedHelper 降级链天然接管半成品窗口，不加新契约态。
+     */
+    private respawnChannel;
+    /** 自愈在飞时外部请求的等待缝(带超时;超时/失败都让调用方走既有降级链)。 */
+    private awaitRespawn;
     getDimensions(): number;
+    /** 生效的单条 token 预算(=子进程侧 shrinkToBudget 的硬帽;embedding_meta 留痕用)。 */
+    getTokenBudget(): number;
     getProviderInfo(): EmbeddingProviderInfo;
     isReady(): boolean;
     /** 状态(进度展示用)。 */