dsh-flash-mem-mon 0.1.7 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # dsh-flash-mem-mon
 
-Memory monitor provider for [dsh-flash](https://github.com/tcgbp/dsh-flash) — registers a host-memory-alert provider (RSS absolute thresholds, RSS growth rate, Major GC frequency) via `ctx.get('dockFlashAlerts')` and exposes `/memory-trend` for trend sparklines.
+Performance monitor provider for [dsh-flash](https://github.com/tcgbp/dsh-flash) — registers a host-performance-alert provider (RSS absolute thresholds, RSS growth rate, Major GC frequency) via `ctx.get('dockFlashAlerts')` and exposes `/memory-trend` for trend sparklines.
 
 ## Installation
 

package/README.zh-CN.md

@@ -1,6 +1,6 @@
 # dsh-flash-mem-mon
 
-dsh-flash 的内存监控提供器 — 通过 `ctx.get('dockFlashAlerts')` 注册主机内存告警提供器（RSS 绝对阈值、RSS 增长率、Major GC 频率），并暴露 `/memory-trend` 路由用于趋势图。
+dsh-flash 的性能监控提供器 — 通过 `ctx.get('dockFlashAlerts')` 注册主机性能告警提供器（RSS 绝对阈值、RSS 增长率、Major GC 频率），并暴露 `/memory-trend` 路由用于趋势图。
 
 ## 安装
 

package/dist/index.js

@@ -1,9 +1,16 @@
+import { writeHeapSnapshot } from 'node:v8';
+import { createReadStream } from 'node:fs';
+import { readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir, tmpdir } from 'node:os';
 // Default export only (`export default Schema`); there is no named `Schema`.
 import Schema from '@deepseek-ai/schemastery';
-import { DEFAULT_ALERT_CONFIG, isFullGc, rssSlopePerMin } from './pure.js';
+import { countArchivedSessions, DEFAULT_ALERT_CONFIG, formatBytes, isFullGc, rssSlopePerMin, sumBytes, } from './pure.js';
 export const name = 'dsh-flash-mem-mon';
-// No host-side service dependencies; all services are injected lazily.
-export const inject = [];
+// Lazy-injected services. All are resolved via ctx.inject() at apply-time, so
+// the plugin still boots even when a service (e.g. workspaceRegistry) is
+// unavailable; declaring them here documents the dependency.
+export const inject = ['workspaceRegistry'];
 // ── Memory alert thresholds (RSS MB) and GC thresholds (major GC/min) ──
 // All values come from the single canonical DEFAULT_ALERT_CONFIG in
 // ./pure.js. The browser client half mirrors these (see lib/client.js
@@ -19,6 +26,14 @@ const DEFAULT_GC_THRESHOLD_INFO = DEFAULT_ALERT_CONFIG.gcThresholdInfo;
 const DEFAULT_GC_THRESHOLD_WARNING = DEFAULT_ALERT_CONFIG.gcThresholdWarning;
 const DEFAULT_GC_THRESHOLD_ERROR = DEFAULT_ALERT_CONFIG.gcThresholdError;
 const DEFAULT_MEM_GROWTH_ALERT_PER_MIN = DEFAULT_ALERT_CONFIG.memGrowthAlertPerMin;
+// Session-footprint (disk) polling interval. Deliberately NOT a member of
+// DEFAULT_ALERT_CONFIG: test/defaults-drift.test.ts asserts that object contains
+// EXACTLY the 10 memory/GC keys, and a footprint key here would break that
+// precise set. Disk scans are comparatively expensive (recursive readdir +
+// stat over every session directory), so they run far less often than memory.
+// The host caches the last scan and the client reads the cached snapshot, so
+// the route itself never triggers an on-demand scan.
+const FOOTPRINT_POLL_INTERVAL_MS = 300000; // 5 min
 /**
  * Sentinel passed to `query()` / `gcEvents()` as the `since` lower bound to
  * mean "no lower bound — return ALL stored records".  These methods treat any
@@ -227,9 +242,12 @@ class MemoryTrendCollector {
                     // because they are rare and the general ring buffer may evict them.
                     if (isFullGc(kind)) {
                         const last = this._gcMajorEvents[this._gcMajorEvents.length - 1];
-                        if (last && event.ts - last.ts < 500) {
+                        if (last && event.ts - last.ts < 2000) {
                             // Same full-GC cycle (phase entries arriving back-to-back):
                             // merge into the existing event, keeping the worst-case pause.
+                            // Window is generous (2s) because one cycle's phases can arrive
+                            // over a second apart under real load; merging here prevents one
+                            // Full GC from being reported as several adjacent events.
                             last.duration = Math.max(last.duration, event.duration);
                             last.ts = event.ts;
                         }
@@ -284,6 +302,13 @@ class MemoryTrendCollector {
 // not the current owner, so overlapping apply/dispose cycles stay safe.
 let _memoryTrend = null;
 let _ownerCtx = null;
+// ── Heap-snapshot dump state ─────────────────────────────────────────────
+// The "dump heap now" disposal button on an alert POSTs dump-heap, which
+// writes a .heapsnapshot (possibly tens–hundreds of MB) and records it here
+// so the browser client can pull it down via the heap-dump route. Only the
+// latest snapshot is kept for download; dumps are user-paced, not automatic,
+// because writeHeapSnapshot() blocks the host main thread for seconds.
+let _lastSnapshot = null;
 /** Adopt the process-wide collector for `ctx`; no-op if it is already owned. */
 function startTrend(ctx, config) {
     if (_ownerCtx && _ownerCtx !== ctx)
@@ -307,6 +332,173 @@ function stopTrend(ctx) {
     _ownerCtx = null;
     _memoryTrend?.stop();
 }
+class SessionFootprintCollector {
+    _snapshot = null;
+    _timer = null;
+    _running = false;
+    start() {
+        if (this._running)
+            return;
+        this._running = true;
+        this._scan().then(() => { this._schedule(); }).catch(() => { this._schedule(); });
+    }
+    stop() {
+        this._running = false;
+        if (this._timer) {
+            clearTimeout(this._timer);
+            this._timer = null;
+        }
+    }
+    /** Immediately trigger a re-scan (e.g. right after the workspace registry is
+     *  captured) so the very first archived count is not stuck at 0. */
+    rescan() {
+        if (!this._running)
+            return;
+        this._scan().catch(() => { });
+    }
+    snapshot() {
+        return this._snapshot;
+    }
+    _schedule() {
+        if (!this._running)
+            return;
+        this._timer = setTimeout(() => {
+            this._timer = null;
+            this._scan().then(() => { this._schedule(); }).catch(() => { this._schedule(); });
+        }, FOOTPRINT_POLL_INTERVAL_MS);
+        this._timer.unref?.();
+    }
+    async _scan() {
+        const sessionsRoot = resolveSessionsRoot();
+        const workspaces = await this._scanWorkspaces(sessionsRoot);
+        const snapshot = {
+            totalSessions: 0,
+            archivedSessions: 0,
+            bytes: 0,
+            workspaces,
+            scannedAt: Date.now(),
+        };
+        for (const w of workspaces) {
+            snapshot.totalSessions += w.totalSessions;
+            snapshot.archivedSessions += w.archivedSessions;
+            snapshot.bytes += w.bytes;
+        }
+        this._snapshot = snapshot;
+    }
+    async _scanWorkspaces(sessionsRoot) {
+        let workspaceDirs = [];
+        try {
+            workspaceDirs = await readdir(sessionsRoot, { withFileTypes: true }).then((ents) => ents.filter((e) => e.isDirectory()).map((e) => e.name));
+        }
+        catch (_e) {
+            return [];
+        }
+        const registry = getWorkspaceRegistry();
+        let archivedIds = [];
+        try {
+            if (registry && typeof registry.archivedSessionIds === 'function')
+                archivedIds = registry.archivedSessionIds();
+            else if (registry && Array.isArray(registry.archivedSessionIds))
+                archivedIds = registry.archivedSessionIds;
+        }
+        catch (_e) { /* keep empty */ }
+        const result = [];
+        for (const ws of workspaceDirs) {
+            const wsPath = join(sessionsRoot, ws);
+            let sessionNames = [];
+            try {
+                sessionNames = await readdir(wsPath, { withFileTypes: true }).then((ents) => ents.filter((e) => e.isDirectory() && /^session-/.test(e.name)).map((e) => e.name));
+            }
+            catch (_e) {
+                sessionNames = [];
+            }
+            const namesSet = new Set(sessionNames);
+            let bytes = 0;
+            for (const s of sessionNames) {
+                bytes += await dirSize(join(wsPath, s));
+            }
+            result.push({
+                workspace: ws,
+                totalSessions: sessionNames.length,
+                archivedSessions: countArchivedSessions(archivedIds, namesSet),
+                bytes,
+            });
+        }
+        return result;
+    }
+}
+/** Recursively sum the on-disk size of a session directory. */
+async function dirSize(dir) {
+    let total = 0;
+    let entries = [];
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch (_e) {
+        return 0;
+    }
+    for (const e of entries) {
+        const p = join(dir, e.name);
+        try {
+            if (e.isDirectory()) {
+                total += await dirSize(p);
+            }
+            else if (e.isSymbolicLink()) {
+                continue;
+            }
+            else {
+                const s = await stat(p);
+                total += s.size;
+            }
+        }
+        catch (_e) { /* skip */ }
+    }
+    return total;
+}
+/**
+ * Resolve the DSH sessions root the same way the harness seeds `$DSH_HOME`:
+ * configured override > `$DSH_HOME` env > `~/.dsh` (opened home). `$DSH_HOME`
+ * may itself contain a `~` or trailing slashes, so expand the home and join the
+ * well-known `sessions` sub-directory explicitly. Returns `''` if a home could
+ * not be resolved at all (the scan then simply reports zero workspaces).
+ */
+function resolveSessionsRoot() {
+    const env = process.env.DSH_HOME;
+    const home = env && env.trim()
+        ? env.replace(/^~(?=\/|\\)/, homedir())
+        : join(homedir(), '.dsh');
+    return join(home, 'sessions');
+}
+let _footprint = null;
+let _footprintOwner = null;
+// Cached reference to the DSH workspace-registry service, resolved lazily via
+// ctx.inject. When it is unavailable (or the plugin was applied without it),
+// archived-session counting degrades to whatever the registry can provide —
+// if the registry is truly absent the archived count is reported as 0 rather
+// than guessing from the disk (disk directories carry no archive flag).
+let _workspaceRegistry = null;
+function setWorkspaceRegistry(wsCtx) {
+    const reg = wsCtx?.workspaceRegistry;
+    if (reg != null)
+        _workspaceRegistry = reg;
+}
+function getWorkspaceRegistry() {
+    return _workspaceRegistry ?? null;
+}
+function startFootprint(ctx) {
+    if (_footprintOwner && _footprintOwner !== ctx)
+        return;
+    if (!_footprint)
+        _footprint = new SessionFootprintCollector();
+    _footprintOwner = ctx;
+    _footprint.start();
+}
+function stopFootprint(ctx) {
+    if (_footprintOwner !== ctx)
+        return;
+    _footprintOwner = null;
+    _footprint?.stop();
+}
 // ── Private HTTP helpers ────────────────────────────────────────────────
 /** Send a JSON response with no-store cache control. */
 function sendJson(res, status, payload) {
@@ -321,6 +513,26 @@ export function apply(ctx, config) {
     ctx.inject(['settings'], (settingsCtx) => {
         settingsCtx.effect(() => settingsCtx.settings.configure({ auto: false }, ctx.fiber));
     });
+    // ── Workspace-registry capture ───────────────────────────────────────
+    // Grab the runtime's archived-session id list so the footprint collector can
+    // intersect it with on-disk session dirs. The registry is injected lazily;
+    // if it is unavailable at apply-time the footprint still scans the disk (and
+    // simply reports the archived count from whatever the registry later yields,
+    // or 0 if it never appears).
+    ctx.inject(['workspaceRegistry'], (regCtx) => {
+        setWorkspaceRegistry(regCtx);
+        // The registry may arrive after the collector's first scan already ran
+        // with no archived ids → refresh it immediately so the count is correct.
+        _footprint?.rescan();
+    });
+    // ── Session-footprint collector bootstrap ────────────────────────────
+    // Low-frequency disk scan (5-minute cadence by default), cached on the host.
+    // Owned exclusively by this ctx; overlapping apply/dispose cycles are safe.
+    startFootprint(ctx);
+    ctx.effect(() => {
+        const owner = ctx;
+        return () => { stopFootprint(owner); };
+    }, 'dsh-flash-mem-mon: session-footprint collector lifecycle');
     // ── Memory trend collector bootstrap ──────────────────────────────────
     // One bounded ring buffer per process, owned exclusively by the active ctx.
     // startTrend/stopTrend are idempotent and owner-guarded, so overlapping
@@ -387,5 +599,98 @@ export function apply(ctx, config) {
                 }
             },
         }), 'dsh-flash-mem-mon: GET /plugins/dsh-flash-mem-mon/memory-trend');
+        // GET /plugins/dsh-flash-mem-mon/session-footprint
+        // Returns the host's cached session-footprint snapshot (total / archived
+        // session counts + per-workspace and total on-disk bytes). Serves only the
+        // cached result of the low-frequency disk scan — never triggers a scan on
+        // demand, so repeated client polls (or a reload while the modal is open)
+        // cannot hammer the filesystem. `scannedAt` is the unix-ms time of the last
+        // completed scan (0 before the first scan finishes).
+        wsCtx.effect(() => ws.register({
+            kind: 'exact',
+            path: '/plugins/dsh-flash-mem-mon/session-footprint',
+            handler: async (req, res) => {
+                if (req.method !== 'GET') {
+                    res.statusCode = 405;
+                    res.setHeader('allow', 'GET');
+                    res.end();
+                    return;
+                }
+                const snap = _footprint?.snapshot() ?? null;
+                sendJson(res, 200, snap ?? {
+                    totalSessions: 0,
+                    archivedSessions: 0,
+                    bytes: 0,
+                    workspaces: [],
+                    scannedAt: 0,
+                });
+            },
+        }), 'dsh-flash-mem-mon: GET /plugins/dsh-flash-mem-mon/session-footprint');
+        // POST /plugins/dsh-flash-mem-mon/dump-heap
+        // Triggered by the "立即转储堆快照" disposal button attached to a memory
+        // alert (see lib/client.js createHostMemoryAlertProvider → actions).
+        // Synchronously writes a .heapsnapshot into the OS temp dir (the one
+        // acceptable place to block the main thread: the user asked for it), then
+        // records it as the latest snapshot and returns its name+size so the
+        // client can confirm and pull it down. Auto-dump is deliberately NOT
+        // offered anywhere — a runaway gleaning loop must never stall the host.
+        wsCtx.effect(() => ws.register({
+            kind: 'exact',
+            path: '/plugins/dsh-flash-mem-mon/dump-heap',
+            handler: async (_req, res) => {
+                if (_req.method !== 'POST') {
+                    res.statusCode = 405;
+                    res.setHeader('allow', 'POST');
+                    res.end();
+                    return;
+                }
+                const name = `dsh-flash-mem-mon-${Date.now()}.${process.pid}.heapsnapshot`;
+                const path = join(tmpdir(), name);
+                try {
+                    writeHeapSnapshot(path);
+                    const info = await stat(path);
+                    _lastSnapshot = { name, path, size: info.size };
+                    sendJson(res, 200, { ok: true, name, size: info.size, path });
+                }
+                catch (err) {
+                    sendJson(res, 500, { ok: false, error: (err && err.message) || 'heap snapshot failed' });
+                }
+            },
+        }), 'dsh-flash-mem-mon: POST /plugins/dsh-flash-mem-mon/dump-heap');
+        // GET /plugins/dsh-flash-mem-mon/heap-dump
+        // Streams the most recent heap snapshot back to the client as an
+        // attachment. One latest-at-a-time is fine here: dumps are user-paced and
+        // downloading is immediate, so keeping a whole archive is unnecessary
+        // (and the tmp files are already pruned by the OS over time).
+        wsCtx.effect(() => ws.register({
+            kind: 'exact',
+            path: '/plugins/dsh-flash-mem-mon/heap-dump',
+            handler: async (_req, res) => {
+                if (_req.method !== 'GET') {
+                    res.statusCode = 405;
+                    res.setHeader('allow', 'GET');
+                    res.end();
+                    return;
+                }
+                const snap = _lastSnapshot;
+                if (!snap) {
+                    sendJson(res, 404, { error: 'No heap snapshot available yet' });
+                    return;
+                }
+                try {
+                    await stat(snap.path); // ensure it still exists
+                    res.statusCode = 200;
+                    res.setHeader('content-type', 'application/octet-stream');
+                    res.setHeader('content-length', String(snap.size));
+                    res.setHeader('content-disposition', `attachment; filename="${snap.name}"`);
+                    res.setHeader('cache-control', 'no-store');
+                    createReadStream(snap.path).pipe(res);
+                }
+                catch (_e) {
+                    _lastSnapshot = null; // stale entry; drop it
+                    sendJson(res, 404, { error: 'Heap snapshot no longer available' });
+                }
+            },
+        }), 'dsh-flash-mem-mon: GET /plugins/dsh-flash-mem-mon/heap-dump');
     });
 }

