dsh-prime-memory 0.26.5-beta.0 → 0.26.6

package/dist/projection/recall.js

@@ -1,4 +1,5 @@
 import { isRetired } from '../store/supersede.js';
+import { stateOfRecord } from '../store/validity.js';
 export const MEMORY_RECALL_KEY = 'memoryRecall';
 /** view 最多透出条数（最近在上；超出部分只计入 count，防 wire 体量失控）。 */
 export const RECALL_VIEW_CAP = 20;
@@ -43,6 +44,7 @@ export const stateSchema = {
     },
 };
 /** view 校验（出网前调用；未知键容忍，同 slots 投影的语义边界）。 */
+const VALIDITY_STATES_VIEW = ['current', 'historical', 'expired', 'expired_suspect', 'superseded', 'retired'];
 export const viewSchema = {
     parse: (value) => {
         const what = 'memoryRecall.view';
@@ -73,6 +75,12 @@ export const viewSchema = {
                 invalid(at, 'retired 只能是 true 或缺席');
             if (item.superseded !== undefined && item.superseded !== true)
                 invalid(at, 'superseded 只能是 true 或缺席');
+            // 时效标注(task_3.5)：缺席=旧帧容忍；有则必须六态枚举内，validUntil 必字符串。
+            if (item.validity !== undefined && VALIDITY_STATES_VIEW.indexOf(item.validity) < 0) {
+                invalid(at, 'validity 必须是六态之一或缺席');
+            }
+            if (item.validUntil !== undefined)
+                requireString(item.validUntil, at, 'validUntil');
         });
         return value;
     },
