dsh-prime-memory 0.26.5 → 0.26.6

package/dist/pipeline/slot-migrate.js

@@ -1,4 +1,5 @@
 import { errDetail } from '../util/filelog.js';
+import { readSupersedeMarker } from '../store/supersede.js';
 /** 判定 + 挑选可迁移槽位（纯读，无副作用；面板预览与反刍执行共用）。 */
 export function pickMigratableSlots(slots, l1) {
     if (l1 === undefined)
@@ -6,9 +7,9 @@ export function pickMigratableSlots(slots, l1) {
     const open = slots.filter((s) => s.status === 'open' && s.pinned === true && s.kind === 'rule');
     if (open.length === 0)
         return [];
-    // 一次批量取全部 refs，避免 N 次查询。
+    // 一次批量取全部 refs，避免 N 次查询。存活 = 无退场 marker（门1 解耦同口径）。
     const allRefs = [...new Set(open.flatMap((s) => s.refs ?? []))];
-    const alive = new Set(l1.getByIds(allRefs).filter((r) => r.validTo === undefined || r.validTo === null).map((r) => r.id));
+    const alive = new Set(l1.getByIds(allRefs).filter((r) => readSupersedeMarker(r.metadata) === undefined).map((r) => r.id));
     const out = [];
     for (const s of open) {
         const carrier = (s.refs ?? []).find((r) => alive.has(r));

package/dist/projection/recall.d.ts

@@ -58,6 +58,13 @@ export interface RecallItemView {
      * 读侧据此把「已被摘要取代的旧召回」与「此刻仍在上下文里的召回」区分开。
      */
     superseded?: true;
+    /**
+     * 时效定性快照(task_3.5,expiry-tiering 门2 展示面)：仅在 `expired`/`expired_suspect`
+     * 两档写键(泡泡如实标"已于 X 失效/疑似失效")；current/historical 等缺席=旧帧兼容。
+     */
+    validity?: import('../store/validity.js').ValidityState;
+    /** 现实有效期(ISO)：与 `validity` 同进同退，只在写 validity 时带上。 */
+    validUntil?: string;
 }
 /** 持久态：本会话的活召回 id 集 + 判脏序号。 */
 export interface RecallProjectionState {
@@ -89,13 +96,13 @@ interface SchemaLike<T> {
 }
 /** state 校验（registry 用它挡掉损坏/过期的 checkpoint 行）。 */
 export declare const stateSchema: SchemaLike<RecallProjectionState>;
-/** view 校验（出网前调用；未知键容忍，同 slots 投影的语义边界）。 */
 export declare const viewSchema: SchemaLike<RecallView>;
 /** 投影需要的 L1 只读面（结构化声明，避免跨模块类型耦合）。
- *  判退场要 `validTo`/`metadata`，故直接 Pick 自 MemoryRecord，不在投影里自写时间比较。
+ *  判退场要 `validTo`/`metadata`，时效定性还要 `persistence`/`validFrom`，
+ *  故直接 Pick 自 MemoryRecord，不在投影里自写时间比较。
  *  `name` 是名称蒸馏产出的短标题，优先作为展示标题。 */
 export interface RecallL1Face {
-    getByIds(ids: string[]): Array<Pick<MemoryRecord, 'id' | 'type' | 'content' | 'priority' | 'metadata' | 'validTo' | 'name'>>;
+    getByIds(ids: string[]): Array<Pick<MemoryRecord, 'id' | 'type' | 'content' | 'priority' | 'metadata' | 'validFrom' | 'validTo' | 'persistence' | 'name'>>;
 }
 /** 投影需要的反馈只读面（缺席 = view 不带 rating，旧行为）。 */
 export interface RecallFeedbackFace {

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';
@@ -525,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];
@@ -547,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,
@@ -1352,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,
                 }),
@@ -1750,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 };
@@ -1828,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 = [];
@@ -1847,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,
@@ -1893,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;
@@ -2351,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

@@ -139,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[];
+    };
     /**
      * 记录被物理删除后，把两张**索引表**里指向它的行一并抹掉。
      *
@@ -164,8 +212,11 @@ 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——根据错误分类选不同封顶:
      * - 永久错误(校验/解析):attempts >= GRAPH_JOB_MAX_ATTEMPTS(3) → dead
@@ -191,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` 状态**同步**到给定冲突集。
      *

package/dist/store/graph-store.js

@@ -21,8 +21,10 @@ import { randomBytes } from 'node:crypto';
 import { applyGraphProjection } from '../graph/apply.js';
 import { expandHitRecordIds, searchGraphNodes } from '../graph/search.js';
 import { buildFullView, buildGraphPreview } from '../graph/preview.js';
-import { GRAPH_JOB_BACKOFF_BASE_MS, GRAPH_JOB_BATCH, GRAPH_JOB_MAX_ATTEMPTS, GRAPH_JOB_TRANSIENT_MAX_ATTEMPTS, GRAPH_PRIORITY_BACKFILL, GRAPH_PROJECTOR_VERSION, GRAPH_VEC_SEED_CAP, } from '../graph/types.js';
+import { GRAPH_JOB_BACKOFF_BASE_MS, GRAPH_JOB_BATCH, GRAPH_JOB_MAX_ATTEMPTS, GRAPH_JOB_TRANSIENT_MAX_ATTEMPTS, GRAPH_PRIORITY_BACKFILL, GRAPH_PRIORITY_NEW, GRAPH_PROJECTOR_VERSION, GRAPH_VEC_SEED_CAP, } from '../graph/types.js';
 import { normPersistence } from '../types.js';
+import { classifyValidity, isExitedState, validToSourceOf } from './validity.js';
+import { readSupersedeMarker } from './supersede.js';
 import { isZeroVector, vecToBuffer } from './vec-utils.js';
 const TAG = '[memory][graph]';
 /** 坏 JSON 容忍解析:图谱表列损坏只损失该行派生信息,不抛。 */