package/dist/pure.js

@@ -6,7 +6,7 @@ export const DEFAULT_ALERT_CONFIG = {
     memThresholdWarning: 512,
     memThresholdError: 1024,
     memThresholdCritical: 1536,
-    memPollBase: 30000,
+    memPollBase: 60000,
     memPollMin: 2000,
     gcThresholdInfo: 2,
     gcThresholdWarning: 5,
@@ -64,3 +64,56 @@ export function rssSlopePerMin(samples, tailCount = 20) {
     const samplesPerMinute = 60000 / avgIntervalMs;
     return Math.round((slope * samplesPerMinute / 1048576) * 100) / 100;
 }
+// ── Session-footprint helpers ─────────────────────────────────────────────
+// These are derived purely from collected inputs so the aggregate math and the
+// human-readable formatting can be unit tested without touching the filesystem.
+/**
+ * Derive the number of ARCHIVED sessions that are still physically present on
+ * disk. The DSH runtime's `workspaceRegistry.archivedSessionIds` lists archived
+ * session ids, but some may have already been pruned from disk (so the disk
+ * `sessions/<workspace>/session-<uuid>` directories can be fewer than the ids).
+ * The truth source for "archived" is the runtime id list; the disk constrains
+ * it to what still exists. Pass `sessionNames` as the on-disk directory names
+ * (e.g. `new Set(['session-a', 'session-b', ...])`).
+ */
+export function countArchivedSessions(archivedIds, sessionNames) {
+    let count = 0;
+    for (const id of archivedIds) {
+        if (sessionNames.has(id) || sessionNames.has(`session-${id}`))
+            count++;
+    }
+    return count;
+}
+/** Format a byte count for display, e.g. 1536 → '1.5 KB', 7340032 → '7.0 MB'. */
+export function formatBytes(bytes) {
+    if (!Number.isFinite(bytes) || bytes < 0)
+        return '—';
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const units = ['KB', 'MB', 'GB', 'TB'];
+    let value = bytes / 1024;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit++;
+    }
+    return `${value.toFixed(1)} ${units[unit]}`;
+}
+/** Format a duration (ms) as a human freshness string, e.g. '5 分钟前'. */
+export function formatDurationAgo(nowMs, thenMs) {
+    if (!Number.isFinite(nowMs) || !Number.isFinite(thenMs) || thenMs <= 0 || nowMs < thenMs)
+        return null;
+    const sec = Math.floor((nowMs - thenMs) / 1000);
+    if (sec < 60)
+        return sec <= 1 ? '刚刚' : `${sec} 秒前`;
+    if (sec < 3600)
+        return `${Math.floor(sec / 60)} 分钟前`;
+    return `${Math.floor(sec / 3600)} 小时前`;
+}
+/** Sum an array of byte counts (per-workspace disk usage) into a single total. */
+export function sumBytes(parts) {
+    let total = 0;
+    for (const p of parts)
+        total += p;
+    return total;
+}

