dsh-layered-memory 0.8.12 → 0.9.0

package/dist/contract.d.ts

@@ -2,7 +2,7 @@
  * RPC 契约单一事实源（types-only，零运行时代码）。
  *
  * 把 host（src/stats.ts 的 case 表）与 client（client/src，浏览器侧）共用的
- * 23 个 `dsh-memory/*` 端点请求/响应类型收敛到本模块——两端各自 `import type`，
+ * 26 个 `dsh-memory/*` 端点请求/响应类型收敛到本模块——两端各自 `import type`，
  * 契约漂移在编译期暴露，而不是等 UI 渲染出 undefined 才发现。
  *
  * 铁律：
@@ -315,6 +315,105 @@ export interface EmbeddingStateView {
     reindex: ReindexProgressState;
     activeNote?: string;
 }
+/** 资产活动条目：L1 记忆 / L2 场景 / L3 画像按更新时间混排（资产视图，非变更审计）。 */
+export interface AssetActivityItem {
+    /** 稳定 id：l1:<recordId> / l2:<family>:<path> / l3:<family>。 */
+    id: string;
+    kind: 'l1' | 'l2' | 'l3';
+    /** new = 首次形成；upd = 蒸馏演进（L1 version>1 / L2 updated>created / L3 恒 upd）。 */
+    verb: 'new' | 'upd';
+    family: MemoryFamily;
+    /** 标题：L1 内容首行截断 / L2 场景名 / L3 画像文件名（本地化装饰在 client 侧）。 */
+    title: string;
+    /** 完整内容（L1 原文 / L2 摘要 + 正文 / L3 画像正文）。 */
+    content: string;
+    createdAt: string | null;
+    updatedAt: string | null;
+    version: number | null;
+    /** L1 来源会话（缺省 default）；L2/L3 恒 null。 */
+    sourceSession: string | null;
+    /** L1 情境名；L2/L3 null。 */
+    scene: string | null;
+    /** L1 的 7 类类型键（persona/episodic/…）；L2/L3 null。 */
+    l1Type: string | null;
+}
+/** dsh-memory/asset-activity（记忆库活动流；游标分页 + 筛选，只读）。 */
+export interface AssetActivityRequest {
+    /** 关键词：L1 走 FTS 索引检索缝（与召回同源）；L2/L3 小数据内存子串匹配。 */
+    query?: string;
+    /** 空/缺省 = 全部类型。 */
+    kind?: '' | 'l1' | 'l2' | 'l3';
+    /** 空/缺省 = 两族混排。 */
+    family?: '' | 'chat' | 'work';
+    /** 时间下限（epoch ms；0/缺省 = 全部）。 */
+    since?: number;
+    /** 1~100，默认 30。 */
+    limit?: number;
+    /** 上一页返回的 opaque 游标；null/缺省 = 第一页。 */
+    cursor?: string | null;
+}
+export interface AssetActivityResponse {
+    items: AssetActivityItem[];
+    /** 还有下一页时非 null（opaque，原样回传）。 */
+    nextCursor: string | null;
+    /** 检索路径触达上限（200），结果可能不完整。 */
+    truncated: boolean;
+}
+/** dsh-memory/workspace-overview（总览单发聚合，免去 client N+1 拉取）。 */
+export interface WorkspaceOverviewResponse {
+    ok: true;
+    degraded: boolean;
+    /** 检索能力位（sessionInfo 缺席时 null = 未知，不渲染该行）。 */
+    retrieval: 'hybrid' | 'vector' | 'keyword' | 'none' | null;
+    pendingExtract: number;
+    l0Today: number;
+    l1Count: number;
+    sceneCount: number;
+    personaChars: number;
+    /** 全部派生层为空（引导式空状态判据）。 */
+    empty: boolean;
+    lastExtractAt: string | null;
+    lastL2At: string | null;
+    lastL3At: string | null;
+    /** 本周蒸馏成本（token-cost 周窗口；无调用 null）。 */
+    week: {
+        calls: number;
+        outputTokens: number;
+        reasoningTokens: number;
+    } | null;
+    /** 最近活动（asset-activity 同口径前 5 条）。 */
+    recent: AssetActivityItem[];
+}
+/** dsh-memory/runtime-insights（洞察：活动/召回只读聚合；成本子页直接用 token-cost）。 */
+export interface RuntimeInsightsResponse {
+    ok: true;
+    /** 近 7 天（含当日）逐日资产活动，day 为 ISO 日期 YYYY-MM-DD（与 L1 SQL 口径一致）。 */
+    activityDays: Array<{
+        day: string;
+        l1: number;
+        l2: number;
+        l3: number;
+    }>;
+    /** 蒸馏调用与失败（进程生命周期累计计数器，llm-usage 口径）。 */
+    distill: Array<{
+        layer: string;
+        calls: number;
+        failures: number;
+    }>;
+    recall: {
+        /** 有过检索的会话数 + 全量累计（进程内召回注册表；重启归零）。 */
+        sessions: number;
+        injectedTurns: number;
+        hitTurns: number;
+        totalHits: number;
+        timeouts: number;
+        suppressedRecalls: number;
+        /** 停用侧写：全局注入开关当前态 + 持久化会话分布。 */
+        globalRecall: boolean;
+        sessionsModeOff: number;
+        sessionsWriteOnly: number;
+    };
+}
 /** dsh-memory/stats */
 export interface StatsResponse extends MemoryStats {
 }