@@ -150,6 +158,11 @@ function makeView(state, l1, feedback) {
             ? r.metadata?.dsh_usage_scenario
             : undefined;
         const rating = feedback?.lastOf(id);
+        // 时效标注(task_3.5)：只对"过时两档"写键——current/historical 不必让人看见时效噪声；
+        // 旧帧无此键，读侧缺席即活跃。判定现算（stateOfRecord），不吃落库快照；
+        // 未退场行才会真判过时两档（退场行由 retired 键表达，validity 不再叠加）。
+        const vState = isRetired(r) ? undefined : stateOfRecord(r, Date.now());
+        const showValidity = vState === 'expired' || vState === 'expired_suspect';
         items.push({
             id: r.id,
             type: r.type,
@@ -162,6 +175,7 @@ function makeView(state, l1, feedback) {
             ...(isRetired(r) ? { retired: true } : {}),
             // 已被摘要取代：正文已不在上下文里。与 retired 正交，两者可同时在。
             ...(superseded.has(id) ? { superseded: true } : {}),
+            ...(showValidity ? { validity: vState, validUntil: r.validTo === undefined ? '' : new Date(r.validTo).toISOString() } : {}),
         });
     }
     const next = { rev: state.rev, sessionId: state.sessionId, count: state.ids.length, items };

package/dist/settings.js

@@ -85,6 +85,8 @@ const ALWAYS_ON = {
     redistillEnabled: false,
     mdSyncEnabled: false,
     memportEnabled: false,
+    // 时效分级门2 灰度开关:默认关(注入与改前逐字一致)
+    validityTiering: false,
     // md 投射护栏运行时覆盖:0 = 跟随部署 cfg.memExport.maxRecords（面板上可改）
     mdExportMaxRecords: 0,
     // 回填并行度运行时覆盖:0 = 跟随部署 cfg.backfill.concurrency（概览页滑块可改）
@@ -329,6 +331,7 @@ function resolveSettings(value) {
         redistillEnabled: v.redistillEnabled === true,
         mdSyncEnabled: v.mdSyncEnabled === true,
         memportEnabled: v.memportEnabled === true,
+        validityTiering: v.validityTiering === true,
         // md 投射护栏钳 0~10000（与 live schema 同上限）；0 = 跟随部署默认
         mdExportMaxRecords: Math.min(10_000, Math.max(0, num(v.mdExportMaxRecords))),
         // 回填并行度钳 0~8（与 live schema 同上限）；0 = 跟随部署 cfg.backfill.concurrency

package/dist/stats.d.ts

@@ -183,7 +183,7 @@ export declare function hitToUiRecord(r: {
     scope?: string;
     /** 归属工作区路径（仅 scope='workspace' 时非空）。 */
     workspaceId?: string;
-    /** 退场判据:`valid_to` 闭合即已退场(软删)。由 `listL1`/`getByIds` 透传。 */
+    /** 退场判据:与库侧同源（门1 解耦后 marker 单源，`isRetired`）。由 `listL1`/`getByIds` 透传。 */
     validTo?: number;
 }, extra?: {
     agingWeight?: number | null;

package/dist/stats.js

@@ -26,7 +26,7 @@ import { RECEIPTS_QUERY_LIMIT_MAX, dimensionOf, toReceiptView } from './store/re
 import { getTraceStore } from './store/trace.js';
 import { resolveConflictPair, listConflictPairs } from './conflict-service.js';
 import { sourceAnchorLabels } from './pipeline/anchors.js';
-import { readSupersedeMarker } from './store/supersede.js';
+import { readSupersedeMarker, withSupersedeMarker, isRetired } from './store/supersede.js';
 import { isSnapshotName } from './store/l1-snapshot.js';
 import { WING_CATALOG, WING_FALLBACK } from './types.js';
 import { isRoomSlug } from './metadata-validators.js';
@@ -107,6 +107,8 @@ export const MEMORY_ENDPOINTS = [
     'dsh-memory/conflicts-rejected',
     'dsh-memory/graph-search',
     'dsh-memory/graph-node-get',
+    'dsh-memory/graph-preview',
+    'dsh-memory/graph-cleanup-dead',
     'dsh-memory/scenes',
     'dsh-memory/persona',
     'dsh-memory/log-tail',
@@ -474,6 +476,8 @@ export async function handleEndpoint(endpoint, payload, deps) {
                 return { sessionId, records: [], typeCatalog: typeCatalogEntries() };
             // 压缩水位之上的那批：正文已被摘要取代。与 retired 正交（真实实现见 session-recalled.ts）。
             const superseded = stores.recalled?.supersededOf(sessionId);
+            // 路归因表（record id → 管道串）：不在表里 = 无从归因，不挂 lanes 字段。
+            const laneTab = stores.recalled?.lanesOf(sessionId);
             const halfLife = effectiveCfg(cfg, live).recall?.decayHalfLifeDays ?? 0;
             const byId = new Map(stores.l1.getByIds(ids).map((r) => [r.id, r]));
             const records = ids
@@ -486,7 +490,11 @@ export async function handleEndpoint(endpoint, payload, deps) {
                     userRelevance: stores.feedback?.meanOf(r.id) ?? null,
                     userMark: stores.feedback?.lastOf(r.id) ?? null,
                 });
-                return superseded?.has(r.id) === true ? { ...ui, superseded: true } : ui;
+                let out = superseded?.has(r.id) === true ? { ...ui, superseded: true } : ui;
+                const laneStr = laneTab?.get(r.id);
+                if (laneStr !== undefined && laneStr.length > 0)
+                    out = { ...out, lanes: laneStr.split('|') };
+                return out;
             });
             return { sessionId, records, typeCatalog: typeCatalogEntries() };
         }
@@ -517,7 +525,7 @@ export async function handleEndpoint(endpoint, payload, deps) {
             let retired = false;
             let announced = false;
             // 退场**前**的记录快照（带 workspaceId/name）——失效联动要靠它算落点，
-            // 而 `retire` 只改 `valid_to`，不会动这两列，所以取在退场前后等价，取在前更直白。
+            // 而 `retire` 只写 marker，不会动这两列，所以取在退场前后等价，取在前更直白。
             let rec;
             if (p.score === -1) {
                 rec = stores.l1.getByIds([id])[0];
@@ -539,9 +547,11 @@ export async function handleEndpoint(endpoint, payload, deps) {
                 // （面板无消费方），磁盘凭证的对账走 mem-reconcile。
                 if (retired && rec !== undefined && cfg.memExport?.enabled === true && stores.mdLedger !== undefined) {
                     void disableProjectionFile({
-                        // 传退场**后**的快照：渲染出的 frontmatter 才带 `retired: true`，
-                        // 凭证自己就能说清它为什么存在。
-                        record: { ...rec, validTo: Date.parse(retiredAt) || Date.now() },
+                        // 传退场**后**的快照：门1 解耦后 md 层按 marker 判退场，这里补上同样形状的
+                        // 取代标记，渲染出的 frontmatter 才带 `retired: true`——凭证自己就能说清它为什么存在。
+                        record: withSupersedeMarker(rec.metadata, { at: retiredAt, reason: 'obsolete' }) === rec.metadata
+                            ? rec
+                            : { ...rec, metadata: withSupersedeMarker(rec.metadata, { at: retiredAt, reason: 'obsolete' }) },
                         cfgRoot: cfg.memExport.root,
                         dataDir: deps.dataDir,
                         ledger: stores.mdLedger,
@@ -1344,6 +1354,7 @@ export async function handleEndpoint(endpoint, payload, deps) {
                     redistillEnabled: live?.get()?.redistillEnabled === true,
                     mdSyncEnabled: live?.get()?.mdSyncEnabled === true,
                     memportEnabled: live?.get()?.memportEnabled === true,
+                    validityTiering: live?.get()?.validityTiering === true,
                     mdExportMaxRecords: live?.get()?.mdExportMaxRecords ?? 0,
                     backfillConcurrency: live?.get()?.backfillConcurrency ?? 0,
                 }),
@@ -1742,7 +1753,8 @@ export async function handleEndpoint(endpoint, payload, deps) {
                     ...(Array.isArray(r.metadata?.dsh_keywords) ? { keywords: r.metadata.dsh_keywords.filter((k) => typeof k === 'string' && k !== '') } : {}),
                     ...(Array.isArray(r.metadata?.dsh_usage_scenario) ? { usageScenario: r.metadata.dsh_usage_scenario } : {}),
                     filePath,
-                    retired: r.validTo !== undefined,
+                    // 退场判据与库侧同源（门1:marker 单源，valid_to 只是现实有效期）。
+                    retired: isRetired(r),
                 };
             });
             return { items };
@@ -1820,8 +1832,8 @@ export async function handleEndpoint(endpoint, payload, deps) {
             let targets;
             if (explicit.length > 0) {
                 // 显式 id 也要**复核**是否真的处于已退场态:防止调用方用一个 id 列表
-                // 把活动记忆绕过软删直接物理抹掉(那等于给了一条硬删后门)。
-                targets = explicit.filter((id) => stores.l1.getByIds([id]).some((r) => r.validTo !== undefined));
+                // 把活动记忆绕过软删直接物理抹掉(那等于给了一条硬删后门)。判据 marker 单源(门1)。
+                targets = explicit.filter((id) => stores.l1.getByIds([id]).some((r) => isRetired(r)));
             }
             else {
                 targets = [];
@@ -1839,7 +1851,8 @@ export async function handleEndpoint(endpoint, payload, deps) {
                     id: r.id,
                     name: r.name ?? '',
                     type: r.type,
-                    retiredAt: r.validTo === undefined ? '' : new Date(r.validTo).toISOString(),
+                    // 退场时刻:marker.at 优先;旧版 retire 写的 valid_to 作回退(存量行兼容)。
+                    retiredAt: readSupersedeMarker(r.metadata)?.at ?? (r.validTo === undefined ? '' : new Date(r.validTo).toISOString()),
                 }));
                 const resp = {
                     dryRun: true,
@@ -1885,7 +1898,7 @@ export async function handleEndpoint(endpoint, payload, deps) {
                     id: x.id,
                     name: x.name ?? '',
                     type: x.type,
-                    retiredAt: x.validTo === undefined ? '' : new Date(x.validTo).toISOString(),
+                    retiredAt: readSupersedeMarker(x.metadata)?.at ?? (x.validTo === undefined ? '' : new Date(x.validTo).toISOString()),
                 })),
             };
             return resp;
@@ -2019,6 +2032,27 @@ export async function handleEndpoint(endpoint, payload, deps) {
                 return { node: null, edges: [] };
             return { node, edges: graph.edgesOf(id) };
         }
+        case 'dsh-memory/graph-preview': {
+            // 面板图谱预览:缺省种子推荐榜,seedId 给定展开该邻域(悬挂/不可见→空 seeds 不抛)。
+            // mode==='full' 附全图轻量块(大图星图);非 'full' 一律按缺省——无 full 键零漂移。
+            const p = (payload ?? {});
+            const seedId = typeof p.seedId === 'string' && p.seedId.length > 0 ? p.seedId.slice(0, 200) : undefined;
+            const mode = p.mode === 'full' ? 'full' : undefined;
+            const graph = stores.graph;
+            if (!graph) {
+                const zero = { seeds: [], stats: { nodes: 0, edges: 0, causalEdges: 0, pendingJobs: 0, jobsTotal: 0 } };
+                return mode === 'full' ? { ...zero, full: { nodes: [], edges: [], truncated: false } } : zero;
+            }
+            return graph.buildPreview(seedId, mode);
+        }
+        case 'dsh-memory/graph-cleanup-dead': {
+            const graph = stores.graph;
+            if (!graph)
+                return { removed: 0 };
+            const p = (payload ?? {});
+            const ms = typeof p.olderThanMs === 'number' && p.olderThanMs > 0 ? p.olderThanMs : undefined;
+            return { removed: graph.cleanupDead(ms) };
+        }
         case 'dsh-memory/scenes': {
             // 两族拼接展示(浏览器保持混合视图;路径冲突时后写入的族覆盖显示名,读取仍各自独立)
             const items = [];
@@ -2322,7 +2356,8 @@ export function agingWeightOf(updatedAtMs, halfLifeDays, now = Date.now()) {
     return Math.max(0.5, Math.pow(0.5, ageDays / halfLifeDays));
 }
 export function hitToUiRecord(r, extra) {
-    const retired = r.validTo !== undefined;
+    // 退场判据 marker 单源(门1 解耦,与 `isRetired`/`retiredL1Sql` 同口径)。
+    const retired = isRetired(r);
     const mark = retired ? readSupersedeMarker(r.metadata) : undefined;
     return {
         id: r.id,

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

@@ -63,8 +63,10 @@ export interface InitialEmbedding {
 export declare function remoteCeiling(cfg: MemoryConfig): boolean;
 export declare function resolveInitialEmbedding(cfg: MemoryConfig, sourceStore: EmbeddingSourceStore, downloader: ModelDownloadQueue, makeLocal: (modelId: string) => LocalEmbeddingService | null, logger?: MemoryLogger): Promise<InitialEmbedding>;
 /** 本地服务构造工厂(index.ts 的初始解析与 Manager 共用一份实现,防漂移)。
- *  推理在 worker 线程(见 local-embedding.ts);此处只传 runtime 目录与模型目录。 */
-export declare function makeLocalServiceFactory(installer: RuntimeInstaller, downloader: ModelDownloadQueue, logger?: MemoryLogger, maxInputChars?: number): (modelId: string) => LocalEmbeddingService | null;
+ *  推理在 fork 子进程(见 local-embedding.ts,fix #11);此处只传 runtime 目录与模型目录。 */
+export declare function makeLocalServiceFactory(installer: RuntimeInstaller, downloader: ModelDownloadQueue, logger?: MemoryLogger, maxInputChars?: number, 
+/** 测试注入缝:子进程资产路径(源码态下 dist 产物不存在,显式指向 resources 源文件)。 */
+childPath?: string): (modelId: string) => LocalEmbeddingService | null;
 export interface EmbeddingManagerDeps {
     dataDir: string;
     cfg: MemoryConfig;

package/dist/store/embedding-source.js

@@ -153,14 +153,17 @@ export async function resolveInitialEmbedding(cfg, sourceStore, downloader, make
     return { svc, dims: cfg.embedding.dimensions, providerInfo: svc.getProviderInfo() };
 }
 /** 本地服务构造工厂(index.ts 的初始解析与 Manager 共用一份实现,防漂移)。
- *  推理在 worker 线程(见 local-embedding.ts);此处只传 runtime 目录与模型目录。 */
-export function makeLocalServiceFactory(installer, downloader, logger, maxInputChars) {
+ *  推理在 fork 子进程(见 local-embedding.ts,fix #11);此处只传 runtime 目录与模型目录。 */
+export function makeLocalServiceFactory(installer, downloader, logger, maxInputChars, 
+/** 测试注入缝:子进程资产路径(源码态下 dist 产物不存在,显式指向 resources 源文件)。 */
+childPath) {
     return (modelId) => {
         const entry = catalogById(modelId);
         if (!entry)
             return null;
         return new LocalEmbeddingService(entry, downloader.modelsDir(entry.id), {
             runtimeDir: installer.runtimeDir,
+            childPath,
             logger,
             maxInputChars,
         });

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

@@ -1,4 +1,6 @@
 import type { DatabaseSync } from 'node:sqlite';
+import { buildFullView } from '../graph/preview.js';
+import type { GraphPreviewResult } from '../graph/preview.js';
 import type { GraphEdge, GraphNode, GraphNodeSearchResult, GraphProjectionJob, GraphProjectionResult } from '../graph/types.js';
 import type { MemoryFamily, MemoryLogger, MemoryRecord } from '../types.js';
 /**
@@ -99,6 +101,37 @@ export declare class GraphStore {
      * 宁可漏不可串)。降级/异常返回空数组。
      */
     searchNodes(query: string, limit: number, families?: readonly MemoryFamily[]): GraphNodeSearchResult[];
+    /**
+     * §D 第 3 路存储缝(回链记录 id 序;graphLane 直接消费):词法命中 ∪ 路内向量种子
+     * → 1-hop 边扩展 → 保序去重的 L1 记录 id 序列。
+     *
+     * - **向量种子是路内并集、不是新路**:embedding 由调用方传入(装配层惰性查
+     *   l1.embedText;未就绪/失败传 undefined = 纯词法路,与旧 searchNodes+直连回链
+     *   逐位一致);并集不占 RRF 路数名额,"未接线 = 恰为 2 路"不变量不动;
+     * - **种子序**:词法命中在前、向量种子追加在后(RRF 用 rank,顺序即权重),
+     *   同节点去重;向量种子同样过 visible 族集与 active|disputed 状态闸(宁可漏不可串);
+     * - **1-hop 邻居不按族预筛**:来源记录的跨族由 graphLane 尾部记录级 family/scope
+     *   双闸兜底(与本路既有纪律同源);
+     * - 降级(db 未就绪/空图)返回空数组,不抛。
+     *
+     * 返回记录 id 而非 hits 是刻意的:回链/扩展属于读路径细节,路侧只需排名序列。
+     */
+    searchLaneRecords(query: string, embedding: Float32Array | undefined, limit: number, families?: readonly MemoryFamily[]): readonly string[];
+    /**
+     * 面板图谱预览存储缝(契约 `dsh-memory/graph-preview` 的数据源):
+     * loadGraph 一次 + job 计数(pending/running/failed 未定项与全量分母)传入纯函数。
+     * 降级(db 未就绪)返**全零结构**不抛——预览是展示面,永不拖垮端点。
+     * mode==='full' 时响应附 `full` 轻量块;**缺省时该键缺席**(可选键零漂移纪律,
+     * 不是 undefined 占位——消费方 `'full' in res` 与 JSON 形状双判据都干净)。
+     */
+    buildPreview(seedId?: string, mode?: 'full'): GraphPreviewResult & {
+        full?: ReturnType<typeof buildFullView>;
+    };
+    /**
+     * 清理历史 dead 作业行（纯审计痕迹删除，不影响已重入队的记录）。
+     * olderThanMs: 只删早于 now-olderThanMs 的；缺省删全部 dead。
+     */
+    cleanupDead(olderThanMs?: number): number;
     private newJobId;
     /**
      * 投影入队(按 GRAPH_JOB_BATCH 分片成多个 job;去重下推 SQL):
@@ -106,6 +139,54 @@ export declare class GraphStore {
      * 记录跳过。返回实际新建的 job 数。
      */
     queueGraphProjection(recordIds: readonly string[], priority: number): number;
+    /**
+     * 入队的详细形态(与 `queueGraphProjection` 同一实现,只是把新建 job id 也交出来):
+     * `memory_reproject` 工具面需要 `{queued, jobIds}` 回报,而既有调用方只数 created——
+     * 两个返回形状共享一份去重/分片逻辑,不漂移。
+     */
+    private queueGraphProjectionDetailed;
+    /**
+     * 强制重投(计划 expiry-tiering R10 冻结契约 · 先行刀):
+     * 抹掉 `graph_projected_records` 里这些记录的"已按当前版本投过"凭证,再按
+     * 新蒸馏优先级入队——绕开 `projector_version` 的永久跳过,让"改了 L1 → 图谱跟随"
+     * 有一条不依赖重启/周期 sweep 的纠正通道。
+     *
+     * **不动在途 `graph_job_records` 映射**(与上游 task_7.5 字面的一处刻意偏差,
+     * 理由记入写面计划 findings):claim 在认领时才现读 L1 记录,在途 job 天然投的是
+     * **改后**内容;若把映射一并删掉,同一次调用稍后再来一次就会绕过 PK 去重,
+     * 堆出内容重叠的双 job——保留映射才是"重复调用不堆重 job"的构造性保证。
+     *
+     * 幂等:在途有 job → blocked 集吸收,`created=0`;job 已完成 → 凭证刚被
+     * `complete` 写回,本方法再删再投,是合法的新重投而非堆积。
+     */
+    forceReprojectRecord(recordIds: readonly string[]): {
+        queued: number;
+        jobIds: string[];
+    };
+    /**
+     * 确定性边提案落库面(graph-write-plane R4 兜底支路):把"工具传入的显式边提案"
+     * 当作一次确定性投影输入,经 `applyGraphProjection` **纯函数**校验后在同一事务内
+     * 写回——不是裸 UPDATE graph_edges:validSources 硬校验、同 (from,relation) 换目标
+     * 闭旧边的确定性支路、来源并集封顶,全部复用既有守门代码(R5 不变量由它保证)。
+     *
+     * 提案形态:两端节点按现有 name/type 重提(消歧合并会命中现有节点,不新铸实体),
+     * 边 (from → to, relation) 携调用方给的 sourceRecordIds。claim 同款现读 L1:
+     * allowedRecordIds = 命中的来源记录集,未命中的 id 会被纯函数整条拒掉(返回
+     * ok:false, reason='dropped')——工具面传的"非现存 L1"在这里撞上硬校验,而非静默落库。
+     */
+    applyRelationProposal(opts: {
+        fromNodeId: string;
+        toNodeId: string;
+        relation: string;
+        sourceRecordIds: readonly string[];
+        now?: string;
+    }): {
+        ok: boolean;
+        reason?: string;
+        closedEdgeIds: string[];
+        edgeIds: string[];
+        touchedNodeIds: string[];
+    };
     /**
      * 记录被物理删除后，把两张**索引表**里指向它的行一并抹掉。
      *
@@ -131,13 +212,20 @@ export declare class GraphStore {
      * 校验)→ 写回 touched 行 → job 置 completed + 登记已投影记录 + 放掉 mapping。
      * job 非 running 态(已完成/已 dead/已回收)一律幂等 no-op;任何一步抛错整体
      * 回滚,不留半写。
+     *
+     * 返回 touched 节点中 active/disputed 的那批(写面向量收尾的输入,G-vec 缺陷修):
+     * 调用方只关心"哪些节点刚被写活",向量补算失败不回滚投影——返回值不参与控制流。
      */
-    complete(jobId: string, result: GraphProjectionResult, opts?: CompleteOptions): void;
+    complete(jobId: string, result: GraphProjectionResult, opts?: CompleteOptions): GraphNode[];
     /**
-     * 投影失败收尾:attempts 已在 claim 时 +1——封顶转 dead(放掉 mapping,允许
-     * 重新入队);未封顶转 failed + 指数退避 nextAttemptAt(mapping 保留防重复入队)。
+     * 投影失败收尾:attempts 已在 claim 时 +1——根据错误分类选不同封顶:
+     * - 永久错误(校验/解析):attempts >= GRAPH_JOB_MAX_ATTEMPTS(3) → dead
+     * - 瞬态错误(aborted/timeout/网络):attempts >= GRAPH_JOB_TRANSIENT_MAX_ATTEMPTS(6) → dead
+     * dead 放掉 mapping(允许下次 backfill 重新入队);未封顶转 failed + 指数退避。
      */
-    fail(jobId: string, error: string): void;
+    fail(jobId: string, error: string, opts?: {
+        transient?: boolean;
+    }): void;
     /** 启动回收:上次进程退出时卡在 running 的 job 放回 pending(dispose 缝不永久卡批)。 */
     recoverRunning(): number;
     /** 最近 job 列表(诊断/面板用;未就绪返回空)。 */
@@ -154,6 +242,25 @@ export declare class GraphStore {
      * 之后;按 L1 存活集判定(而非本次删除集合),跨多次删除与历史孤儿一并收敛。
      */
     markSourcesDeleted(deletedIds: readonly string[]): void;
+    /**
+     * 退场传播(计划 expiry-tiering R9 冻结契约 · 先行刀):软删/取代后的图谱
+     * 来源活性重算清扫。
+     *
+     * 与 `markSourcesDeleted` 的分野:那边判"来源 row 是否还活着",对软删(主表行
+     * 一直在)结构性失效;这边判"来源是否全部处于**退场态**"——即
+     * `classifyValidity` ∈ {superseded, retired}。退场判据单源在 validity 层,
+     * 本方不再自写一份 valid_to/marker 比较(写面计划约束 §4)。
+     *
+     * 重算式 sweep(不是逐条事件改写):每次按当前 L1 全量判定候选节点/边,
+     * 双向收敛——
+     * - active/disputed 且来源全部退场(含 row 消失)→ `archived` 墓碑(保留行,
+     *   expand 可见,与物理删传播同落库形态);
+     * - archived 且来源全部复活(row 存在且非退场态)→ 回 `active`(restore 的回药;
+     *   被物理删清空来源的永不满 足此条,不会误复活)。
+     *
+     * `changedIds` 只作早退与诊断日志的口径,不参与判定(判定面 = 全图来源集)。
+     */
+    markSourcesRetired(changedIds: readonly string[]): void;
     /**
      * §C 矛盾冻结:把图谱的 `disputed` 状态**同步**到给定冲突集。
      *