package/lib/client.js

@@ -60,7 +60,7 @@ window.__ModuleLoader__.load({
     //#region i18n ────────────────────────────────────────────────────────────
 
     var zh = {
-      alertMemCluster: '内存监控',
+      alertMemCluster: '性能监控',
       monitorOn: '已开启',
       monitorOff: '已关闭',
       monitorConfig: '配置',
@@ -108,6 +108,11 @@ window.__ModuleLoader__.load({
       alertHostGcWarning: 'GC 频率异常',
       alertHostGcError: 'GC 频率极高',
       alertHostGcMsg: 'Major {v} 次/min | 暂停 {pause} ms/min | Minor {minor} 次 | RSS {rss} MB | 堆 {heap}/{heapTotal} MB ({pct}%)',
+      // Alert disposal buttons (registered via `actions` — see dsh-flash contract)
+      alertDisposeDumpHeap: '立即转储堆快照',
+      alertDumping: '正在转储堆快照…',
+      alertDumpSaved: '已保存快照 {name}（{size}），可在 DevTools → Memory → Load 中载入分析',
+      alertDumpFailed: '堆快照失败：{error}',
       alertSevInfo: '信息',
       alertSevWarning: '警告',
       alertSevError: '错误',
@@ -153,10 +158,16 @@ window.__ModuleLoader__.load({
       memTrendAxisHeap: '堆',
       memTrendAxisTime: '时间',
       memTrendInfo: '趋势信息',
+      // Session footprint
+      footprintTitle: '会话足迹',
+      footprintTotalSessions: '总会话数',
+      footprintArchivedSessions: '归档会话数',
+      footprintOnDisk: '磁盘占用',
+      footprintNoData: '暂无足迹数据',
     }
 
     var en = {
-      alertMemCluster: 'Memory Monitor',
+      alertMemCluster: 'Performance Monitor',
       monitorOn: 'Enabled',
       monitorOff: 'Disabled',
       monitorConfig: 'Configure',
@@ -204,6 +215,11 @@ window.__ModuleLoader__.load({
       alertHostGcWarning: 'GC frequency abnormal',
       alertHostGcError: 'GC frequency critical',
       alertHostGcMsg: 'Major {v}/min | Pause {pause} ms/min | Minor {minor} | RSS {rss} MB | Heap {heap}/{heapTotal} MB ({pct}%)',
+      // Alert disposal buttons (registered via `actions` — see dsh-flash contract)
+      alertDisposeDumpHeap: 'Dump heap now',
+      alertDumping: 'Dumping heap snapshot…',
+      alertDumpSaved: 'Saved snapshot {name} ({size}). Load it in DevTools → Memory to analyze.',
+      alertDumpFailed: 'Heap dump failed: {error}',
       alertSevInfo: 'Info',
       alertSevWarning: 'Warning',
       alertSevError: 'Error',
@@ -249,6 +265,12 @@ window.__ModuleLoader__.load({
       memTrendAxisHeap: 'Heap',
       memTrendAxisTime: 'Time',
       memTrendInfo: 'Trend Info',
+      // Session footprint
+      footprintTitle: 'Session Footprint',
+      footprintTotalSessions: 'Total Sessions',
+      footprintArchivedSessions: 'Archived Sessions',
+      footprintOnDisk: 'On Disk',
+      footprintNoData: 'No footprint data yet',
     }
 
     // ── i18n: a proxy over DSH's official locale framework ─────────────────
@@ -438,7 +460,7 @@ window.__ModuleLoader__.load({
       memThresholdWarning: 512,
       memThresholdError: 1024,
       memThresholdCritical: 1536,
-      memPollBase: 30000,
+      memPollBase: 60000,
       memPollMin: 2000,
       gcThresholdInfo: 2,
       gcThresholdWarning: 5,
@@ -696,6 +718,52 @@ var _PREFS_MAX_RETRIES = 8
         disarmAbsent()
       }
 
+      /** Disposal actions attached to every memory/GC alert. dsh-flash renders
+       *  one button per entry and calls onClick(alert, api). Contract in
+       *  dsh-flash/lib/client.js `_showAlertDetail` → plugin-registered action
+       *  buttons. Returning a Promise keeps the button disabled until settled;
+       *  returning {message} keeps the detail modal open so the saved location
+       *  stays visible (the user pulls down the .heapsnapshot browser download
+       *  we trigger programmatically — the status line is plain text, not HTML,
+       *  so we cannot render a live link into it). */
+      function _dumpHeapActions() {
+        return [{
+          id: 'dump-heap',
+          label: function () { return t('alertDisposeDumpHeap') },
+          primary: true,
+          onClick: function (_alert, api) {
+            api.status(t('alertDumping'), 'info')
+            return fetch('/plugins/dsh-flash-mem-mon/dump-heap', { method: 'POST' })
+              .then(function (r) { return r.json().catch(function () { return null }) })
+              .then(function (d) {
+                if (!d || !d.ok || !d.name) {
+                  var err = (d && d.error) || 'unknown'
+                  api.status(t('alertDumpFailed').replace('{error}', err), 'error')
+                  return { message: t('alertDumpFailed').replace('{error}', err), level: 'error' }
+                }
+                // Stream the snapshot down as a browser download (same origin).
+                var a = document.createElement('a')
+                a.href = '/plugins/dsh-flash-mem-mon/heap-dump'
+                a.download = d.name
+                document.body.appendChild(a)
+                a.click()
+                a.remove()
+                var size = d.size >= 1048576
+                  ? (d.size / 1048576).toFixed(1) + ' MB'
+                  : Math.max(1, Math.round(d.size / 1024)) + ' KB'
+                var msg = t('alertDumpSaved').replace('{name}', d.name).replace('{size}', size)
+                api.status(msg, 'info')
+                return { message: msg, level: 'info' }
+              })
+              .catch(function (err) {
+                var msg = t('alertDumpFailed').replace('{error}', (err && err.message) || 'network')
+                api.status(msg, 'error')
+                return { message: msg, level: 'error' }
+              })
+          },
+        }]
+      }
+
       function poll() {
         if (!callback) return
         var alerts = []
@@ -757,6 +825,7 @@ var _PREFS_MAX_RETRIES = 8
                 icon: '🔴',
                 timestamp: Date.now(),
                 dismissible: true,
+                actions: _dumpHeapActions(),
               })
             } else if (rssMB >= tErr) {
               emitIfChanged(alerts, {
@@ -767,6 +836,7 @@ var _PREFS_MAX_RETRIES = 8
                 icon: '🟠',
                 timestamp: Date.now(),
                 dismissible: true,
+                actions: _dumpHeapActions(),
               })
             } else if (rssMB >= tWarn) {
               emitIfChanged(alerts, {
@@ -777,6 +847,7 @@ var _PREFS_MAX_RETRIES = 8
                 icon: '🟡',
                 timestamp: Date.now(),
                 dismissible: true,
+                actions: _dumpHeapActions(),
               })
             } else if (rssMB >= tInfo) {
               emitIfChanged(alerts, {
@@ -787,6 +858,7 @@ var _PREFS_MAX_RETRIES = 8
                 icon: '🔵',
                 timestamp: Date.now(),
                 dismissible: true,
+                actions: _dumpHeapActions(),
               })
             }
 
@@ -816,6 +888,7 @@ var _PREFS_MAX_RETRIES = 8
                   icon: '📈',
                   timestamp: Date.now(),
                   dismissible: true,
+                  actions: _dumpHeapActions(),
                 })
               }
             }
@@ -853,6 +926,7 @@ var _PREFS_MAX_RETRIES = 8
                   icon: '🟠',
                   timestamp: Date.now(),
                   dismissible: true,
+                  actions: _dumpHeapActions(),
                 })
               } else if (mpm >= gcWarn) {
                 emitIfChanged(alerts, {
@@ -863,6 +937,7 @@ var _PREFS_MAX_RETRIES = 8
                   icon: '🟡',
                   timestamp: Date.now(),
                   dismissible: true,
+                  actions: _dumpHeapActions(),
                 })
               } else if (mpm >= gcInfo) {
                 emitIfChanged(alerts, {
@@ -873,6 +948,7 @@ var _PREFS_MAX_RETRIES = 8
                   icon: '🔵',
                   timestamp: Date.now(),
                   dismissible: true,
+                  actions: _dumpHeapActions(),
                 })
               }
             }
@@ -1388,6 +1464,11 @@ var _PREFS_MAX_RETRIES = 8
       var _gcEvents = useState(null)
       var gcEvents = _gcEvents[0], setGcEvents = _gcEvents[1]
 
+      // Session footprint — total/archived session counts and on-disk usage
+      // from our own /session-footprint route (cached host snapshot).
+      var _footprint = useState(null)
+      var footprint = _footprint[0], setFootprint = _footprint[1]
+
       // Sparkline hover index (null = not hovering).
       var _hoverIdx = useState(null)
       var hoverIdx = _hoverIdx[0], setHoverIdx = _hoverIdx[1]
@@ -1459,6 +1540,22 @@ var _PREFS_MAX_RETRIES = 8
         return function () { clearInterval(sampleTimer) }
       }, [])
 
