dsh-prime-memory 0.22.1 → 0.24.0

package/dist/config.js

@@ -32,7 +32,7 @@ export function liveSettingsSchema() {
         model: Schema.string().default(''),
         reasoningEffort: Schema.union([...EFFORT_CHOICES]).default(''),
     });
-    return Schema.object({
+    const node = Schema.object({
         enabled: Schema.boolean().default(true),
         capture: Schema.boolean().default(true),
         distill: Schema.boolean().default(true),
@@ -69,6 +69,8 @@ export function liveSettingsSchema() {
         memoryMutate: Schema.boolean().default(false),
         // §C 人工冲突裁决总开关:默认 false(冻结消耗注意力,不可默认全开)
         conflictFreeze: Schema.boolean().default(false),
+        // 轨2 技能结晶总开关(看板可拨):默认 false。开=注册 memory_skill_* 工具 + 注入 active 技能 + skills-* 端点可用。
+        skillsEnabled: Schema.boolean().default(false),
         // 工具分组封印(v0.21.0):false = 该组工具不注册,从模型工具列表消失。
         // 核心读(memory_search/read_scene/receipts/conversation_search)与槽位三件不受控。
         toolRoom: Schema.boolean().default(true),
@@ -76,7 +78,13 @@ export function liveSettingsSchema() {
         toolRuminate: Schema.boolean().default(true),
         toolConflict: Schema.boolean().default(true),
         toolMutate: Schema.boolean().default(true),
-    }).volatile();
+    });
+    // 探测后再标：`Schema.object(...).volatile()` 只在新版 schemastery 上有（格内实测：
+    // cordis/schemastery 4.0.4 有、0.1.5-rc.3 解析到的 4.0.2 没有）。直接调用会让**整插件**
+    // 在老线 load-failure——不是降级，是起不来。未标时读侧走 readLiveRef 的兜底路径：
+    // 开关仍然生效（取宿主注入的冻结值），只是改值需要重启而不是热更。
+    const maybe = node;
+    return (typeof maybe.volatile === 'function' ? maybe.volatile() : node);
 }
 export const memorySchema = Schema.object({
     dataDir: Schema.string().default(''),
@@ -129,6 +137,107 @@ export const memorySchema = Schema.object({
         // 30 天:足够跨过假期与项目间歇,又不至于让互相矛盾的两条记忆长期并列召回。
         timeoutDays: Schema.number().min(0).max(3650).default(30),
     }),
+    // 轨3 memport Connect:默认关(新功能默认关)。scan 为**只读预览**，写库仍走 memory_import。
+    memport: Schema.object({
+        enabled: Schema.boolean().default(false),
+        // 单源扫描上限（防极端大包在事件循环里阻塞 RPC；scan 是手动触发，仍留护栏）。
+        scanMaxRecords: Schema.number().min(0).max(20_000).default(5000),
+    }),
+    // 轨2 技能结晶：默认关 + allowPromote 关（先只计数不晋升）。
+    skills: Schema.object({
+        enabled: Schema.boolean().default(false),
+        inject: Schema.boolean().default(true),
+        allowPromote: Schema.boolean().default(false),
+        minSessions: Schema.number().min(1).max(100).default(3),
+        minEvidence: Schema.number().min(1).max(1000).default(5),
+        maxPerTurnBytes: Schema.number().min(0).max(8192).default(600),
+        maxSkillCatalogBytes: Schema.number().min(0).max(8192).default(2048),
+        excerptChars: Schema.number().min(0).max(4000).default(240),
+        idleArchiveDays: Schema.number().min(0).max(3650).default(90),
+    }),
+    // wing 回填护栏：默认与旧行为一致(300 条 / 120s)，需一次多跑点时调大。
+    backfill: Schema.object({
+        maxRecords: Schema.number().min(1).max(10_000).default(300),
+        timeBudgetMs: Schema.number().min(1000).max(1_800_000).default(120_000),
+    }),
+    /**
+     * 内容路由：默认**开**（用户口径：谈到本仓/dsh 生态的记忆要归到本仓 workspace，
+     * 而不是全托底到 `<dataDir>/memories`）。默认路由表就是用户给的两条归类规则（路径可改，不需改码）。
+     */
+    workspaceSource: Schema.object({
+        enabled: Schema.boolean().default(true),
+        routes: Schema.array(Schema.object({
+            /**
+             * 归到哪个 workspace（**workspace 根**，绝对路径；写入前过 normalizeWorkspacePath）。
+             *
+             * 存的不包含 `.agents/memory`：投射落点由 `targetFor` 算，它会在本值后拼上
+             * `WORKSPACE_SUBDIR = ['.agents','memory']`。旧默认值把它写成了
+             * `E:\test\rewrite-agently\.agents`，于是落点变成 `.agents\.agents\memory\`——
+             * 而 `.agents` 目录确实存在，"目录不存在则退回单根"的护栏救不了这种形状，
+             * 等于在仓里挂一棵没人认领的孤儿树。新增用例钉住这个不变式。
+             */
+            path: Schema.string().default(''),
+            /** 命中任一关键词即归此路（小写子串匹配，已 NFKC 归一）。 */
+            anyOf: Schema.array(Schema.string()).default([]),
+            /** 出现任一排除词则此路不命中（用于「无 dsh 才算非 dsh 项目」）。 */
+            noneOf: Schema.array(Schema.string()).default([]),
+        })).default([
+            {
+                path: 'E:\\test\\rewrite-agently',
+                // 'dsh' 子串已覆盖 mine-dsh-plugins 下所有插件名；把目录名单列出来是因为
+                // 有些记忆只写了"某个插件"而没写 dsh- 前缀，那时这一项才顶用。
+                anyOf: ['dsh', 'mine-dsh-plugins', 'cordis', 'prime-memory', 'brief-sidebar', 'host farm', 'inferglow-dsh'],
+                noneOf: [],
+            },
+            {
+                path: 'E:\\test\\agent-no-dsh',
+                anyOf: ['hanako', 'hanaagent', 'openhanako', 'inferglow', 'pi-agent'],
+                // 同一段内容又谈到 dsh 时属于 dsh 生态（如 Hanako 逆向用于反推 dsh 机制），归 dsh 侧。
+                noneOf: ['dsh'],
+            },
+        ]),
+        maxRecords: Schema.number().min(1).max(10_000).default(300),
+        timeBudgetMs: Schema.number().min(1000).max(1_800_000).default(120_000),
+    }),
+    // md 投射与外部存档：**默认开**（写盘不影响检索，关掉只会让人看不到任何投影文件）。root 空串 = 用默认根（<dataDir>/memories），形状校验在投射器里做。
+    memExport: Schema.object({
+        enabled: Schema.boolean().default(true),
+        root: Schema.string().default(''),
+        maxRecords: Schema.number().min(1).max(10_000).default(300),
+        timeBudgetMs: Schema.number().min(1000).max(1_800_000).default(120_000),
+    }),
+    // P2 反向同步：默认关。文件数护栏比导出的条数护栏宽一些——一次目录扫描的代价
+    // 低于一次全库渲染，但时间预算照同一口径（面板不能被卡住）。
+    mdSync: Schema.object({
+        enabled: Schema.boolean().default(false),
+        maxFiles: Schema.number().min(1).max(20_000).default(2_000),
+        timeBudgetMs: Schema.number().min(1000).max(1_800_000).default(120_000),
+    }),
+    // 使用场景（G1）：默认关；开时抽取 prompt 追加 usageScenario 指令（off 逐字不变）。
+    usageScenario: Schema.object({
+        enabled: Schema.boolean().default(false),
+    }),
+    // 类型叙述模板（G2）：默认**开**；开时抽取 prompt 追加分类型 content 骨架（关时仍逐字不变）。
+    // 默认值从关改开的理由写在上方接口注释：只给定义实测骨架齐备 0/23，
+    // 而"没前因后果就不算可用"是用户定的判据，所以默认值要按可用性定而不是按保守定。
+    narrativeTemplates: Schema.object({
+        enabled: Schema.boolean().default(true),
+    }),
+    // 名称蒸馏（Phase 3）。两个开关的默认值都来自 A/B 实测，不是审美偏好：
+    // `ab-distill.mjs`（真会话）+0.703 骨架齐备 → 默认开；`ab-naming.mjs`（存量改名）
+    // −0.113 → 证明示例不能跨任务复用，所以抽取提示里的那段不注入命名脚本。
+    naming: Schema.object({
+        enabled: Schema.boolean().default(true),
+        fewShot: Schema.boolean().default(true),
+    }),
+    // 召回相关度反馈：默认开（只新增写端点与播报，不改任何既有产物；播报需用户显式打 -1）。
+    recallFeedback: Schema.object({
+        enabled: Schema.boolean().default(true),
+        announce: Schema.boolean().default(true),
+        // 低分沉底/高分上浮默认开（这是打分的常规出口）；0 分硬剔除默认关。
+        affectRank: Schema.boolean().default(true),
+        excludeZero: Schema.boolean().default(false),
+    }),
     recall: Schema.object({
         enabled: Schema.boolean().default(true),
         maxResults: Schema.number().min(1).max(20).default(5),
@@ -221,6 +330,8 @@ export const memorySchema = Schema.object({
         maxSlots: Schema.number().min(1).max(32).default(8),
         maxAlwaysOnBytes: Schema.number().min(128).max(16_384).default(2048),
         maxBodyChars: Schema.number().min(32).max(2048).default(512),
+        // 旧 slot 语义迁移：默认关（不自动碰用户手动 pin 的常驻约定）。
+        migrateLegacy: Schema.boolean().default(false),
     }),
     tools: Schema.boolean().default(true),
     benchControl: Schema.boolean().default(false),

package/dist/conflict-service.d.ts

@@ -39,6 +39,18 @@ export interface ConflictListDeps {
     l1: Pick<L1Store, 'listConflictPending' | 'countConflictPendingUnresolved' | 'getByIds'>;
     /** `conflictFreeze.enabled`。 */
     conflictFreezeEnabled: boolean;
+    /** G3 成熟度旁注用：召回使用统计（缺省按 0 强化）。 */
+    usage?: {
+        get(id: string): {
+            used: number;
+        } | null | undefined;
+    };
+    /** 时效半衰期（天）；≤0 = 衰减关 → aging 视为 null。 */
+    decayHalfLifeDays?: number;
+    /** 人工打分面（可选）：成熟度旁注要吃“最近一笔”，与面板/召回同一口径。 */
+    feedback?: {
+        lastOf(id: string): number | undefined;
+    };
 }
 /**
  * 列出待裁决对。

package/dist/conflict-service.js

@@ -1,4 +1,5 @@
 import { DEFER_MAX } from './store/conflicts.js';
+import { computeMaturity } from './util/maturity.js';
 const OUTCOMES = ['winner', 'loser', 'both', 'defer'];
 function view(partial) {
     return { pair_id: '', outcome: '', resolved_at: '', removed_record_id: '', ...partial };
@@ -150,6 +151,9 @@ export function listConflictPairs(deps, opts = {}) {
     const contentById = new Map();
     // §C 三轴(conflict-3axis):记忆记录自带有效期与持续性,取出来用于裁决视图对比。
     const axisById = new Map();
+    // G3 成熟度旁注：取 priority/updatedAt 供 computeMaturity（读时派生，不落库）。
+    const priorityById = new Map();
+    const updatedAtById = new Map();
     for (const r of deps.l1.getByIds([...ids])) {
         contentById.set(r.id, r.content);
         axisById.set(r.id, {
@@ -157,8 +161,23 @@ export function listConflictPairs(deps, opts = {}) {
             validTo: (r.validTo ?? null),
             persistence: (r.persistence ?? null),
         });
+        priorityById.set(r.id, r.priority ?? 60);
+        updatedAtById.set(r.id, r.updatedAt ?? 0);
     }
     const axisOf = (id) => axisById.get(id) ?? { validFrom: null, validTo: null, persistence: null };
+    // 成熟度（priority + 被用次数 + 老化）——仅帮人工裁决看“哪条更确立”，不参与自动了结。
+    const halfLife = deps.decayHalfLifeDays ?? 0;
+    const maturityOf = (id) => {
+        const aging = halfLife > 0
+            ? Math.max(0.5, Math.pow(0.5, Math.max(0, (Date.now() - (updatedAtById.get(id) ?? 0)) / 86_400_000) / halfLife))
+            : null;
+        return computeMaturity({
+            priority: priorityById.get(id) ?? 60,
+            usage: deps.usage?.get(id) ?? null,
+            agingWeight: aging,
+            mark: deps.feedback?.lastOf(id) ?? null,
+        });
+    };
     const items = pending.map((p) => {
         const w = axisOf(p.winnerId);
         const l = axisOf(p.loserId);
@@ -184,6 +203,8 @@ export function listConflictPairs(deps, opts = {}) {
             // ('hard' / ''),使"旧行经 ALTER 回填"与"读取面兜底"呈现同一个形状。
             conflict_type: p.conflictType ?? 'hard',
             claim_key: p.claimKey ?? '',
+            winner_maturity: maturityOf(p.winnerId),
+            loser_maturity: maturityOf(p.loserId),
         };
     });
     return { enabled: true, total: deps.l1.countConflictPendingUnresolved(), items };
@@ -201,6 +222,7 @@ export function renderConflicts(v) {
         const vf = side === 'winner' ? p.winner_valid_from_ms : p.loser_valid_from_ms;
         const vt = side === 'winner' ? p.winner_valid_to_ms : p.loser_valid_to_ms;
         const ps = side === 'winner' ? p.winner_persistence : p.loser_persistence;
+        const mt = side === 'winner' ? p.winner_maturity : p.loser_maturity;
         const parts = [];
         const vfS = iso(vf);
         const vtS = iso(vt);
@@ -210,6 +232,8 @@ export function renderConflicts(v) {
             parts.push(`有效期止 ${vtS}`);
         if (ps)
             parts.push(`持续性 ${ps}`);
+        if (mt)
+            parts.push(`成熟度 ${mt}`);
         return parts.length ? `   三轴: ${parts.join(' / ')}` : '';
     };
     const rows = v.items.map((p, i) => {

package/dist/contract.d.ts

@@ -103,6 +103,9 @@ export interface MemoryLiveSettings {
     /** §C 人工冲突裁决总开关:true = 去重判定"两边都像对的"时冻结冲突对,停放到待人工裁决区;
      *  false = 默认,冲突按 LLM 的 winner/loser 自动了结。运行时覆盖静态 config 的 conflictFreeze.enabled。 */
     conflictFreeze: boolean;
+    /** 轨2 技能结晶总开关（看板可拨）:true = 注册 memory_skill_* 工具、注入 active 技能、skills-* 端点可用。
+     *  默认 false（新功能默认关）；与部署 cfg.skills.enabled 取或（任一开则生效）。 */
+    skillsEnabled: boolean;
 }
 /** 召回停用原因(session-stats recall.enabled=false 时带出;短路序第一个为假的因子)。 */
 export type RecallDisabledReason = 'deploy' | 'global' | 'session' | 'mode';
@@ -360,6 +363,39 @@ export interface DownloadProgress {
 /** 嵌入源活切换阶段。 */
 export type ApplyPhase = 'idle' | 'installing-runtime' | 'warming' | 'switching' | 'reindexing' | 'done' | 'error';
 /** 重嵌入进度。 */
+/**
+ * 一轮重建跑完后的留痕。
+ *
+ * 为什么必需：进度条只在 `running` 期间存在，而“待补 0 条”的重建会**瞬间跑完**
+ * （l1Total/l0Total 都是 0），界面与“点了什么也没发生”长得一模一样。真机反馈原话就是
+ * “重建索引无法观察进度无进度条、索引重设的效果无法确认”——缺的不是进度，是事后凭证。
+ * 所以这里同时存**重建前后的待补数**：效果就是这两个数的差，不是“我看它转了一下”。
+ */
+export interface ReindexRunSummary {
+    /** 完成时刻(ms epoch)；0 = 从未跑过。 */
+    finishedAt: number;
+    /** 从 startedAt 到完成的毫秒数。 */
+    durationMs: number;
+    /** 本轮实际重嵌条数（L1 + L0 完成数之和）。 */
+    processed: number;
+    /** 两层计划总数（为 0 就是“无事可做”，这不是失败而是本来就同步好了）。 */
+    planned: number;
+    /** 嵌入失败条数（进 skip 集的那些）。 */
+    failed: number;
+    cancelled: boolean;
+    /** 抛出来的整体错误（单层失败不在这里，在 failed 里）。 */
+    error?: string;
+    /** 重建**前**的待补数（-1 = 向量能力不可用）。 */
+    missingBefore: {
+        l1: number;
+        l0: number;
+    };
+    /** 重建**后**的待补数。 */
+    missingAfter: {
+        l1: number;
+        l0: number;
+    };
+}
 export interface ReindexProgressState {
     running: boolean;
     l1Done: number;
@@ -369,6 +405,8 @@ export interface ReindexProgressState {
     startedAt: number;
     cancelled: boolean;
     error?: string;
+    /** 上一次重建的结果（从未跑过则缺省）。 */
+    last?: ReindexRunSummary;
 }
 /** 嵌入源状态视图(embedding-state-get 端点的主体)。 */
 export interface EmbeddingStateView {
@@ -796,6 +834,24 @@ export interface UiRecord {
     retired?: boolean;
     /** 退场原因:`conflict`(裁决) / `superseded`(取代) / `manual`(人工) / `unknown`。未退场为 null。 */
     retiredReason?: string | null;
+    /**
+     * 「正文已被摘要取代」：压缩发生时这条还在本会话召回列表里，它的正文已不在模型上下文。
+     * 与 `retired` **正交**——退场讲“人有没有对它下过裁决”，取代讲“正文还在不在上下文”。
+     * 只在 `dsh-memory/session-recalled` 这条路径上有意义；缺省 = 无此概念（旧服务端）。
+     */
+    superseded?: boolean;
+    /**
+     * 成熟度(G3 读时派生):priority + 被用次数 + 老化权重合成。
+     * 可选字段——旧 client 忽略=向后兼容；不参与存储/快照（纯投影）。
+     */
+    maturity?: 'low' | 'mid' | 'high';
+    /** 使用场景（G1）：从 metadata.dsh_usage_scenario 读出；功能关/无则 undefined。 */
+    usageScenario?: string[];
+    /**
+     * 人给的相关度均值(0..5)；从未被 0..5 打过分为 undefined（**缺席 ≠ 0 分**）。
+     * 读时从 recall-feedback sidecar 派生，不进存储/快照。
+     */
+    userRelevance?: number;
 }
 export interface ListRecordsResponse {
     items: UiRecord[];
@@ -822,6 +878,14 @@ export interface ListRecordsResponse {
         id: string;
         label: string;
     }>;
+    /**
+     * 类型词表目录（pm-name-distill task_1.5：词表单一真源随首屏下发，client 不再手抄
+     * `TYPE_LABELS`；仅 offset===0 时附带）。缺省（旧服务端）时 client 降级显示 type 原值。
+     */
+    typeCatalog?: Array<{
+        id: string;
+        label: string;
+    }>;
 }
 /** dsh-memory/records-delete(面板高权限退场指定记忆;须 memoryMutate 开启)。 */
 export interface RecordsDeleteRequest {
@@ -882,6 +946,30 @@ export interface CleanupRetiredRequest {
 }
 export interface CleanupRetiredResponse {
     dryRun: boolean;
+    /**
+     * 待删/已删清单预览（最多 50 条）。
+     *
+     * `targets` 只是一个计数，人无法从计数判断“这批是不是该删的那批”——物理删除不可逆，
+     * 干跑报告必须能抽看内容。取前 50 条而不是全量：全量会把面板撑爆，而判据只需抽看。
+     */
+    items?: Array<{
+        id: string;
+        name: string;
+        type: string;
+        retiredAt: string;
+    }>;
+    /** 本批之外发生漂移的记录数（只计数、**不中止**）。 */
+    otherChanged?: number;
+    /** 归档正文 `retired.md` 路径（未写 = 空串）。 */
+    archiveMd?: string;
+    /** 投射文件搬运计数（N12；投射面关着时全 0）。 */
+    files?: {
+        moved: number;
+        failed: number;
+        absent: number;
+    };
+    /** 图投影索引表里一并抹掉的行数（F19；图面未装配或不该动时为 0）。 */
+    graphForgotten?: number;
     /** 本次涉及(干跑)或实际处理(真跑)的条数。 */
     targets: number;
     /** 真正物理删除的条数(干跑恒为 0;中止恒为 0)。 */
@@ -1218,6 +1306,9 @@ export interface ConflictPairView {
     loser_valid_from_ms?: number | null;
     loser_valid_to_ms?: number | null;
     loser_persistence?: string | null;
+    /** G3 成熟度旁注（读时派生，仅帮人工看“哪条更确立”，不参与自动裁决）。 */
+    winner_maturity?: 'low' | 'mid' | 'high';
+    loser_maturity?: 'low' | 'mid' | 'high';
     review_state?: 'unseen' | 'deferred';
     /** R1:复看次数(面板据此显示"已复看 N 次");达 `DEFER_MAX` 即钉子户。 */
     defer_count?: number;
@@ -1303,6 +1394,216 @@ export interface ReceiptsResponse {
     items: ReceiptItemView[];
     total: number;
 }
+/** 外部来源视图（轨3 Connect；路径指针，不含正文）。 */
+export interface MemorySourceView {
+    id: string;
+    kind: string;
+    path: string;
+    label?: string;
+    lastScanAt: string;
+    lastImportAt: string;
+    disabled: boolean;
+    status: 'active' | 'retired';
+}
+export interface MemorySourcesListResponse {
+    sources: MemorySourceView[];
+    /** 写门/启用态提示（面板据它显示“导入需开高权限”）。 */
+    memoryMutate: boolean;
+}
+export interface MemorySourcesAddRequest {
+    id: string;
+    kind: string;
+    path: string;
+    label?: string;
+}
+export interface MemorySourcesAddResponse {
+    id: string;
+    created: boolean;
+    notice: string;
+}
+export interface MemorySourcesRetireRequest {
+    id: string;
+    /** true = 恢复为 active；缺省/ false = 退役（不删数据，来源仍可重放）。 */
+    active?: boolean;
+}
+export interface MemorySourcesRetireResponse {
+    changed: boolean;
+    notice: string;
+}
+export interface MemportScanRequest {
+    /** 省略 = 扫描全部启用来源；指定 = 只扫该 id。 */
+    sourceId?: string;
+}
+export interface MemportScanCounts {
+    dup: number;
+    'near-dup': number;
+    'conflict-candidate': number;
+    new: number;
+}
+export interface MemportScanSourceResult {
+    sourceId: string;
+    label?: string;
+    /** 命中的 .mem 包数（只读，未写库）。 */
+    files: number;
+    /** 解析出的总条数（受 scanMaxRecords 上限）。 */
+    total: number;
+    /** 每包校验失败原因（不阻断其余来源）。 */
+    errors: string[];
+    counts: MemportScanCounts;
+    /** 新记录样本预览（正文截断；实际写库走 memory_import，那里才做脱敏）。 */
+    sampleNew: Array<{
+        type: string;
+        content: string;
+    }>;
+}
+export interface MemportScanResponse {
+    /** cfg.memport.enabled——关时 sources 为空并附 notice。 */
+    enabled: boolean;
+    sources: MemportScanSourceResult[];
+    notice?: string;
+}
+/** 技能摘要（轨2 SkillsTab；供人工审阅/晋升/pin/归档）。 */
+export interface SkillView {
+    id: string;
+    title: string;
+    status: 'candidate' | 'active' | 'archived';
+    tier: 'full' | 'excerpt' | 'hint';
+    pinned: boolean;
+    sessionCount: number;
+    updatedAt: string;
+}
+export interface SkillsListResponse {
+    enabled: boolean;
+    /** 自动晋升总闸（allowPromote）；关时 promote 动作会被拒。 */
+    allowPromote: boolean;
+    memoryMutate: boolean;
+    skills: SkillView[];
+}
+export interface SkillsActionRequest {
+    id: string;
+    action: 'promote' | 'archive' | 'pin' | 'unpin' | 'set-tier';
+    tier?: 'full' | 'excerpt' | 'hint';
+    reason?: string;
+}
+export interface SkillsActionResponse {
+    changed: boolean;
+    notice: string;
+}
+/** dsh-memory/session-recalled (G-live)：本会话已注入、未被压缩覆盖的召回集。 */
+export interface SessionRecalledRequest {
+    sessionId: string;
+}
+export interface SessionRecalledResponse {
+    sessionId: string;
+    /** 按召回插入序（旧→新）；复用 UiRecord（含 maturity/usageScenario）。 */
+    records: UiRecord[];
+    /** 词表目录（pill 与面板同源取标签；见 `ListRecordsResponse.typeCatalog`）。 */
+    typeCatalog?: Array<{
+        id: string;
+        label: string;
+    }>;
+}
+/**
+ * dsh-memory/recall-feedback（人在召回卡上打分）。
+ *
+ * 语义边界：`0..5` = 人给的相关度（只聚合、不改写任何排序分）；`-1` = 声明过时，
+ * 服务端会顺手做三件事——退场该记录（软删，可 `records-restore` 恢复）、从本会话
+ * 活召回集摘掉、把“已向模型播报”入队（下一轮一次性告知）。
+ */
+export interface RecallFeedbackRequest {
+    sessionId: string;
+    /** 被打分的那条召回记录 id（必须是本会话活召回集里的，否则拒）。 */
+    id: string;
+    /** -1 或 0..5。 */
+    score: number;
+}
+export interface RecallFeedbackResponse {
+    id: string;
+    score: number;
+    /** 聚合后的反馈条目。 */
+    rating: {
+        last: number;
+        rated: number;
+        mean: number;
+        obsolete: number;
+    };
+    /** 本次是否触发了退场(仅 score=-1)。 */
+    retired: boolean;
+    /** 退场后是否已排入下一轮向模型播报(仅 score=-1 且 cfg.recallFeedback.announce)。 */
+    announced: boolean;
+    /**
+     * 失效联动（N11）的文件侧结果，仅当 `score === -1`、真退场且 `cfg.memExport.enabled` 时出现：
+     * `renamed`（投射文件已改名 `.memory.md.disable`）/ `created`（本来没导出过，新建了凭证）/
+     * `already`（早就是 `.disable`）/ `no-workspace`（归属不明，**没动任何文件**）/ `failed`。
+     * 缺席 = 本次未走文件联动（功能关着或账本未装配）；它不影响 `retired`，退场已成立。
+     */
+    fileDisabled?: string;
+}
+/**
+ * dsh-memory/mem-export / mem-reconcile：md 投射的导出与对账（P1 + N8/N9）。
+ *
+ * 两个都无入参（护栏条数/墙钟来自 config），响应形状直接取存储层的报告类型
+ * ——同一事实源，避开“契约手抄一份然后与实现漂移”。
+ *
+ * 写面要说准：**对账什么都不写**；**导出写文件、写账本，并会回填一次 `l1_records.name`**
+ * （给没名字的记录派生全库唯一的文件身份名，计数在 `named`/`nameFailed`）。那一步只改
+ * `name`：内容、类型、退场态、检索面一律不动，而 `name` 不在 `canonicalRecords` 的快照
+ * 哈希字段表里，所以“导出不得改变库内容”这条护栏仍成立——但“导出不碰库”不成立。
+ */
+export type MemExportRequest = Record<string, never>;
+export type MemExportResponse = import('./store/memory-md-types.js').MemExportResponse;
+export type MemReconcileRequest = Record<string, never>;
+export type MemReconcileResponse = import('./store/memory-md-types.js').ReconcileReport;
+/**
+ * dsh-memory/mem-sync：P2 反向同步（md 文件 → 索引）。
+ *
+ * 与 `mem-reconcile` 的区别是风险不对称：对账**什么都不写**，同步**会写库**（回灌
+ * 文件侧修改、把 `.disable` 对应的记录退场）。所以服务端除了配置门还要高权限门。
+ * 两边都变的那批**两侧都不动**，只在 `pending` 里挂账等人裁决。
+ */
+export type MemSyncRequest = Record<string, never>;
+export type MemSyncResponse = import('./store/memory-md-types.js').MdSyncReport;
+/**
+ * dsh-memory/mem-orphans：P4.4 孤儿投射文件归档。
+ *
+ * 只搬“**账本记着我们写过、但现在没记录映射到这个路径**”的文件（改名/消歧/物理删除都会
+ * 留下这种残片）。账本里没有的来路不明文件**一律不动**——那可能是人放进投射目录等着
+ * 被同步进来的输入。
+ *
+ * `dryRun` **省略即 true**：搬文件在用户眼里与删文件差不离，必须显式要；真搬还需要高权限模式。
+ */
+export interface MemOrphansRequest {
+    dryRun?: boolean;
+}
+export type MemOrphansResponse = import('./store/memory-md-types.js').OrphanReport;
+/**
+ * dsh-memory/workspace-relink：按内容路由把存量记忆归到 workspace。
+ *
+ * 只写 `workspace_id` 列——**不改 `scope`**，所以可见性今天一行不变
+ * （`isScopeVisible` 先看 scope，global 即全可见）；`workspace_id` 不在
+ * `canonicalRecords` 快照哈希字段表里，因此回填不会让旧快照失配。
+ */
+export interface WorkspaceRelinkRequest {
+    /** 缺省 true（干跑）：只看报告不写库。给 `false` 才真写（需高权限）。 */
+    dryRun?: boolean;
+}
+export interface WorkspaceRelinkResponse {
+    dryRun: boolean;
+    /** 本次扫过的记录数（含未命中）。 */
+    scanned: number;
+    /** 路由命中的记录数。 */
+    matched: number;
+    /** 归属已是目标值（幂等重跑时等于 matched）。 */
+    unchanged: number;
+    /** 干跑时“若真跑会写多少条”；真写时恒为 0。 */
+    toWrite: number;
+    /** 实际写入条数（干跑恒 0）。 */
+    written: number;
+    /** 未扫到、下次触发续扫的条数。 */
+    remaining: number;
+    /** 命中记录按归属分布——拿它判断路由表合不合口味。 */
+    byWorkspace: Record<string, number>;
+}
 export interface DshMemoryRequestMap {
     'dsh-memory/stats': Record<string, never>;
     'dsh-memory/token-cost': TokenCostRequest;
@@ -1350,6 +1651,19 @@ export interface DshMemoryRequestMap {
     'dsh-memory/cleanup-retired': CleanupRetiredRequest;
     'dsh-memory/snapshots-list': SnapshotsListRequest;
     'dsh-memory/snapshot-restore': SnapshotRestoreRequest;
+    'dsh-memory/memory-sources-list': Record<string, never>;
+    'dsh-memory/memory-sources-add': MemorySourcesAddRequest;
+    'dsh-memory/memory-sources-retire': MemorySourcesRetireRequest;
+    'dsh-memory/memport-scan': MemportScanRequest;
+    'dsh-memory/skills-list': Record<string, never>;
+    'dsh-memory/session-recalled': SessionRecalledRequest;
+    'dsh-memory/recall-feedback': RecallFeedbackRequest;
+    'dsh-memory/workspace-relink': WorkspaceRelinkRequest;
+    'dsh-memory/mem-export': MemExportRequest;
+    'dsh-memory/mem-reconcile': MemReconcileRequest;
+    'dsh-memory/mem-sync': MemSyncRequest;
+    'dsh-memory/mem-orphans': MemOrphansRequest;
+    'dsh-memory/skills-action': SkillsActionRequest;
 }
 export interface DshMemoryResponseMap {
     'dsh-memory/stats': StatsResponse;
@@ -1398,6 +1712,19 @@ export interface DshMemoryResponseMap {
     'dsh-memory/cleanup-retired': CleanupRetiredResponse;
     'dsh-memory/snapshots-list': SnapshotsListResponse;
     'dsh-memory/snapshot-restore': SnapshotRestoreResponse;
+    'dsh-memory/memory-sources-list': MemorySourcesListResponse;
+    'dsh-memory/memory-sources-add': MemorySourcesAddResponse;
+    'dsh-memory/memory-sources-retire': MemorySourcesRetireResponse;
+    'dsh-memory/memport-scan': MemportScanResponse;
+    'dsh-memory/skills-list': SkillsListResponse;
+    'dsh-memory/session-recalled': SessionRecalledResponse;
+    'dsh-memory/recall-feedback': RecallFeedbackResponse;
+    'dsh-memory/workspace-relink': WorkspaceRelinkResponse;
+    'dsh-memory/mem-export': MemExportResponse;
+    'dsh-memory/mem-reconcile': MemReconcileResponse;
+    'dsh-memory/mem-sync': MemSyncResponse;
+    'dsh-memory/mem-orphans': MemOrphansResponse;
+    'dsh-memory/skills-action': SkillsActionResponse;
 }
 /** 全部端点名(client 调用与 host case 表的共用字面量来源)。 */
 export type DshMemoryEndpoint = keyof DshMemoryResponseMap;

package/dist/domain-gate.d.ts

@@ -47,3 +47,22 @@ export declare function sortByDomainWeight<T extends {
     id: string;
     score: number;
 }>(hits: readonly T[], wingOf: (id: string) => unknown, weights: Record<string, number>): T[];
+/**
+ * G1 使用场景细排(纯函数、**score 不改写**、默认关时不进此路径):
+ * 命中查询词的 usageScenario 记忆上浮；未命中/无场景的记录保持原序(fail-open)。
+ * 保守：只按“命中强度”重排，不引入新相关性判断；无查询词时原样返回。
+ */
+export declare function sortByUsageScenario<T extends {
+    id: string;
+}>(hits: readonly T[], scenariosOf: (id: string) => readonly string[], query: string): T[];
+/**
+ * 人工打分参与排序（纯重排、**score 不改写**）：4/5 上浮、0/1/2 下沉。
+ *
+ * 三条约束：
+ * - 同档内保持进入顺序（稳定排序），所以不会推翻 scopeFence / 场景细排的结果；
+ * - **未打分与 3 分同为中性**（fail-open），全部未打分时输出与输入逐字同序；
+ * - 判据是**最近一笔**而非均值——用户改主意的路径必须存在（先 5 后 0 应当下沉）。
+ */
+export declare function sortByHumanMark<T extends {
+    id: string;
+}>(hits: readonly T[], markOf: (id: string) => number | undefined): T[];