@@ -565,8 +567,16 @@ export class GraphStore {
      * 记录跳过。返回实际新建的 job 数。
      */
     queueGraphProjection(recordIds, priority) {
+        return this.queueGraphProjectionDetailed(recordIds, priority).created;
+    }
+    /**
+     * 入队的详细形态(与 `queueGraphProjection` 同一实现,只是把新建 job id 也交出来):
+     * `memory_reproject` 工具面需要 `{queued, jobIds}` 回报,而既有调用方只数 created——
+     * 两个返回形状共享一份去重/分片逻辑,不漂移。
+     */
+    queueGraphProjectionDetailed(recordIds, priority) {
         if (!this.db || recordIds.length === 0)
-            return 0;
+            return { created: 0, jobIds: [] };
         try {
             const db = this.db;
             const ids = [...new Set(recordIds)];
@@ -585,10 +595,10 @@ export class GraphStore {
             }
             const fresh = ids.filter((id) => !blocked.has(id));
             if (fresh.length === 0)
-                return 0;
+                return { created: 0, jobIds: [] };
             const now = new Date().toISOString();
             return this.tx(() => {
-                let created = 0;
+                const jobIds = [];
                 for (let i = 0; i < fresh.length; i += GRAPH_JOB_BATCH) {
                     const batch = fresh.slice(i, i + GRAPH_JOB_BATCH);
                     const jobId = this.newJobId();
@@ -597,14 +607,121 @@ export class GraphStore {
                     for (const id of batch) {
                         db.prepare('INSERT OR REPLACE INTO graph_job_records (record_id, job_id) VALUES (?, ?)').run(id, jobId);
                     }
-                    created++;
+                    jobIds.push(jobId);
                 }
-                return created;
+                return { created: jobIds.length, jobIds };
             });
         }
         catch (err) {
             this.logger?.warn(`${TAG} 投影入队失败(忽略): ${err instanceof Error ? err.message : String(err)}`);
-            return 0;
+            return { created: 0, jobIds: [] };
+        }
+    }
+    /**
+     * 强制重投(计划 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) {
+        if (!this.db || recordIds.length === 0)
+            return { queued: 0, jobIds: [] };
+        const ids = [...new Set(recordIds)];
+        try {
+            this.tx(() => {
+                for (const chunk of chunkOf(ids)) {
+                    const ph = chunk.map(() => '?').join(',');
+                    this.db.prepare(`DELETE FROM graph_projected_records WHERE record_id IN (${ph})`).run(...chunk);
+                }
+            });
+            const r = this.queueGraphProjectionDetailed(ids, GRAPH_PRIORITY_NEW);
+            return { queued: r.created, jobIds: r.jobIds };
+        }
+        catch (err) {
+            this.logger?.warn(`${TAG} 强制重投入队失败(忽略): ${err instanceof Error ? err.message : String(err)}`);
+            return { queued: 0, jobIds: [] };
+        }
+    }
+    /**
+     * 确定性边提案落库面(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) {
+        const fail = (reason) => ({ ok: false, reason, closedEdgeIds: [], edgeIds: [], touchedNodeIds: [] });
+        if (!this.db)
+            return fail('graph-not-ready');
+        const relation = String(opts.relation ?? '').trim();
+        const sourceIds = [...new Set((opts.sourceRecordIds ?? []).map((s) => String(s).trim()).filter((s) => s.length > 0))];
+        if (!opts.fromNodeId || !opts.toNodeId || opts.fromNodeId === opts.toNodeId)
+            return fail('bad-nodes');
+        if (!relation || sourceIds.length === 0)
+            return fail('empty-relation-or-sources');
+        try {
+            return this.tx(() => {
+                const { nodes, edges } = this.loadGraphInTx();
+                const from = nodes.find((n) => n.id === opts.fromNodeId);
+                const to = nodes.find((n) => n.id === opts.toNodeId);
+                if (!from || !to)
+                    return fail('nodes-not-found');
+                const records = this.loadRecordsInTx(sourceIds);
+                if (records.length === 0)
+                    return fail('sources-not-in-l1');
+                const now = opts.now ?? new Date().toISOString();
+                const idFactory = (prefix) => `${prefix}_${Date.now()}_${randomBytes(3).toString('hex')}`;
+                const result = {
+                    reason: 'tool-explicit-proposal',
+                    nodes: [
+                        { ref: 'from', name: from.name, type: from.type, sourceRecordIds: sourceIds, status: 'active' },
+                        { ref: 'to', name: to.name, type: to.type, sourceRecordIds: sourceIds, status: 'active' },
+                    ],
+                    edges: [{ fromRef: 'from', toRef: 'to', relation, sourceRecordIds: sourceIds, status: 'active' }],
+                };
+                const statusBefore = new Map(edges.map((e) => [e.id, e.status]));
+                const outcome = applyGraphProjection({
+                    nodes,
+                    edges,
+                    records,
+                    result,
+                    allowedRecordIds: new Set(records.map((r) => r.id)),
+                    now,
+                    idFactory,
+                });
+                if (outcome.edgeIds.length === 0)
+                    return fail('proposal-dropped-by-validator');
+                const touchedNodes = nodes.filter((n) => outcome.nodeIds.includes(n.id));
+                const touchedEdges = edges.filter((e) => outcome.edgeIds.includes(e.id));
+                this.upsertTouchedInTx(touchedNodes, touchedEdges);
+                const closedEdgeIds = touchedEdges
+                    .filter((e) => e.status === 'superseded' && statusBefore.get(e.id) !== 'superseded')
+                    .map((e) => e.id);
+                const newEdgeIds = touchedEdges.filter((e) => e.status === 'active' && e.relation === relation).map((e) => e.id);
+                this.logger?.info(`${TAG} 确定性边提案落库:${newEdgeIds.length} 边 active,${closedEdgeIds.length} 旧边 superseded(来源 ${sourceIds.length} 条,校验丢弃 ${outcome.dropped} 项)`);
+                return {
+                    ok: true,
+                    closedEdgeIds,
+                    edgeIds: newEdgeIds,
+                    touchedNodeIds: touchedNodes.map((n) => n.id),
+                };
+            }, true);
+        }
+        catch (err) {
+            this.logger?.warn(`${TAG} 确定性边提案失败(整体回滚): ${err instanceof Error ? err.message : String(err)}`);
+            return fail('tx-error');
         }
     }
     /**
@@ -692,10 +809,14 @@ export class GraphStore {
      * 校验)→ 写回 touched 行 → job 置 completed + 登记已投影记录 + 放掉 mapping。
      * job 非 running 态(已完成/已 dead/已回收)一律幂等 no-op;任何一步抛错整体
      * 回滚,不留半写。
+     *
+     * 返回 touched 节点中 active/disputed 的那批(写面向量收尾的输入,G-vec 缺陷修):
+     * 调用方只关心"哪些节点刚被写活",向量补算失败不回滚投影——返回值不参与控制流。
      */
     complete(jobId, result, opts) {
         if (!this.db)
-            return;
+            return [];
+        let touchedVecNodes = [];
         try {
             const db = this.db;
             const now = opts?.now ?? new Date().toISOString();
@@ -721,6 +842,9 @@ export class GraphStore {
                 const touchedNodes = nodes.filter((n) => outcome.nodeIds.includes(n.id));
                 const touchedEdges = edges.filter((e) => outcome.edgeIds.includes(e.id));
                 this.upsertTouchedInTx(touchedNodes, touchedEdges);
+                // 写面收尾的输入(只递交落库后的 active/disputed 节点):墓碑不需要向量,
+                // 读侧 searchNodesByVector 本就按状态闸过滤陈旧向量行。
+                touchedVecNodes = touchedNodes.filter((n) => n.status === 'active' || n.status === 'disputed');
                 db.prepare(`UPDATE graph_projection_jobs SET status = 'completed', error = NULL, updated_time = ? WHERE job_id = ?`).run(now, jobId);
                 for (const id of wanted) {
                     db.prepare('INSERT OR REPLACE INTO graph_projected_records (record_id, projector_version) VALUES (?, ?)').run(id, GRAPH_PROJECTOR_VERSION);
@@ -736,6 +860,7 @@ export class GraphStore {
             // 提交失败:job 仍在 running 态,下次启动 recoverRunning 回收重投
             this.logger?.warn(`${TAG} 投影提交失败(待启动回收重投): ${err instanceof Error ? err.message : String(err)}`);
         }
+        return touchedVecNodes;
     }
     /**
      * 投影失败收尾:attempts 已在 claim 时 +1——根据错误分类选不同封顶:
@@ -874,6 +999,94 @@ export class GraphStore {
             this.logger?.warn(`${TAG} 删除传播失败(忽略): ${err instanceof Error ? err.message : String(err)}`);
         }
     }
+    /**
+     * 退场传播(计划 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) {
+        if (!this.db || changedIds.length === 0)
+            return;
+        try {
+            const { nodes, edges } = this.loadGraph();
+            const sourceIds = new Set();
+            for (const n of nodes)
+                for (const id of n.sourceRecordIds)
+                    sourceIds.add(id);
+            for (const e of edges)
+                for (const id of e.sourceRecordIds)
+                    sourceIds.add(id);
+            if (sourceIds.size === 0)
+                return;
+            // 现读 L1 行(含已退场软删行——主表行一直在,差别在 marker);
+            // 列形状按 l1SelectCols 同款容缺(独立测试夹具/旧库可能没有时间增强列)。
+            const now = Date.now();
+            const byId = new Map();
+            for (const chunk of chunkOf([...sourceIds])) {
+                const ph = chunk.map(() => '?').join(',');
+                for (const r of this.db
+                    .prepare(`SELECT ${l1SelectCols(this.db)} FROM l1_records WHERE record_id IN (${ph})`)
+                    .all(...chunk)) {
+                    byId.set(String(r.record_id), rowToRecord(r));
+                }
+            }
+            /** 单条来源是否处于退场态:row 消失也算(与物理删传播同口径,宁保守勿复活)。 */
+            const exited = (id) => {
+                const rec = byId.get(id);
+                if (!rec)
+                    return true;
+                const state = classifyValidity({
+                    marker: readSupersedeMarker(rec.metadata),
+                    persistence: rec.persistence,
+                    validTo: rec.validTo,
+                    validToSource: validToSourceOf(rec.metadata),
+                    now,
+                });
+                return isExitedState(state);
+            };
+            const allExited = (ids) => ids.length > 0 && ids.every(exited);
+            const allRevived = (ids) => ids.length > 0 && ids.every((id) => byId.has(id) && !exited(id));
+            const toArchive = nodes.filter((n) => (n.status === 'active' || n.status === 'disputed') && allExited(n.sourceRecordIds));
+            const toArchiveEdges = edges.filter((e) => (e.status === 'active' || e.status === 'disputed') && allExited(e.sourceRecordIds));
+            const toRevive = nodes.filter((n) => n.status === 'archived' && allRevived(n.sourceRecordIds));
+            const toReviveEdges = edges.filter((e) => e.status === 'archived' && allRevived(e.sourceRecordIds));
+            if (toArchive.length === 0 && toArchiveEdges.length === 0 && toRevive.length === 0 && toReviveEdges.length === 0)
+                return;
+            const nowIso = new Date(now).toISOString();
+            this.tx(() => {
+                for (const n of toArchive) {
+                    this.db.prepare(`UPDATE graph_nodes SET status = 'archived', updated_time = ? WHERE node_id = ?`).run(nowIso, n.id);
+                }
+                for (const e of toArchiveEdges) {
+                    this.db.prepare(`UPDATE graph_edges SET status = 'archived', updated_time = ? WHERE edge_id = ?`).run(nowIso, e.id);
+                }
+                for (const n of toRevive) {
+                    this.db.prepare(`UPDATE graph_nodes SET status = 'active', updated_time = ? WHERE node_id = ?`).run(nowIso, n.id);
+                }
+                for (const e of toReviveEdges) {
+                    this.db.prepare(`UPDATE graph_edges SET status = 'active', updated_time = ? WHERE edge_id = ?`).run(nowIso, e.id);
+                }
+            });
+            this.logger?.info(`${TAG} 退场传播(重算清扫):${toArchive.length + toArchiveEdges.length} 项标 archived,` +
+                `${toRevive.length + toReviveEdges.length} 项复活(触发记录 ${changedIds.length} 条)`);
+        }
+        catch (err) {
+            this.logger?.warn(`${TAG} 退场传播失败(忽略): ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     /**
      * §C 矛盾冻结:把图谱的 `disputed` 状态**同步**到给定冲突集。
      *