dsh-prime-memory 0.11.0 → 0.12.0

package/dist/config.d.ts

@@ -6,7 +6,7 @@
  */
 import Schema from '@deepseek-ai/schemastery';
 import type { LayerRouteKey, StaticFallbackEntry } from './contract.js';
-import type { ExtractMode } from './types.js';
+import type { ExtractMode, ScopeMode } from './types.js';
 /**
  * 蒸馏思考档位全词汇表(唯一事实源):'' = 自动(模型默认档 → high),
  * 其余为各适配器通用档位词汇(deepseek 认 'off',OpenAI 系是 'none')。
@@ -18,6 +18,10 @@ export interface MemoryConfig {
     dataDir: string;
     /** 新会话的默认记忆档位:auto(双族自动)| chat(个人)| work(工作)。 */
     family: ExtractMode;
+    /** §E 存储作用域(可见范围):`global`(默认,跨工作区可见)| `workspace`(按工作区隔离 work 族)。
+     *  与 `family` **正交**——前者问"这是什么内容",后者问"它该在多大范围内可见"(ADR-0008 条 1)。
+     *  默认 `global` 保证既有部署零漂移:检索侧"是否带工作区标识"即开关,不带即不过滤。 */
+    scope: ScopeMode;
     capture: {
         enabled: boolean;
         /** 助手消息是否剥离代码块(减少嵌入噪声)。 */
@@ -56,6 +60,20 @@ export interface MemoryConfig {
          *  同时为真才执行;图谱是 L1 的可重建投影,关闭不影响记忆主链路。 */
         enabled: boolean;
     };
+    /** §C 矛盾冻结:去重判定"两边都像是对的、机器判不了"时不自动裁决,
+     *  把冲突对停放到待人工裁决区(conflict_pending)。**默认关**——
+     *  冻结消耗人的注意力,不可默认全开。 */
+    conflictFreeze: {
+        /** 总开关。关闭时去重 prompt 与改动前**逐字一致**,冲突分支结构性不可达。 */
+        enabled: boolean;
+        /** 待裁决队列上限(条)。未裁决数达上限时**不再停放**,直接按 LLM 的
+         *  winner/loser 自动了结(仍写 conflict_pending,`resolution='auto'`)。
+         *  语义是「不收新的」而非「偷偷删旧的」——有界性由此结构性成立。 */
+        maxPending: number;
+        /** 超时降级(天):停放超过该天数的待裁决对在下一轮蒸馏开头被自动了结。
+         *  **0 = 不做超时降级**(显式关闭,而非"立刻全部超时")。 */
+        timeoutDays: number;
+    };
     recall: {
         enabled: boolean;
         /** 每步自动召回注入的 L1 条数。 */
@@ -160,6 +178,7 @@ export interface MemoryConfig {
 export declare const memorySchema: Schema<Schemastery.ObjectS<{
     dataDir: Schema<string, string>;
     family: Schema<"chat" | "work" | "auto", "chat" | "work" | "auto">;
+    scope: Schema<string, string>;
     capture: Schema<Schemastery.ObjectS<{
         enabled: Schema<boolean, boolean>;
         stripCodeBlocks: Schema<boolean, boolean>;
@@ -205,6 +224,15 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
     }>, Schemastery.ObjectT<{
         enabled: Schema<boolean, boolean>;
     }>>;
+    conflictFreeze: Schema<Schemastery.ObjectS<{
+        enabled: Schema<boolean, boolean>;
+        maxPending: Schema<number, number>;
+        timeoutDays: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: Schema<boolean, boolean>;
+        maxPending: Schema<number, number>;
+        timeoutDays: Schema<number, number>;
+    }>>;
     recall: Schema<Schemastery.ObjectS<{
         enabled: Schema<boolean, boolean>;
         maxResults: Schema<number, number>;
@@ -421,6 +449,7 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
 }>, Schemastery.ObjectT<{
     dataDir: Schema<string, string>;
     family: Schema<"chat" | "work" | "auto", "chat" | "work" | "auto">;
+    scope: Schema<string, string>;
     capture: Schema<Schemastery.ObjectS<{
         enabled: Schema<boolean, boolean>;
         stripCodeBlocks: Schema<boolean, boolean>;
@@ -466,6 +495,15 @@ export declare const memorySchema: Schema<Schemastery.ObjectS<{
     }>, Schemastery.ObjectT<{
         enabled: Schema<boolean, boolean>;
     }>>;
+    conflictFreeze: Schema<Schemastery.ObjectS<{
+        enabled: Schema<boolean, boolean>;
+        maxPending: Schema<number, number>;
+        timeoutDays: Schema<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: Schema<boolean, boolean>;
+        maxPending: Schema<number, number>;
+        timeoutDays: Schema<number, number>;
+    }>>;
     recall: Schema<Schemastery.ObjectS<{
         enabled: Schema<boolean, boolean>;
         maxResults: Schema<number, number>;

package/dist/config.js

@@ -16,6 +16,12 @@ export const EFFORT_CHOICES = ['', 'off', 'none', 'minimal', 'low', 'medium', 'h
 export const memorySchema = Schema.object({
     dataDir: Schema.string().default(''),
     family: Schema.union(['auto', 'chat', 'work']).default('auto'),
+    // §E 可见范围:默认 global(既有部署不传该键 = 行为与改动前逐字一致)。
+    // **实测**(schemastery):`Schema.union` 对非法值**抛错**——`$.x expected "a" | "b" but got "bogus"`;
+    // `Schema.string()` 则原样透传。ADR-0008 条 4 要求「解析失败不阻断启动」
+    // (历史上 `nullable` 崩溃整棵插件树的教训在案),故此处用 string + 消费侧 `normScope` 归一。
+    // ⚠️ 既有 `family` 仍是 union,存在同款风险(传 'bogus' 会抛)——已登记 findings §17,不在本波修。
+    scope: Schema.string().default('global'),
     capture: Schema.object({
         enabled: Schema.boolean().default(true),
         stripCodeBlocks: Schema.boolean().default(true),
@@ -42,6 +48,16 @@ export const memorySchema = Schema.object({
     graph: Schema.object({
         enabled: Schema.boolean().default(false),
     }),
+    // §C 矛盾冻结:默认关(新功能默认关)。开启后去重决策词表多出 conflict 动作,
+    // 冲突对停放待人工裁决,不再由 LLM 直接 update/merge 覆盖。
+    conflictFreeze: Schema.object({
+        enabled: Schema.boolean().default(false),
+        // 上限给"人会看"留出余量:100 条待裁决 ≈ 连续 5~20 轮蒸馏全在冲突,
+        // 远超正常使用强度;真达到说明该调 prompt 而不是加容量。
+        maxPending: Schema.number().min(0).max(10_000).default(100),
+        // 30 天:足够跨过假期与项目间歇,又不至于让互相矛盾的两条记忆长期并列召回。
+        timeoutDays: Schema.number().min(0).max(3650).default(30),
+    }),
     recall: Schema.object({
         enabled: Schema.boolean().default(true),
         maxResults: Schema.number().min(1).max(20).default(5),

package/dist/conflict-service.d.ts

@@ -0,0 +1,38 @@
+/**
+ * §C 矛盾冻结的**裁决出口**(task_25)。
+ *
+ * 冻结把裁决权交还给人,那么必须有一个"人能把结论说回去"的出口:
+ * 否则待裁决队列是只进不出的黑洞,安全阀(task_24)的自动了结会成为唯一出路——
+ * 那等于把 opt-in 的冻结悄悄退回成"超时后机器自己判"。
+ *
+ * 工具层与 RPC 层共用本模块,保证两条出口的**语义与返回形状完全一致**
+ * (与 `memory_receipts` 一样:同一份 `ReceiptsView` 供工具与端点共用)。
+ */
+import type { L1Store } from './store/l1.js';
+/** 裁决结果的对外形状(snake_case,工具与端点共用)。 */
+export interface ConflictResolutionView {
+    pair_id: string;
+    outcome: string;
+    /** 裁决时刻(ISO)。空串 = 未生效。 */
+    resolved_at: string;
+    /** 因裁决从检索中退场的记录 id(无则空串)。 */
+    removed_record_id: string;
+    notice?: string;
+}
+export interface ConflictResolveDeps {
+    l1: Pick<L1Store, 'listConflictPending' | 'resolveConflictPending' | 'deleteBatch' | 'syncGraphDisputed'>;
+    /** `conflictFreeze.enabled`。未开启时队列恒空,直接给出提示而非静默无操作。 */
+    conflictFreezeEnabled: boolean;
+}
+/**
+ * 裁决一条待裁决对。
+ *
+ * 顺序刻意如此:
+ * ① **先打 `resolved_at` 再退场 loser**。反过来的话,退场成功但打标失败会留下
+ *    "记录已消失、队列里那条仍在待裁决"的状态——人再点一次才发现无据可依。
+ *    打标用 `WHERE resolved_at = ''`,天然防重复裁决:第二次调用拿到 0 行即中止。
+ * ② 退场后才**重算**图谱 `disputed`(派生字段必须由当前事实重算,见 `syncDisputed`)。
+ */
+export declare function resolveConflictPair(deps: ConflictResolveDeps, pairId: string, outcome: string): Promise<ConflictResolutionView>;
+/** 裁决结果的人类可读渲染(工具路径用)。schema 产出的是可选字段,故按部分取值渲染。 */
+export declare function renderConflictResolution(v: Partial<ConflictResolutionView>): string;

package/dist/conflict-service.js

@@ -0,0 +1,65 @@
+const OUTCOMES = ['winner', 'loser', 'both'];
+function view(partial) {
+    return { pair_id: '', outcome: '', resolved_at: '', removed_record_id: '', ...partial };
+}
+/**
+ * 裁决一条待裁决对。
+ *
+ * 顺序刻意如此:
+ * ① **先打 `resolved_at` 再退场 loser**。反过来的话,退场成功但打标失败会留下
+ *    "记录已消失、队列里那条仍在待裁决"的状态——人再点一次才发现无据可依。
+ *    打标用 `WHERE resolved_at = ''`,天然防重复裁决:第二次调用拿到 0 行即中止。
+ * ② 退场后才**重算**图谱 `disputed`(派生字段必须由当前事实重算,见 `syncDisputed`)。
+ */
+export async function resolveConflictPair(deps, pairId, outcome) {
+    const clean = outcome.trim();
+    if (!OUTCOMES.includes(clean)) {
+        return view({
+            pair_id: pairId,
+            outcome: clean,
+            notice: `outcome 必须是 ${OUTCOMES.join(' / ')} 之一:winner(LLM 建议的胜方为真)、loser(败方为真)、both(两者其实是各自独立的事实,都保留)。`,
+        });
+    }
+    if (!deps.conflictFreezeEnabled) {
+        return view({
+            pair_id: pairId,
+            outcome: clean,
+            notice: '矛盾冻结未开启(conflictFreeze.enabled=false):没有待裁决对,无从裁决。',
+        });
+    }
+    const pair = deps.l1.listConflictPending().find((p) => p.pairId === pairId);
+    if (!pair) {
+        return view({
+            pair_id: pairId,
+            outcome: clean,
+            notice: '找不到该待裁决对:pair_id 有误,或它已被裁决(resolved_at 非空的不再接受二次裁决)。',
+        });
+    }
+    const resolvedAt = new Date().toISOString();
+    const removedId = clean === 'winner' ? pair.loserId : clean === 'loser' ? pair.winnerId : '';
+    if (deps.l1.resolveConflictPending(pairId, clean, resolvedAt) === 0) {
+        // 并发/重复调用:这一对在本次读取与本次写入之间被裁决了
+        return view({ pair_id: pairId, outcome: clean, notice: '该对已被裁决,本次未生效(裁决不可覆盖)。' });
+    }
+    if (removedId)
+        await deps.l1.deleteBatch([removedId]);
+    // 图谱 disputed 重算:此刻仍未裁决的对才是争议集,已了结的节点自动复原 active
+    const ids = new Set();
+    for (const p of deps.l1.listConflictPending()) {
+        ids.add(p.winnerId);
+        ids.add(p.loserId);
+    }
+    deps.l1.syncGraphDisputed([...ids]);
+    return view({ pair_id: pairId, outcome: clean, resolved_at: resolvedAt, removed_record_id: removedId });
+}
+/** 裁决结果的人类可读渲染(工具路径用)。schema 产出的是可选字段,故按部分取值渲染。 */
+export function renderConflictResolution(v) {
+    if (v.notice)
+        return v.notice;
+    const outcome = v.outcome ?? '';
+    const label = outcome === 'winner' ? '判定 LLM 建议的胜方为真' : outcome === 'loser' ? '判定败方为真' : '两者都保留(判为各自独立的事实)';
+    const removed = v.removed_record_id
+        ? `\n退场记录:${v.removed_record_id}(已从检索中移除,事实源保留)`
+        : '\n未移除任何记录。';
+    return `已裁决待裁决对 ${v.pair_id ?? ''}\n结论:${outcome}(${label})\n裁决时刻:${v.resolved_at ?? ''}${removed}`;
+}

package/dist/graph/search.d.ts

@@ -9,6 +9,21 @@ export declare const GRAPH_FIELD_WEIGHTS: {
     readonly relations: 3;
     readonly type: 2;
 };
+/**
+ * 图谱命中 → L1 记录 id 序列(§D 第 3 路 RRF 的输入;纯函数,无 I/O)。
+ *
+ * 图谱是**可重建派生投影**,节点/fact 的 `sourceRecordIds` 是它回链 L1 的唯一凭证
+ * (types.ts:6-7)。此处把"节点排名"翻译成"L1 记录排名":
+ *
+ * - **保序**:按命中的 score 降序依次展开来源,先出现的记录 = 更高排名;
+ * - **去重**:同一 L1 记录可能被多个节点/fact 引用,只占首次出现的位置
+ *   (重复占位会凭空抬高该记录在 RRF 里的权重);
+ * - **节点自身来源优先于其 fact 来源**:节点的 sourceRecordIds 是它的身份来源,
+ *   而单个 fact 的来源可能引向与该查询无关的旁支记录;
+ * - **只取 active fact**:superseded 是历史状态,不该把旧记录拉进当前检索结果;
+ * - **不查库**:返回的 id 可能已被删除(墓碑边界),由调用方按"取不到的跳过"处理。
+ */
+export declare function graphHitRecordIds(hits: readonly GraphNodeSearchResult[]): string[];
 /**
  * 图谱节点检索:返回按 score 降序的命中(最多 limit 条;limit 钳制 1~20)。
  * 候选节点 = active | disputed(superseded/archived 不进检索)。

package/dist/graph/search.js

@@ -2,7 +2,25 @@
  * 图谱节点检索(纯函数,无 I/O):字段加权重叠计分 + 可解释命中输出。
  *
  * 与 L1 检索(FTS5/向量)不同,图谱节点量级是"可重建投影"的百~千级,在此
- * 直接内存打分即可,不建倒排索引(>2k 节点再考虑预建——见规划可延后清单)。
+ * 直接内存打分即可,不建倒排索引(>2k 节点再考虑预建)。
+ *
+ * ── 图谱演进阶梯(阈值触发,非按需猜测)──────────────────────────────
+ * 图谱是 L0 → L1 → 图谱 链上的可重建派生投影(不是事实源),故存储引擎**可随时替换,
+ * 且是重建而非迁移**——这是当前不引入图数据库不会锁死将来的核心依据。
+ * 本阶梯把"何时才该升级"固化成可判定的阈值,避免提前引入重型方案:
+ *
+ *   Tier  能力                                          存储      触发阈值                  成本
+ *   T0    邻接表 + 字段加权打分(即本文件)               SQLite    nodes 10²~10³(现状)      已有
+ *   T1    TS 内存 BFS/DFS:k-hop/最短路径/连通分量       **不变**  nodes ≤ ~10k             纯 TS,零 schema 变更
+ *                                                                edges ≤ ~100k(=T1 上限)
+ *   T2    递归 CTE(不物化全图)                          **不变**  图装不进内存              复杂 SQL + 手工防环
+ *   T3    闭包表/物化路径(传递闭包预计算)               **不变**  高频多跳重复查询          写放大,边变更需维护
+ *   T4    嵌入式图引擎(Kuzu 优先,非 Neo4j)              换引擎    T1-T3 全部不足            原生依赖,破坏自包含
+ *
+ * **2k 节点** = 预建倒排索引的检查点(上方既有判断);**10k / 100k** = T1 内存遍历的上限。
+ *
+ * **注意**:10k 节点 / 100k 边是**按内存占用推算的估算值**(10 万边 × ~100 字节 ≈ 10 MB),
+ * **非实测**,待真实规模数据校准。多跳遍历归 TS 纯函数层,**不使用 `WITH RECURSIVE`**。
  *
  * 设计要点:
  * - 分词与 L0/L1 共用 util/text.ts 的 tokenize(jieba 词 ∪ 拉丁词 ∪ CJK 二元组),
@@ -42,6 +60,41 @@ const FIELD_ORDER = ['name', 'aliases', 'tags', 'currentState', 'facts', 'relati
 function factValueText(value) {
     return Array.isArray(value) ? value.join(' ') : value;
 }
+/**
+ * 图谱命中 → L1 记录 id 序列(§D 第 3 路 RRF 的输入;纯函数,无 I/O)。
+ *
+ * 图谱是**可重建派生投影**,节点/fact 的 `sourceRecordIds` 是它回链 L1 的唯一凭证
+ * (types.ts:6-7)。此处把"节点排名"翻译成"L1 记录排名":
+ *
+ * - **保序**:按命中的 score 降序依次展开来源,先出现的记录 = 更高排名;
+ * - **去重**:同一 L1 记录可能被多个节点/fact 引用,只占首次出现的位置
+ *   (重复占位会凭空抬高该记录在 RRF 里的权重);
+ * - **节点自身来源优先于其 fact 来源**:节点的 sourceRecordIds 是它的身份来源,
+ *   而单个 fact 的来源可能引向与该查询无关的旁支记录;
+ * - **只取 active fact**:superseded 是历史状态,不该把旧记录拉进当前检索结果;
+ * - **不查库**:返回的 id 可能已被删除(墓碑边界),由调用方按"取不到的跳过"处理。
+ */
+export function graphHitRecordIds(hits) {
+    const seen = new Set();
+    const out = [];
+    const take = (id) => {
+        if (seen.has(id))
+            return;
+        seen.add(id);
+        out.push(id);
+    };
+    for (const h of hits) {
+        for (const id of h.node.sourceRecordIds)
+            take(id);
+        for (const f of h.node.facts) {
+            if (f.status !== 'active')
+                continue;
+            for (const id of f.sourceRecordIds ?? [])
+                take(id);
+        }
+    }
+    return out;
+}
 /**
  * 图谱节点检索:返回按 score 降序的命中(最多 limit 条;limit 钳制 1~20)。
  * 候选节点 = active | disputed(superseded/archived 不进检索)。

package/dist/hooks/recall.js

@@ -1,6 +1,7 @@
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { RecallDedupeStore } from '../store/recall-dedupe.js';
 import { OccupancyStore } from '../store/occupancy.js';
+import { scopeFilterOf } from '../workspace.js';
 import { applyRecallBudget, raceRecallTimeout, RECALL_EMBED_CAP_MS } from '../util/recall-budget.js';
 import { clearProfileShare, emptyOccupancyLedger, estimateInjectedMessageTokens, estimateStableSectionTokens, recordProfileShare, recordRecallInjection, resetForCompaction, } from '../util/context-occupancy.js';
 import { errDetail } from '../util/filelog.js';
@@ -164,6 +165,9 @@ export function registerRecall(ctx, cfg, stores, logger, live, modes, dataDir) {
                 const hits = await raceRecallTimeout(stores.l1.search(query, cfg.recall.maxResults, {
                     scoreThreshold: cfg.recall.scoreThreshold,
                     family: mode === 'auto' ? undefined : mode,
+                    // §E 可见范围:自动召回是"最没人在看"的一条路径——它静默地往模型上下文里
+                    // 注入记忆。若这里漏了隔离,跨工作区泄漏会发生在每一次对话里而不留痕迹。
+                    workspaceId: scopeFilterOf(cfg.scope, { agent: payload.agent }),
                     // 嵌入内层钳制:给 FTS 降级留出总预算内的时间(远程限 HTTP fetch;本地经 worker 代理 race 放弃)
                     embeddingTimeoutMs: RECALL_EMBED_CAP_MS,
                 }), cfg.recall.timeoutMs);

package/dist/index.d.ts

@@ -1,7 +1,14 @@
 import type { Context } from '@deepseek-ai/cordis';
 import { type MemoryConfig } from './config.js';
 export declare const name = "dsh-memory-plugin";
-/** 硬依赖:蒸馏要用 llm,工具注册要用 tools,召回注入要用 systemPrompt。 */
+/**
+ * 硬依赖:蒸馏要用 llm,工具注册要用 tools,召回注入要用 systemPrompt。
+ * 0.1.5 起 connection.rpc.handle() 把 /rpc 路由登记到 webServer 时按**调用方
+ * fiber** 校验 inject 授权(0.1.1/0.1.2 由 connection 服务自己持有 webServer,
+ * 调用方无需声明)——缺失即 `cannot get property "webServer" without inject`
+ * 致命失败。故声明 connection + webServer;两者在 0.1.1~0.1.5 均存在,
+ * 额外授权在旧版无害(声明式注入只会等这两个服务就绪,不改装配顺序)。
+ */
 export declare const inject: string[];
 /**
  * 插件配置 schema。导出名必须是 `Config`——cordis 运行时只读 plugin.Config
@@ -11,6 +18,7 @@ export declare const inject: string[];
 export declare const Config: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
     dataDir: import("@deepseek-ai/schemastery").default<string, string>;
     family: import("@deepseek-ai/schemastery").default<"chat" | "work" | "auto", "chat" | "work" | "auto">;
+    scope: import("@deepseek-ai/schemastery").default<string, string>;
     capture: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         stripCodeBlocks: import("@deepseek-ai/schemastery").default<boolean, boolean>;
@@ -56,6 +64,15 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
     }>, Schemastery.ObjectT<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
     }>>;
+    conflictFreeze: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        maxPending: import("@deepseek-ai/schemastery").default<number, number>;
+        timeoutDays: import("@deepseek-ai/schemastery").default<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        maxPending: import("@deepseek-ai/schemastery").default<number, number>;
+        timeoutDays: import("@deepseek-ai/schemastery").default<number, number>;
+    }>>;
     recall: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         maxResults: import("@deepseek-ai/schemastery").default<number, number>;
@@ -272,6 +289,7 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
 }>, Schemastery.ObjectT<{
     dataDir: import("@deepseek-ai/schemastery").default<string, string>;
     family: import("@deepseek-ai/schemastery").default<"chat" | "work" | "auto", "chat" | "work" | "auto">;
+    scope: import("@deepseek-ai/schemastery").default<string, string>;
     capture: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         stripCodeBlocks: import("@deepseek-ai/schemastery").default<boolean, boolean>;
@@ -317,6 +335,15 @@ export declare const Config: import("@deepseek-ai/schemastery").default<Schemast
     }>, Schemastery.ObjectT<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
     }>>;
+    conflictFreeze: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        maxPending: import("@deepseek-ai/schemastery").default<number, number>;
+        timeoutDays: import("@deepseek-ai/schemastery").default<number, number>;
+    }>, Schemastery.ObjectT<{
+        enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
+        maxPending: import("@deepseek-ai/schemastery").default<number, number>;
+        timeoutDays: import("@deepseek-ai/schemastery").default<number, number>;
+    }>>;
     recall: import("@deepseek-ai/schemastery").default<Schemastery.ObjectS<{
         enabled: import("@deepseek-ai/schemastery").default<boolean, boolean>;
         maxResults: import("@deepseek-ai/schemastery").default<number, number>;

package/dist/index.js

@@ -37,8 +37,15 @@ import { effectiveCfg } from './pipeline/runner.js';
 import { pendingPathFor } from './store/pending.js';
 import { initTokenCost, resetTokenCost } from './token-cost.js';
 export const name = 'dsh-memory-plugin';
-/** 硬依赖:蒸馏要用 llm,工具注册要用 tools,召回注入要用 systemPrompt。 */
-export const inject = ['llm', 'tools', 'systemPrompt'];
+/**
+ * 硬依赖:蒸馏要用 llm,工具注册要用 tools,召回注入要用 systemPrompt。
+ * 0.1.5 起 connection.rpc.handle() 把 /rpc 路由登记到 webServer 时按**调用方
+ * fiber** 校验 inject 授权(0.1.1/0.1.2 由 connection 服务自己持有 webServer,
+ * 调用方无需声明)——缺失即 `cannot get property "webServer" without inject`
+ * 致命失败。故声明 connection + webServer;两者在 0.1.1~0.1.5 均存在,
+ * 额外授权在旧版无害(声明式注入只会等这两个服务就绪,不改装配顺序)。
+ */
+export const inject = ['llm', 'tools', 'systemPrompt', 'connection', 'webServer'];
 /**
  * 插件配置 schema。导出名必须是 `Config`——cordis 运行时只读 plugin.Config
  * (Standard Schema 接口)做校验与默认值填充;导出 `schema` 会被静默忽略,
@@ -128,7 +135,9 @@ export async function apply(ctx, config) {
     }
     const stores = {
         l0: new L0Store(dataDir, db, embed, logger),
-        l1: new L1Store(dataDir, db, embed, config.recall.strategy, logger, config.recall.decayHalfLifeDays),
+        l1: new L1Store(dataDir, db, embed, config.recall.strategy, logger, config.recall.decayHalfLifeDays, 
+        // §D 第 3 路:图谱回链。图谱不可用时 searchNodes 自带 no-op,不影响双路。
+        (query, limit, family) => db.graphStore.searchNodes(query, limit, family ? [family] : undefined)),
         // L2/L3 分族隔离:各自目录与文件(scenes/chat|work、persona-chat|work.md)
         scenes: {
             chat: new SceneStore(dataDir, 'chat', logger),

package/dist/pipeline/l1.d.ts

@@ -16,4 +16,10 @@ export type FamilyStates = Record<MemoryFamily, MemoryState>;
  * 每条消息按 content 长度 + 64 字符脚手架开销(id/时间戳行)计。
  */
 export declare function chunkByCharBudget(messages: ConversationMessage[], budgetChars: number): ConversationMessage[][];
-export declare function runExtraction(ctx: Context, cfg: MemoryConfig, store: L1Store, states: FamilyStates, pending: ConversationMessage[], background: ConversationMessage[], logger: MemoryLogger, mode: ExtractMode): Promise<ExtractionResult>;
+export declare function runExtraction(ctx: Context, cfg: MemoryConfig, store: L1Store, states: FamilyStates, pending: ConversationMessage[], background: ConversationMessage[], logger: MemoryLogger, mode: ExtractMode, 
+/**
+ * §E 当前工作区标识(由调用方经 `sessionWorkspaceIdOf` 解析;拿不到传 undefined)。
+ * 传 undefined 时行为与改动前**逐字一致**——`cfg.scope='global'` 的既有部署
+ * 永远走这条分支,这是零漂移的构造性保证。
+ */
+workspaceId?: string): Promise<ExtractionResult>;