@@ -340,6 +439,12 @@ export interface SessionModeGetResponse {
     /** host 解析后的注入生效值（会话覆盖 ?? 全局开关）：pill 面文直接消费，
      *  client 无需另知全局开关。 */
     recallResolved: boolean;
+    /** 暂停恢复快照（UI 重构分散式）：进入 off 档时记录的暂停前范围与注入覆盖，
+     *  非 off 档为 null；旧 host 缺省该字段时 client 回退默认档显示。 */
+    resume?: {
+        scope: MemoryMode;
+        recall: boolean | null;
+    } | null;
 }
 export interface SessionModeSetRequest {
     sessionId: string;
@@ -355,6 +460,11 @@ export interface SessionModeSetResponse {
     recall: boolean | null;
     /** 设置后的注入生效值（client 面文直接消费；清除覆盖后由 host 告知解析结果）。 */
     recallResolved: boolean;
+    /** 同 get：暂停恢复快照（进入 off 时写入，恢复/覆盖变更时清空）。 */
+    resume?: {
+        scope: MemoryMode;
+        recall: boolean | null;
+    } | null;
 }
 /** dsh-memory/session-stats（悬浮卡信息区；热路径端点）。 */
 export interface SessionStatsRequest {
@@ -619,6 +729,9 @@ export interface EmbeddingModelDeleteResponse {
 }
 export interface DshMemoryRequestMap {
     'dsh-memory/stats': Record<string, never>;
+    'dsh-memory/workspace-overview': Record<string, never>;
+    'dsh-memory/asset-activity': AssetActivityRequest;
+    'dsh-memory/runtime-insights': Record<string, never>;
     'dsh-memory/token-cost': TokenCostRequest;
     'dsh-memory/session-mode-get': SessionModeGetRequest;
     'dsh-memory/session-mode-set': SessionModeSetRequest;
@@ -644,6 +757,9 @@ export interface DshMemoryRequestMap {
 }
 export interface DshMemoryResponseMap {
     'dsh-memory/stats': StatsResponse;
+    'dsh-memory/workspace-overview': WorkspaceOverviewResponse;
+    'dsh-memory/asset-activity': AssetActivityResponse;
+    'dsh-memory/runtime-insights': RuntimeInsightsResponse;
     'dsh-memory/token-cost': TokenCostResponse;
     'dsh-memory/session-mode-get': SessionModeGetResponse;
     'dsh-memory/session-mode-set': SessionModeSetResponse;

package/dist/hooks/recall.d.ts

@@ -45,6 +45,8 @@ export interface RecallHooks {
     invalidateProfile(): void;
     /** 会话召回统计只读视图（未发生过检索的会话返回 undefined）。 */
     stats(sessionId: string): RecallSessionStats | undefined;
+    /** 全量会话召回统计（工作台洞察聚合；进程内注册表快照，重启归零）。 */
+    statsAll(): RecallSessionStats[];
     /** 记忆占用账本只读出口：内存优先，miss 时从流水复生（重启后历史会话）；从未注入返回 null。 */
     occupancy(sessionId: string): OccupancyLedger | null;
     /**

package/dist/hooks/recall.js

@@ -362,6 +362,8 @@ export function registerRecall(ctx, cfg, stores, logger, live, modes, dataDir) {
     return {
         invalidateProfile,
         stats: (id) => recallStats.get(id),
+        /** 全量会话召回统计（工作台洞察聚合；进程内注册表深拷贝，重启归零）。 */
+        statsAll: () => Array.from(recallStats.values(), (s) => ({ ...s })),
         /** 占用账本只读出口：内存优先，miss 时从流水复生（重启后历史会话）；从未注入返回 null。 */
         occupancy: (id) => {
             const led = occupancyByAgent.get(id) ?? occupancyStore.load(id);

package/dist/index.js

@@ -313,6 +313,8 @@ export async function apply(ctx, config) {
         runnerView: (sid, mode) => runner.sessionView(sid, mode),
         l0Count: (sid) => stores.l0.countBySession(sid),
         capabilities: () => db.getCapabilities(),
+        // 工作台洞察聚合（runtime-insights；进程内注册表读取，同样零文件 I/O）
+        recallStatsAll: () => recall.statsAll(),
     });
     // bench 控制服务（config.benchControl 门控，默认关）：仅基准/调试部署注册，
     // 供同进程的 bench-runner lifecycle 赛道触发 rebuild / 设置会话档位

package/dist/stats.d.ts

@@ -49,6 +49,8 @@ export interface SessionInfoSource {
         ftsSearch: boolean;
         vectorSearch: boolean;
     };
+    /** 全量会话召回统计（工作台洞察聚合；缺省 = 装配未提供，洞察召回区隐藏计数）。 */
+    recallStatsAll?(): RecallSessionStats[];
 }
 import type { MemoryOccupancy } from './contract.js';
 export type { MemoryStats } from './contract.js';

package/dist/stats.js

@@ -16,6 +16,7 @@ import { buildRouteChain, decideSendableEffort, LAYER_DEFAULT_BUDGETS, layerChai
 import { projectDistillChain, validateDistillChain } from './settings.js';
 import { errDetail } from './util/filelog.js';
 import { snapshotTokenCost } from './token-cost.js';
+import { buildRuntimeInsights, buildWorkspaceOverview, collectAssetActivity, decodeCursor } from './workspace-aggregates.js';
 const require = createRequire(import.meta.url);
 export const PLUGIN_VERSION = require('../package.json').version;
 /** 注册状态 RPC（web 侧 connection 服务可选，缺失时跳过，不影响插件主体）。 */
@@ -150,6 +151,44 @@ async function handleEndpoint(endpoint, payload, deps) {
     switch (endpoint) {
         case 'dsh-memory/stats':
             return buildStats(cfg, stores, status);
+        // ── 工作台聚合（UI 重构分散式；只读，装配见 workspace-aggregates.ts） ──
+        case 'dsh-memory/workspace-overview': {
+            const base = await buildStats(cfg, stores, status);
+            const caps = sessionInfo?.capabilities();
+            const retrieval = caps
+                ? caps.vectorSearch
+                    ? caps.ftsSearch
+                        ? 'hybrid'
+                        : 'vector'
+                    : caps.ftsSearch
+                        ? 'keyword'
+                        : 'none'
+                : null;
+            const weekWin = snapshotTokenCost('day', 0).windows.find((w) => w.range === 'week');
+            return buildWorkspaceOverview(stores, base, weekWin && weekWin.calls > 0 ? weekWin : null, retrieval);
+        }
+        case 'dsh-memory/asset-activity': {
+            const p = (payload ?? {});
+            if (p.query !== undefined && p.query.length > 4096)
+                throw new Error('query 过长（≤4096 字符）');
+            const kind = p.kind === 'l1' || p.kind === 'l2' || p.kind === 'l3' ? p.kind : '';
+            const family = p.family === 'chat' || p.family === 'work' ? p.family : '';
+            // 钳到 Date 可表示范围（超 8.64e15ms 会令 toISOString 抛 RangeError，回退=不过滤）
+            const sinceNum = Number(p.since);
+            const since = Number.isFinite(sinceNum) && sinceNum > 0 && sinceNum <= 8.64e15 ? sinceNum : 0;
+            const limit = Math.min(Math.max(Number(p.limit) || 30, 1), 100);
+            const offset = Math.min(decodeCursor(typeof p.cursor === 'string' ? p.cursor : null), 1_000_000);
+            return collectAssetActivity(stores, {
+                query: (p.query ?? '').trim(),
+                kind,
+                family,
+                sinceMs: since,
+                limit,
+                offset,
+            });
+        }
+        case 'dsh-memory/runtime-insights':
+            return buildRuntimeInsights(stores, sessionInfo, modes, live);
         case 'dsh-memory/token-cost': {
             const p = (payload ?? {});
             const granularity = p.granularity === 'week' || p.granularity === 'month' ? p.granularity : 'day';
@@ -174,6 +213,7 @@ async function handleEndpoint(endpoint, payload, deps) {
                 defaultMode: modes.default,
                 recall: modes.getRecall(sessionId) ?? null,
                 recallResolved: modes.resolvedRecall(sessionId, globalRecall),
+                resume: modes.getResume(sessionId),
             };
             return v;
         }
@@ -206,6 +246,7 @@ async function handleEndpoint(endpoint, payload, deps) {
                 mode: p.mode,
                 recall: modes.getRecall(sessionId) ?? null,
                 recallResolved: modes.resolvedRecall(sessionId, s?.recall ?? true),
+                resume: modes.getResume(sessionId),
             };
             return v;
         }

package/dist/store/l1.d.ts

@@ -54,17 +54,23 @@ export declare class L1Store {
      * 回填（FTS 表无该列；候选池 ≤ limit×3 条主键查询，微秒级）。关闭时零开销。
      */
     private applyDecay;
-    /** 浏览列表（UI 用）：无关键词时按更新时间倒序分页。 */
+    /** 浏览列表（UI 用）：无关键词时按更新时间倒序分页；since 为 ISO 时间下限（可选）。 */
     list(opts: {
         type?: string;
         scene?: string;
         family?: string;
+        since?: string;
         limit: number;
         offset: number;
     }): {
         items: MemoryRecord[];
         total: number;
     };
+    /** 近 N 天逐日更新计数（工作台活动图；索引化 GROUP BY）。 */
+    countByDay(sinceIso: string): Array<{
+        day: string;
+        n: number;
+    }>;
     /** 场景名去重列表（UI 筛选器数据源）。 */
     distinctScenes(): string[];
     /**

package/dist/store/l1.js

@@ -184,10 +184,14 @@ export class L1Store {
         }
         return applyDecayWeight(hits, this.decayHalfLifeDays, (h) => updatedAtById.get(h.id));
     }
-    /** 浏览列表（UI 用）：无关键词时按更新时间倒序分页。 */
+    /** 浏览列表（UI 用）：无关键词时按更新时间倒序分页；since 为 ISO 时间下限（可选）。 */
     list(opts) {
         return this.db.listL1(opts);
     }
+    /** 近 N 天逐日更新计数（工作台活动图；索引化 GROUP BY）。 */
+    countByDay(sinceIso) {
+        return this.db.countL1ByDay(sinceIso);
+    }
     /** 场景名去重列表（UI 筛选器数据源）。 */
     distinctScenes() {
         return this.db.distinctL1Scenes();

package/dist/store/persona.d.ts

@@ -9,6 +9,8 @@ export declare class PersonaStore {
     init(): Promise<void>;
     /** 读取正文（剥离场景导航部分）。 */
     read(): Promise<string | undefined>;
+    /** 文件 mtime（epoch ms；无画像文件 null）——工作台资产活动流的 L3 时间源。 */
+    mtime(): Promise<number | null>;
     /** 写入正文（保留已有导航段则拼回尾部）。 */
     write(body: string): Promise<void>;
 }

package/dist/store/persona.js

@@ -38,6 +38,15 @@ export class PersonaStore {
             return undefined;
         return stripSceneNavigation(raw).trim() || undefined;
     }
+    /** 文件 mtime（epoch ms；无画像文件 null）——工作台资产活动流的 L3 时间源。 */
+    async mtime() {
+        try {
+            return (await fs.stat(this.file)).mtimeMs;
+        }
+        catch {
+            return null;
+        }
+    }
     /** 写入正文（保留已有导航段则拼回尾部）。 */
     async write(body) {
         const raw = await readTextIfExists(this.file);

package/dist/store/scenes.d.ts

@@ -1,4 +1,7 @@
 import type { MemoryFamily, MemoryLogger, SceneSummary } from '../types.js';
+/** 场景文件 META 块标记（工作台活动流剥正文复用，保持单一事实源）。 */
+export declare const META_START = "-----META-START-----";
+export declare const META_END = "-----META-END-----";
 export declare class SceneStore {
     private readonly logger?;
     private readonly dir;

package/dist/store/scenes.js

@@ -10,8 +10,9 @@ import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
 import { atomicWriteText, ensureDir, readTextIfExists } from './io.js';
 import { NAV_HEADER } from './persona.js';
-const META_START = '-----META-START-----';
-const META_END = '-----META-END-----';
+/** 场景文件 META 块标记（工作台活动流剥正文复用，保持单一事实源）。 */
+export const META_START = '-----META-START-----';
+export const META_END = '-----META-END-----';
 const DELETED_MARKER = '[DELETED]';
 export class SceneStore {
     logger;

package/dist/store/session-modes.d.ts

@@ -26,7 +26,20 @@ export declare class SessionModeStore {
     setRecall(sessionId: string, recall: boolean | undefined): void;
     /** 注册档位切换回调（同步调用；回调异常只记日志不阻断写穿）。 */
     setModeChangeHandler(cb: (sessionId: string, oldMode: MemoryMode, newMode: MemoryMode) => void): void;
-    /** 设置会话档位（写穿持久化；持久化失败保持内存态生效）。 */
+    /** 暂停恢复快照（无则 null）。 */
+    getResume(sessionId: string): {
+        scope: 'auto' | 'chat' | 'work';
+        recall: boolean | null;
+    } | null;
+    /** 停用侧分布（工作台洞察，只读计数）：off = 档位暂停会话；wo = 注入覆盖只写
+     *  （recall=false 且档位未停——两态互斥计数，与召回四因子短路序对齐）。 */
+    countStates(): {
+        off: number;
+        wo: number;
+    };
+    /** 设置会话档位（写穿持久化；持久化失败保持内存态生效）。
+     *  暂停语义（UI 重构）：非 off → off 记录恢复快照（暂停前范围 + 当前注入覆盖）；
+     *  off → 非 off 清空快照（恢复）。 */
     set(sessionId: string, mode: MemoryMode): void;
     /** 等待在途持久化写完成（测试/停机用）。 */
     flush(): Promise<void>;

package/dist/store/session-modes.js

@@ -46,6 +46,12 @@ export class SessionModeStore {
                 mode: entry.mode,
                 // 非布尔视为损坏丢弃（= 跟随全局）；旧文件无此键同款兼容
                 recall: typeof entry.recall === 'boolean' ? entry.recall : undefined,
+                // 恢复快照：scope 必须是非 off 档、recall 必须是布尔或 null，否则整块丢弃
+                resume: entry.resume &&
+                    ['auto', 'chat', 'work'].includes(entry.resume.scope) &&
+                    (typeof entry.resume.recall === 'boolean' || entry.resume.recall === null)
+                    ? { scope: entry.resume.scope, recall: entry.resume.recall }
+                    : undefined,
                 updatedAt: entry.updatedAt ?? now,
             });
             count++;
@@ -75,6 +81,7 @@ export class SessionModeStore {
         this.entries.set(sessionId, {
             mode: entry?.mode ?? this.loaded,
             recall,
+            resume: entry?.resume,
             updatedAt: Date.now(),
         });
         this.writeChain = this.writeChain.then(() => this.persist());
@@ -83,12 +90,39 @@ export class SessionModeStore {
     setModeChangeHandler(cb) {
         this.onModeChange = cb;
     }
-    /** 设置会话档位（写穿持久化；持久化失败保持内存态生效）。 */
+    /** 暂停恢复快照（无则 null）。 */
+    getResume(sessionId) {
+        return this.entries.get(sessionId)?.resume ?? null;
+    }
+    /** 停用侧分布（工作台洞察，只读计数）：off = 档位暂停会话；wo = 注入覆盖只写
+     *  （recall=false 且档位未停——两态互斥计数，与召回四因子短路序对齐）。 */
+    countStates() {
+        let off = 0;
+        let wo = 0;
+        for (const e of this.entries.values()) {
+            if (e.mode === 'off')
+                off++;
+            else if (e.recall === false)
+                wo++;
+        }
+        return { off, wo };
+    }
+    /** 设置会话档位（写穿持久化；持久化失败保持内存态生效）。
+     *  暂停语义（UI 重构）：非 off → off 记录恢复快照（暂停前范围 + 当前注入覆盖）；
+     *  off → 非 off 清空快照（恢复）。 */
     set(sessionId, mode) {
         const old = this.get(sessionId);
         // 已有注入覆盖跨切档保留（#38：档位与注入正交，切档不动覆盖）
-        const recall = this.entries.get(sessionId)?.recall;
-        this.entries.set(sessionId, { mode, recall, updatedAt: Date.now() });
+        const prev = this.entries.get(sessionId);
+        const recall = prev?.recall;
+        let resume = prev?.resume;
+        if (mode === 'off' && old !== 'off') {
+            resume = { scope: old, recall: recall ?? null };
+        }
+        else if (mode !== 'off' && old === 'off') {
+            resume = undefined;
+        }
+        this.entries.set(sessionId, { mode, recall, resume, updatedAt: Date.now() });
         this.writeChain = this.writeChain.then(() => this.persist());
         if (old !== mode && this.onModeChange) {
             try {

package/dist/store/sqlite.d.ts

@@ -133,17 +133,24 @@ export declare class MemoryDb {
     /** 全量读取（调试/迁移/重嵌入用；检索请走 FTS/向量）。 */
     getAllL1(): MemoryRecord[];
     getL1ByIds(ids: string[]): MemoryRecord[];
-    /** 浏览列表（UI 用）：按更新时间倒序，支持类型/场景/族过滤与分页。失败返回空。 */
+    /** 浏览列表（UI 用）：按更新时间倒序，支持类型/场景/族/时间下限过滤与分页。失败返回空。 */
     listL1(opts: {
         type?: string;
         scene?: string;
         family?: string;
+        since?: string;
         limit: number;
         offset: number;
     }): {
         items: MemoryRecord[];
         total: number;
     };
+    /** 近 N 天逐日 L1 更新计数（工作台活动图；idx_l1_updated 范围扫描 + GROUP BY）。
+     *  day 为 ISO 日期前缀 YYYY-MM-DD（updated_time 存 ISO 文本，substr 即日期）。 */
+    countL1ByDay(sinceIso: string): Array<{
+        day: string;
+        n: number;
+    }>;
     /** 场景名去重列表（UI 筛选器数据源）。失败返回空。 */
     distinctL1Scenes(): string[];
     /** FTS5 BM25 检索（family 缺省不过滤）。失败返回空数组（调用方降级）。 */

package/dist/store/sqlite.js

@@ -754,7 +754,7 @@ export class MemoryDb {
             stmt =
                 action === 'delete'
                     ? this.db.prepare(`DELETE FROM ${table} WHERE record_id IN (${ph})`)
-                    : this.db.prepare(`SELECT record_id, content, type, priority, scene_name, version, timestamp_str, created_time, updated_time, metadata_json, family FROM ${table} WHERE record_id IN (${ph})`);
+                    : this.db.prepare(`SELECT record_id, content, type, priority, scene_name, session_id, version, timestamp_str, created_time, updated_time, metadata_json, family FROM ${table} WHERE record_id IN (${ph})`);
             this.inStmts.set(key, stmt);
         }
         return stmt;
@@ -819,7 +819,7 @@ export class MemoryDb {
         if (this.degraded)
             return [];
         const rows = this.db
-            .prepare('SELECT record_id, content, type, priority, scene_name, version, timestamp_str, created_time, updated_time, metadata_json, family FROM l1_records')
+            .prepare('SELECT record_id, content, type, priority, scene_name, session_id, version, timestamp_str, created_time, updated_time, metadata_json, family FROM l1_records')
             .all();
         return rows.map(rowToRecord);
     }
@@ -832,7 +832,7 @@ export class MemoryDb {
         }
         return rows.map(rowToRecord);
     }
-    /** 浏览列表（UI 用）：按更新时间倒序，支持类型/场景/族过滤与分页。失败返回空。 */
+    /** 浏览列表（UI 用）：按更新时间倒序，支持类型/场景/族/时间下限过滤与分页。失败返回空。 */
     listL1(opts) {
         if (this.degraded)
             return { items: [], total: 0 };
@@ -851,10 +851,15 @@ export class MemoryDb {
                 where.push('family = ?');
                 params.push(opts.family);
             }
+            // 时间下限（ISO 字符串；updated_time 存同格式，字典序 = 时间序，走 idx_l1_updated）
+            if (opts.since) {
+                where.push('updated_time >= ?');
+                params.push(opts.since);
+            }
             const whereSql = where.length > 0 ? ` WHERE ${where.join(' AND ')}` : '';
             const totalRow = this.db.prepare(`SELECT COUNT(*) AS n FROM l1_records${whereSql}`).get(...params);
             const rows = this.db
-                .prepare(`SELECT record_id, content, type, priority, scene_name, version, timestamp_str, created_time, updated_time, metadata_json, family FROM l1_records${whereSql} ORDER BY updated_time DESC LIMIT ? OFFSET ?`)
+                .prepare(`SELECT record_id, content, type, priority, scene_name, session_id, version, timestamp_str, created_time, updated_time, metadata_json, family FROM l1_records${whereSql} ORDER BY updated_time DESC LIMIT ? OFFSET ?`)
                 .all(...params, opts.limit, opts.offset);
             return { items: rows.map(rowToRecord), total: totalRow?.n ?? 0 };
         }
@@ -863,6 +868,20 @@ export class MemoryDb {
             return { items: [], total: 0 };
         }
     }
+    /** 近 N 天逐日 L1 更新计数（工作台活动图；idx_l1_updated 范围扫描 + GROUP BY）。
+     *  day 为 ISO 日期前缀 YYYY-MM-DD（updated_time 存 ISO 文本，substr 即日期）。 */
+    countL1ByDay(sinceIso) {
+        if (this.degraded)
+            return [];
+        try {
+            return this.db
+                .prepare("SELECT substr(updated_time, 1, 10) AS day, COUNT(*) AS n FROM l1_records WHERE updated_time >= ? AND updated_time <> '' GROUP BY day ORDER BY day")
+                .all(sinceIso);
+        }
+        catch {
+            return [];
+        }
+    }
     /** 场景名去重列表（UI 筛选器数据源）。失败返回空。 */
     distinctL1Scenes() {
         if (this.degraded)
@@ -1437,6 +1456,7 @@ function rowToRecord(row) {
         type: row.type,
         priority: row.priority,
         scene_name: row.scene_name,
+        sessionId: row.session_id || undefined,
         timestamps: dbToTimestamps(row.timestamp_str),
         createdAt: Date.parse(row.created_time) || 0,
         updatedAt: Date.parse(row.updated_time) || 0,

package/dist/workspace-aggregates.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 工作台只读聚合（UI 重构分散式）：总览快照、资产活动流、运行洞察三个端点的
+ * 数据装配层。全部只读，不触碰蒸馏/召回语义。
+ *
+ * 数据源纪律：本组端点按「设置页打开期间低频拉取」设计（非 session-stats
+ * 热路径）——L1 走 SQL 索引（idx_l1_updated 范围扫描 / FTS 检索唯一缝）；
+ * L2 场景与 L3 画像是文件级小数据（dsh-memory/scenes、/persona 端点同款读法）。
+ */
+import type { AssetActivityResponse, MemoryStats, RuntimeInsightsResponse, WorkspaceOverviewResponse } from './contract.js';
+import type { L1Store } from './store/l1.js';
+import type { PersonaStore } from './store/persona.js';
+import type { SceneStore } from './store/scenes.js';
+import type { SessionModeStore } from './store/session-modes.js';
+import type { MemoryFamily } from './types.js';
+import type { SessionInfoSource } from './stats.js';
+import type { LiveSettingsHandle } from './settings.js';
+/** 工作台可见的分族存储聚合（与 registerMemoryRpc 的 stores 同形）。 */
+export type WorkspaceStores = {
+    l1: L1Store;
+    scenes: Record<MemoryFamily, SceneStore>;
+    persona: Record<MemoryFamily, PersonaStore>;
+};
+export interface ActivityQuery {
+    query: string;
+    kind: '' | 'l1' | 'l2' | 'l3';
+    family: '' | 'chat' | 'work';
+    sinceMs: number;
+    limit: number;
+    offset: number;
+}
+export declare function decodeCursor(cursor: string | null | undefined): number;
+/**
+ * 混排资产活动流：L1（索引列表/检索缝）+ L2（场景摘要，页内补读正文）+
+ * L3（画像 + mtime），按 updatedAt 倒序统一排序后游标切片。
+ */
+export declare function collectAssetActivity(stores: WorkspaceStores, q: ActivityQuery): Promise<AssetActivityResponse>;
+/** 总览聚合：buildStats 既有字段 + 本周成本（token-cost 周窗口）+ 最近活动前 5 条。 */
+export declare function buildWorkspaceOverview(stores: WorkspaceStores, base: MemoryStats, week: {
+    calls: number;
+    outputTokens: number;
+    reasoningTokens: number;
+} | null, retrieval: 'hybrid' | 'vector' | 'keyword' | 'none' | null): Promise<WorkspaceOverviewResponse>;
+/** 洞察聚合：近 7 天逐日资产活动 + 蒸馏调用计数器 + 召回全量累计与停用分布。 */
+export declare function buildRuntimeInsights(stores: WorkspaceStores, sessionInfo: SessionInfoSource | undefined, modes: SessionModeStore | undefined, live: LiveSettingsHandle | undefined): Promise<RuntimeInsightsResponse>;