+      // Session footprint — the host collector rescans no more often than every
+      // ~5 min and serves a cached snapshot with the routes' last `scannedAt`, so
+      // the panel is fetched only occasionally; a low-frequency fallback keeps
+      // the panel live even if the shared cache never lands here.
+      useEffect(function () {
+        function fetchFootprint() {
+          fetch('/plugins/dsh-flash-mem-mon/session-footprint')
+            .then(function (r) { return r.json() })
+            .then(function (d) { if (d) setFootprint(d) })
+            .catch(function () {})
+        }
+        fetchFootprint()
+        var footprintTimer = setInterval(fetchFootprint, 60000)
+        return function () { clearInterval(footprintTimer) }
+      }, [])
+
       // Render a single slider field row.
       function renderSliderField(f) {
         var val = Number(_alertPref(f.key)) || 0
@@ -2039,30 +2136,44 @@ var _PREFS_MAX_RETRIES = 8
           if (gcEvents && gcEvents.length > 0) {
             var tsFirst = trendSamples[0].ts
             var tsLast = trendSamples[trendSamples.length - 1].ts
+            // Track which sample RSS-drop segments have already been attributed to a
+            // Full GC event. Without this, two Full GCs that fire around the same
+            // memory release can both grab the same -XX MB drop and double count it.
+            var sampleDropClaimed = {}
             for (var ei = 0; ei < gcEvents.length; ei++) {
               var ge = gcEvents[ei]
               if (ge.ts < tsFirst || ge.ts > tsLast) continue
               // Try to find the RSS drop around this GC event from samples.
               var rssDropMB = null
+              var merged = false
               // First: check if it merges with an existing sample-sourced RSS drop event (within 5s).
-              var duped = false
               for (var di = 0; di < dropEvents.length; di++) {
-                if (dropEvents[di].source === 'sample' && Math.abs(dropEvents[di].ts - ge.ts) < 5000) {
-                  rssDropMB = dropEvents[di].rssDropMB
-                  dropEvents[di].source = 'gc'
-                  dropEvents[di].duration = ge.duration
-                  dropEvents[di].gcIdx = ei
-                  duped = true
+                var dropItem = dropEvents[di]
+                if (dropItem.source === 'sample' && Math.abs(dropItem.ts - ge.ts) < 5000) {
+                  if (!sampleDropClaimed[dropItem.sampleIdx]) {
+                    sampleDropClaimed[dropItem.sampleIdx] = true
+                    rssDropMB = dropItem.rssDropMB
+                    dropItem.source = 'gc'
+                    dropItem.duration = ge.duration
+                    dropItem.gcIdx = ei
+                    merged = true
+                  }
+                  // If this drop was already claimed by an earlier GC, don't
+                  // attribute it again — fall through and add this GC as its own
+                  // row without reusing the same memory-release number.
                   break
                 }
               }
-              // Second: if no existing RSS drop matched, scan nearby samples for a drop.
-              if (!duped) {
+              // Second: if no existing RSS drop merged, scan nearby samples for a
+              // drop, skipping segments already claimed by an earlier event.
+              if (!merged) {
                 for (var si2 = 1; si2 < trendSamples.length; si2++) {
                   var timeDiff = Math.abs(trendSamples[si2].ts - ge.ts)
                   if (timeDiff > 10000) continue  // only look within ±10s
+                  if (sampleDropClaimed[si2]) continue  // drop already attributed elsewhere
                   var nearDrop = trendSamples[si2 - 1].rss - trendSamples[si2].rss
                   if (nearDrop > 0) {
+                    sampleDropClaimed[si2] = true
                     rssDropMB = (nearDrop / 1048576).toFixed(1)
                     break
                   }
@@ -2078,6 +2189,10 @@ var _PREFS_MAX_RETRIES = 8
               }
             }
           }
+          // Merge both sources back into strict chronological order. A Full GC event
+          // found outside any sample's RSS-drop window is appended after the sample
+          // events, which may leave the combined list out of order.
+          dropEvents.sort(function (a, b) { return a.ts - b.ts })
           if (dropEvents.length === 0 && (!trendData.gc || trendData.gc.majorCount === 0)) {
             return h('div', null,
               h('span', { style: S.monitorConfigGroupTitle }, t('memGcEventList')),
@@ -2170,11 +2285,58 @@ var _PREFS_MAX_RETRIES = 8
         )
       }
 
+      var footprintSectionEl = (function () {
+        function formatBytesSync(n) {
+          if (!isFinite(n) || n < 0) return '—'
+          if (n < 1024) return n + ' B'
+          var units = ['KB', 'MB', 'GB', 'TB', 'PB']
+          var v = n
+          var u = -1
+          do { v /= 1024; u++ } while (v >= 1024 && u < units.length - 1)
+          return v.toFixed(v >= 100 ? 0 : 1) + ' ' + units[u]
+        }
+        var fp = footprint
+        var totalBytes = 0
+        var totalSessions = 0
+        var totalArchived = 0
+        var archivedKnown = false
+        if (fp && Array.isArray(fp.workspaces)) {
+          fp.workspaces.forEach(function (w) {
+            totalSessions += Number(w.totalSessions) || 0
+            totalArchived += Number(w.archivedSessions) || 0
+            totalBytes += Number(w.bytes) || 0
+            if (typeof w.archivedSessions === 'number') archivedKnown = true
+          })
+        }
+        if (!fp) {
+          return h('div', { style: Object.assign({}, S.memColumnCard, { marginTop: '8px' }) },
+            h('span', { style: S.memSubSectionLabel }, t('footprintTitle')),
+            h('span', { style: S.memLiveDataLabel }, t('footprintNoData')),
+          )
+        }
+        return h('div', { style: Object.assign({}, S.memColumnCard, { marginTop: '8px' }) },
+          h('span', { style: S.memSubSectionLabel }, t('footprintTitle')),
+          h('div', { style: S.memLiveDataGrid },
+            h('span', { style: S.memLiveDataLabel }, t('footprintTotalSessions')),
+            h('span', { style: S.memLiveDataValue }, String(totalSessions)),
+            h('span', { style: S.memLiveDataLabel }, t('footprintArchivedSessions')),
+            h('span', { style: S.memLiveDataValue },
+              archivedKnown
+                ? String(totalArchived)
+                : '—',
+            ),
+            h('span', { style: S.memLiveDataLabel }, t('footprintOnDisk')),
+            h('span', { style: S.memLiveDataValue }, formatBytesSync(totalBytes)),
+          ),
+        )
+      })()
+
       memLiveDataEl = h('div', { key: 'live-data' },
         h('div', { style: S.monitorModalDivider }),
         h('span', { style: S.monitorModalSectionTitle }, t('memLiveData')),
         hostSectionEl,
         trendSectionEl,
+        footprintSectionEl,
       )
 
       return h('div', {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-flash-mem-mon",
-  "version": "0.1.7",
+  "version": "0.2.0",
   "description": "Memory monitor provider for the `dsh-flash` Quick Control panel — registers a host-memory-alert provider (RSS absolute, RSS growth rate, Major GC frequency) via ctx.get('dockFlashAlerts') and exposes /memory-trend for trend sparklines.",
   "license": "Apache-2.0",
   "type": "module",