dsh-flash-mem-mon 0.1.5 → 0.1.7

package/README.md

@@ -1,38 +1,39 @@
-# 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.
-
-## Installation
-
-```bash
-dsh plugin --profile <profile> add dsh-flash-mem-mon
-```
-
-Requires `dsh-flash >=1.0.0` (provides `dockFlashAlerts` and `quickControl` services).
-
-## Configuration
-
-All settings are live-editable (volatile) and take effect immediately:
-
-| Setting | Default | Description |
-|---|---|---|
-| `memThresholdInfo` | 256 MB | RSS info threshold |
-| `memThresholdWarning` | 512 MB | RSS warning threshold |
-| `memThresholdError` | 1024 MB | RSS error threshold |
-| `memThresholdCritical` | 1536 MB | RSS critical threshold |
-| `memPollBase` | 30000 ms | Base polling interval |
-| `memPollMin` | 2000 ms | Minimum polling interval |
-| `gcThresholdInfo` | 2 /min | Major GC info threshold |
-| `gcThresholdWarning` | 5 /min | Major GC warning threshold |
-| `gcThresholdError` | 10 /min | Major GC error threshold |
-
-## Architecture
-
-This is a **companion plugin** following the same two-half pattern as `dsh-flash-net-mon`:
-
-- **Host half** (`src/index.ts` → tsc → `dist/index.js`): Memory trend ring buffer, GC observer, `/memory-trend` HTTP route
-- **Client half** (`lib/client.js`): Alert provider, enable toggle, config modal with sparkline, i18n
-
-## License
-
-Apache-2.0
+# 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.
+
+## Installation
+
+```bash
+dsh plugin --profile <profile> add dsh-flash-mem-mon
+```
+
+Requires `dsh-flash >=1.0.0` (provides `dockFlashAlerts` and `quickControl` services).
+
+## Configuration
+
+All settings are live-editable (volatile) and take effect immediately:
+
+| Setting | Default | Description |
+|---|---|---|
+| `memThresholdInfo` | 256 MB | RSS info threshold |
+| `memThresholdWarning` | 512 MB | RSS warning threshold |
+| `memThresholdError` | 1024 MB | RSS error threshold |
+| `memThresholdCritical` | 1536 MB | RSS critical threshold |
+| `memPollBase` | 30000 ms | Base polling interval |
+| `memPollMin` | 2000 ms | Minimum polling interval |
+| `gcThresholdInfo` | 2 /min | Major GC info threshold |
+| `gcThresholdWarning` | 5 /min | Major GC warning threshold |
+| `gcThresholdError` | 10 /min | Major GC error threshold |
+| `memGrowthAlertPerMin` | 1 MB/min | RSS growth-rate (linear-regression slope) alert threshold, applied with trend = up |
+
+## Architecture
+
+This is a **companion plugin** following the same two-half pattern as `dsh-flash-net-mon`:
+
+- **Host half** (`src/index.ts` → tsc → `dist/index.js`): Memory trend ring buffer, GC observer, `/memory-trend` HTTP route
+- **Client half** (`lib/client.js`): Alert provider, enable toggle, config modal with sparkline, i18n via DSH's `locale` service
+
+## License
+
+Apache-2.0

package/README.zh-CN.md

@@ -1,38 +1,38 @@
-# dsh-flash-mem-mon
-
-dsh-flash 的内存监控提供器 — 通过 `ctx.get('dockFlashAlerts')` 注册主机内存告警提供器（RSS 绝对阈值、RSS 增长率、Major GC 频率），并暴露 `/memory-trend` 路由用于趋势图。
-
-## 安装
-
-```bash
-dsh plugin --profile <profile> add dsh-flash-mem-mon
-```
-
-需要 `dsh-flash >=1.0.0`（提供 `dockFlashAlerts` 和 `quickControl` 服务）。
-
-## 配置
-
-所有设置均支持热更新（volatile），修改后立即生效：
-
-| 设置 | 默认值 | 说明 |
-|---|---|---|
-| `memThresholdInfo` | 256 MB | RSS 信息阈值 |
-| `memThresholdWarning` | 512 MB | RSS 警告阈值 |
-| `memThresholdError` | 1024 MB | RSS 错误阈值 |
-| `memThresholdCritical` | 1536 MB | RSS 严重阈值 |
-| `memPollBase` | 30000 ms | 基础轮询间隔 |
-| `memPollMin` | 2000 ms | 最小轮询间隔 |
-| `gcThresholdInfo` | 2 /min | Major GC 信息阈值 |
-| `gcThresholdWarning` | 5 /min | Major GC 警告阈值 |
-| `gcThresholdError` | 10 /min | Major GC 错误阈值 |
-
-## 架构
-
-本插件为 **伴随插件**，遵循与 `dsh-flash-net-mon` 相同的双半模式：
-
-- **宿主端** (`src/index.ts` → tsc → `dist/index.js`)：内存趋势环形缓冲区、GC 观察器、`/memory-trend` HTTP 路由
-- **客户端** (`lib/client.js`)：告警提供器、启用开关、带趋势图的配置弹窗、国际化
-
-## 许可证
-
-Apache-2.0
+# dsh-flash-mem-mon
+
+dsh-flash 的内存监控提供器 — 通过 `ctx.get('dockFlashAlerts')` 注册主机内存告警提供器（RSS 绝对阈值、RSS 增长率、Major GC 频率），并暴露 `/memory-trend` 路由用于趋势图。
+
+## 安装
+
+```bash
+dsh plugin --profile <profile> add dsh-flash-mem-mon
+```
+
+需要 `dsh-flash >=1.0.0`（提供 `dockFlashAlerts` 和 `quickControl` 服务）。
+
+## 配置
+
+所有设置均支持热更新（volatile），修改后立即生效：
+
+| 设置 | 默认值 | 说明 |
+|---|---|---|
+| `memThresholdInfo` | 256 MB | RSS 信息阈值 |
+| `memThresholdWarning` | 512 MB | RSS 警告阈值 |
+| `memThresholdError` | 1024 MB | RSS 错误阈值 |
+| `memThresholdCritical` | 1536 MB | RSS 严重阈值 |
+| `memPollBase` | 30000 ms | 基础轮询间隔 |
+| `memPollMin` | 2000 ms | 最小轮询间隔 |
+| `gcThresholdInfo` | 2 /min | Major GC 信息阈值 |
+| `gcThresholdWarning` | 5 /min | Major GC 警告阈值 |
+| `gcThresholdError` | 10 /min | Major GC 错误阈值 |
+
+## 架构
+
+本插件为 **伴随插件**，遵循与 `dsh-flash-net-mon` 相同的双半模式：
+
+- **宿主端** (`src/index.ts` → tsc → `dist/index.js`)：内存趋势环形缓冲区、GC 观察器、`/memory-trend` HTTP 路由
+- **客户端** (`lib/client.js`)：告警提供器、启用开关、带趋势图的配置弹窗、复用 DSH 官方 `locale` 服务的国际化
+
+## 许可证
+
+Apache-2.0

package/cordis.patch.yml

@@ -1,11 +1,11 @@
-# dsh-flash-mem-mon bundle layer — registers the HOST half into a profile.
-#
-# The BROWSER half needs no row here: the module loader auto-discovers the
-# client bundle from package.json `exports["./client"]` + `dsh.client` and
-# serves it at /plugins/<pkg>/client.js.
-#
-# PITFALL: `name` is a PACKAGE NAME (resolved via the profile's node_modules),
-# NOT a relative path.
-- insert:
-    - id: dsh-flash-mem-mon
-      name: dsh-flash-mem-mon
+# dsh-flash-mem-mon bundle layer — registers the HOST half into a profile.
+#
+# The BROWSER half needs no row here: the module loader auto-discovers the
+# client bundle from package.json `exports["./client"]` + `dsh.client` and
+# serves it at /plugins/<pkg>/client.js.
+#
+# PITFALL: `name` is a PACKAGE NAME (resolved via the profile's node_modules),
+# NOT a relative path.
+- insert:
+    - id: dsh-flash-mem-mon
+      name: dsh-flash-mem-mon

package/dist/index.js

@@ -1,33 +1,32 @@
 // 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';
 export const name = 'dsh-flash-mem-mon';
 // No host-side service dependencies; all services are injected lazily.
 export const inject = [];
 // ── Memory alert thresholds (RSS MB) and GC thresholds (major GC/min) ──
-const DEFAULT_MEM_THRESHOLD_INFO = 256;
-const DEFAULT_MEM_THRESHOLD_WARNING = 512;
-const DEFAULT_MEM_THRESHOLD_ERROR = 1024;
-const DEFAULT_MEM_THRESHOLD_CRITICAL = 1536;
-const DEFAULT_MEM_POLL_BASE = 30000;
-const DEFAULT_MEM_POLL_MIN = 2000;
-const DEFAULT_GC_THRESHOLD_INFO = 2;
-const DEFAULT_GC_THRESHOLD_WARNING = 5;
-const DEFAULT_GC_THRESHOLD_ERROR = 10;
-// V8 GC entry `kind` is a bitmask of GC types:
-//   1 << 0 = Scavenge (minor / young-gen)
-//   1 << 1 = MarkSweepCompact (major / full)
-//   1 << 2 = IncrementalMarking
-//   1 << 3 = ProcessWeakCallbacks
-// In practice modern V8/Node reports a full MarkSweepCompact cycle through the
-// IncrementalMarking (4) and ProcessWeakCallbacks (8) phases — the standalone
-// "major" bit (2) is almost never emitted on its own.  Classifying Full GC by
-// `kind === 2` alone therefore misses (nearly) every real full collection.
-// The robust test: a Full GC is any NON-scavenge cycle, i.e. the Scavenge bit
-// (1) is NOT set.  This captures 2, 4, 6, 8, 10, 12, 14 while excluding minor
-// (1) scavenges.
-function isFullGc(kind) {
-    return (kind & 1) === 0 && kind > 0;
-}
+// All values come from the single canonical DEFAULT_ALERT_CONFIG in
+// ./pure.js. The browser client half mirrors these (see lib/client.js
+// _MEM_ALERT_DEFAULTS); test/defaults-drift.test.ts guarantees they never
+// drift from this source of truth.
+const DEFAULT_MEM_THRESHOLD_INFO = DEFAULT_ALERT_CONFIG.memThresholdInfo;
+const DEFAULT_MEM_THRESHOLD_WARNING = DEFAULT_ALERT_CONFIG.memThresholdWarning;
+const DEFAULT_MEM_THRESHOLD_ERROR = DEFAULT_ALERT_CONFIG.memThresholdError;
+const DEFAULT_MEM_THRESHOLD_CRITICAL = DEFAULT_ALERT_CONFIG.memThresholdCritical;
+const DEFAULT_MEM_POLL_BASE = DEFAULT_ALERT_CONFIG.memPollBase;
+const DEFAULT_MEM_POLL_MIN = DEFAULT_ALERT_CONFIG.memPollMin;
+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;
+/**
+ * Sentinel passed to `query()` / `gcEvents()` as the `since` lower bound to
+ * mean "no lower bound — return ALL stored records".  These methods treat any
+ * `since <= 0` (0 or undefined) as "all", and a positive value as a unix-ms
+ * timestamp to filter from.  Keeping one explicit convention prevents callers
+ * from mixing up `0` vs `undefined` (both mean "all").
+ */
+const SINCE_ALL = 0;
 export const Config = Schema.object({
     memThresholdInfo: Schema.number().default(DEFAULT_MEM_THRESHOLD_INFO).volatile(),
     memThresholdWarning: Schema.number().default(DEFAULT_MEM_THRESHOLD_WARNING).volatile(),
@@ -38,10 +37,20 @@ export const Config = Schema.object({
     gcThresholdInfo: Schema.number().default(DEFAULT_GC_THRESHOLD_INFO).volatile(),
     gcThresholdWarning: Schema.number().default(DEFAULT_GC_THRESHOLD_WARNING).volatile(),
     gcThresholdError: Schema.number().default(DEFAULT_GC_THRESHOLD_ERROR).volatile(),
+    memGrowthAlertPerMin: Schema.number().default(DEFAULT_MEM_GROWTH_ALERT_PER_MIN).volatile(),
 });
 class MemoryTrendCollector {
     _samples = [];
+    // The poll loop is self-scheduling via setInterval-like recursion with an
+    // ADAPTIVE delay (higher heap usage → shorter interval), so each cycle holds
+    // a fresh setTimeout handle rather than one fixed-interval setInterval.
     _timer = null;
+    /** Monotonic loop generation. Bumped every start()/stop(); a poll() tick
+     *  whose captured generation no longer matches the current one is a stale
+     *  callback from a superseded loop and must NOT re-schedule itself. This
+     *  closes the start/stop restart race where a queued pre-restart tick could
+     *  otherwise clobber the new loop's timer handle and leak a second loop. */
+    _generation = 0;
     _cap;
     // GC monitoring via PerformanceObserver
     _gcObserver = null; // PerformanceObserver | null
@@ -55,10 +64,16 @@ class MemoryTrendCollector {
     }
     start(baseInterval = 30_000, minInterval = 5_000) {
         this.stop();
+        const gen = ++this._generation;
         // Fire-and-forget: GC observer can start asynchronously; the poll loop
         // below begins immediately regardless, since it does not depend on GC.
         this._startGcObserver().catch(() => { });
         const poll = () => {
+            // Bail if this tick belongs to a superseded loop (a restart has bumped
+            // the generation since we were scheduled). The stopped loop then winds
+            // down on its own instead of fighting the fresh loop for this._timer.
+            if (gen !== this._generation)
+                return;
             const mu = process.memoryUsage();
             this._push({
                 ts: Date.now(),
@@ -81,40 +96,42 @@ class MemoryTrendCollector {
         poll();
     }
     stop() {
+        // Bump the generation BEFORE clearing so any in-flight/stale poll tick that
+        // is already queued (past clearTimeout's reach) recognises itself as stale
+        // and refuses to re-schedule, never resurrecting a stopped loop.
+        this._generation++;
         if (this._timer !== null) {
             clearTimeout(this._timer);
             this._timer = null;
         }
         this._stopGcObserver();
     }
-    setCap(cap) {
-        this._cap = Math.max(10, Math.floor(cap) || 10);
-        while (this._samples.length > this._cap)
-            this._samples.shift();
-    }
-    query(since) {
-        if (!since)
+    /** Memory samples at or after `since` (unix ms). A falsy/absent `since`
+     *  (`SINCE_ALL` / undefined) means "return all stored samples". */
+    query(since = SINCE_ALL) {
+        if (since <= 0)
             return this._samples.slice();
         return this._samples.filter(s => s.ts >= since);
     }
     /** Return Full (major) GC events for chart rendering.
-     *  Pass since=0 to return ALL stored events (for full-mode fetches).
      *  Each returned event is one real full-GC cycle (phases already coalesced
      *  in `_startGcObserver`) and is normalized to kind=2 so the client can
-     *  always treat `gcEvents` as "Full GC events". */
-    gcEvents(since) {
+     *  always treat `gcEvents` as "Full GC events".  A falsy/absent `since`
+     *  (`SINCE_ALL` / undefined) means "return all stored events". */
+    gcEvents(since = SINCE_ALL) {
         if (this._gcMajorEvents.length === 0)
             return [];
-        const cutoff = since ?? (Date.now() - 5 * 60 * 1000);
-        return this._gcMajorEvents
-            .filter(e => e.ts >= cutoff)
+        const events = since > 0
+            ? this._gcMajorEvents.filter(e => e.ts >= since)
+            : this._gcMajorEvents;
+        return events
             .map(e => ({ ts: e.ts, kind: 2, duration: e.duration }))
             .sort((a, b) => a.ts - b.ts);
     }
     summary(since) {
         const data = this.query(since);
         if (data.length === 0) {
-            return { current: null, peak: null, trend: 'stable', sampleCount: 0, heapRatio: 0, spanSeconds: 0, rssSlopePerMin: 0, gc: null };
+            return { current: null, peak: null, trend: 'stable', sampleCount: 0, heapRatio: 0, spanMs: 0, rssSlopePerMin: 0, gc: null };
         }
         const current = data[data.length - 1];
         let peak = { heapUsed: 0, rss: 0, ts: 0 };
@@ -143,28 +160,15 @@ class MemoryTrendCollector {
                 trend = 'down';
         }
         const heapRatio = current.heapTotal > 0 ? current.heapUsed / current.heapTotal : 0;
-        const spanSeconds = data.length >= 2 ? Math.round((data[data.length - 1].ts - data[0].ts) / 1000) : 0;
-        // RSS linear regression over the last 20 samples → slope per minute (MB/min).
-        let rssSlopePerMin = 0;
-        if (tail.length >= 3) {
-            const n = tail.length;
-            let sumX = 0, sumY = 0, sumXY = 0, sumXX = 0;
-            for (let i = 0; i < n; i++) {
-                sumX += i;
-                sumY += tail[i].rss;
-                sumXY += i * tail[i].rss;
-                sumXX += i * i;
-            }
-            const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
-            // slope = bytes per sample-index step.  Convert to MB/min.
-            // Average interval between tail samples ≈ spanSeconds / (n-1).
-            const avgIntervalSec = tail.length >= 2 ? spanSeconds / (tail.length - 1) : 30;
-            const samplesPerMin = avgIntervalSec > 0 ? 60 / avgIntervalSec : 2;
-            rssSlopePerMin = Math.round((slope * samplesPerMin / 1048576) * 100) / 100;
-        }
+        const spanMs = data.length >= 2 ? data[data.length - 1].ts - data[0].ts : 0;
+        // RSS linear-regression slope per minute (MB/min); positive = growing.
+        // Delegated to the pure helper (src/pure.ts) so the same logic is unit-
+        // tested. The average interval comes from the tail's own time span — see
+        // rssSlopePerMin for why using the whole buffer span would under-report.
+        const rssSlope = rssSlopePerMin(data);
         // GC stats over the last ~5 minutes.
         const gc = this._gcSummary(5 * 60 * 1000);
-        return { current, peak, trend, sampleCount: data.length, heapRatio, spanSeconds, rssSlopePerMin, gc };
+        return { current, peak, trend, sampleCount: data.length, heapRatio, spanMs, rssSlopePerMin: rssSlope, gc };
     }
     /** Aggregate GC events in the last `windowMs` milliseconds. */
     _gcSummary(windowMs) {
@@ -176,7 +180,14 @@ class MemoryTrendCollector {
         const majorRecent = this._gcMajorEvents.filter(e => e.ts >= cutoff);
         const majorCount = majorRecent.length;
         // Minor count + total pause come from the general ring buffer (which holds
-        // every event).  A minor cycle is a Scavenge (kind bit 1 set).
+        // EVERY PerformanceObserver entry). A minor cycle is a Scavenge (kind bit 1
+        // set). NOTE: gcPauseMs is the SUM of every phase-entry duration in the
+        // window — one real Full GC is reported as multiple phases (kind 4 + 8), and
+        // each contributes its own duration, so gcPauseMs is the TOTAL stop-the-world
+        // pause across all cycles (minor + full), NOT per-cycle. majorCount, by
+        // contrast, comes from the separate coalesced buffer and counts each real
+        // Full GC cycle ONCE. The two buffers intentionally have different semantics:
+        // majorCount = distinct full collections; gcPauseMs = aggregate pauses.
         let minorCount = 0, gcPauseMs = 0;
         for (const e of this._gcEvents) {
             if (e.ts < cutoff)
@@ -257,8 +268,45 @@ class MemoryTrendCollector {
             this._samples.shift();
     }
 }
-/** Module-level singleton — one collector per process. */
+// ── Process-scoped singleton with an exclusive active owner ─────────────
+//
+// A single MemoryTrendCollector is shared across the whole process so all
+// consumers see one coherent ring buffer (each sample carries its own ts).
+// However, Cordis may apply() this plugin more than once (multiple profiles,
+// hot reload) and dispose() them in any order. To avoid two collectors racing
+// on the same module state — and to stop one stray dispose() from killing a
+// collector another apply() is still using — ownership is explicit:
+//
+//   _memoryTrend  : the live collector (or null)
+//   _ownerCtx     : the Context that currently owns it (or null)
+//
+// startTrend()/stopTrend() are idempotent and fail softly when the caller is
+// not the current owner, so overlapping apply/dispose cycles stay safe.
 let _memoryTrend = null;
+let _ownerCtx = null;
+/** Adopt the process-wide collector for `ctx`; no-op if it is already owned. */
+function startTrend(ctx, config) {
+    if (_ownerCtx && _ownerCtx !== ctx)
+        return; // someone else owns it
+    if (!_memoryTrend)
+        _memoryTrend = new MemoryTrendCollector();
+    _ownerCtx = ctx;
+    _memoryTrend.start((config.memPollBase?.get?.() ?? config.memPollBase) || DEFAULT_MEM_POLL_BASE, (config.memPollMin?.get?.() ?? config.memPollMin) || DEFAULT_MEM_POLL_MIN);
+}
+function restartTrend(config) {
+    if (!_memoryTrend || !_ownerCtx)
+        return;
+    _memoryTrend.stop();
+    _memoryTrend.start((config.memPollBase?.get?.() ?? config.memPollBase) || DEFAULT_MEM_POLL_BASE, (config.memPollMin?.get?.() ?? config.memPollMin) || DEFAULT_MEM_POLL_MIN);
+}
+/** Relinquish ownership of `ctx`. Only the active owner may stop the shared
+ *  collector; other ctx instances (already superseded) must not touch it. */
+function stopTrend(ctx) {
+    if (_ownerCtx !== ctx)
+        return; // not the owner → leave the running collector alone
+    _ownerCtx = null;
+    _memoryTrend?.stop();
+}
 // ── Private HTTP helpers ────────────────────────────────────────────────
 /** Send a JSON response with no-store cache control. */
 function sendJson(res, status, payload) {
@@ -267,29 +315,6 @@ function sendJson(res, status, payload) {
     res.setHeader('cache-control', 'no-store');
     res.end(JSON.stringify(payload));
 }
-/**
- * Read an optional JSON request body, bounded so a client cannot feed the
- * host an unbounded buffer. Returns null for an empty, oversized, or
- * unparseable body — callers treat that as "no override supplied".
- */
-async function readJsonBody(req, limit = 4096) {
-    try {
-        const chunks = [];
-        let size = 0;
-        for await (const chunk of req) {
-            size += chunk.length;
-            if (size > limit)
-                return null;
-            chunks.push(chunk);
-        }
-        if (chunks.length === 0)
-            return null;
-        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
-    }
-    catch (_) {
-        return null;
-    }
-}
 // ── apply() ─────────────────────────────────────────────────────────────
 export function apply(ctx, config) {
     // ── Settings namespace registration ──────────────────────────────────
@@ -297,39 +322,37 @@ export function apply(ctx, config) {
         settingsCtx.effect(() => settingsCtx.settings.configure({ auto: false }, ctx.fiber));
     });
     // ── Memory trend collector bootstrap ──────────────────────────────────
-    // One bounded ring buffer per process. Starts on first apply and stops on
-    // dispose. The timer uses .unref() so it never keeps the process alive.
-    if (!_memoryTrend)
-        _memoryTrend = new MemoryTrendCollector();
-    _memoryTrend.start((config.memPollBase?.get?.() ?? config.memPollBase) || DEFAULT_MEM_POLL_BASE, (config.memPollMin?.get?.() ?? config.memPollMin) || DEFAULT_MEM_POLL_MIN);
+    // One bounded ring buffer per process, owned exclusively by the active ctx.
+    // startTrend/stopTrend are idempotent and owner-guarded, so overlapping
+    // apply/dispose cycles never double-start or kill a still-live collector.
+    startTrend(ctx, config);
     ctx.effect(() => {
-        const collector = _memoryTrend;
-        return () => {
-            collector?.stop();
-            _memoryTrend = null;
-        };
-    });
+        const owner = ctx;
+        return () => { stopTrend(owner); };
+    }, 'dsh-flash-mem-mon: memory-trend collector lifecycle');
     // ── Volatile-update handler for poll intervals ────────────────────────
     // Restart the collector when memPollBase or memPollMin change.
     ctx.on('loader/volatile-update', (paths) => {
         const memPaths = ['memPollBase', 'memPollMin'];
         if (!paths.some((pp) => pp.length && memPaths.includes(pp[pp.length - 1])))
             return;
-        if (_memoryTrend) {
-            _memoryTrend.stop();
-            _memoryTrend.start((config.memPollBase?.get?.() ?? config.memPollBase) || DEFAULT_MEM_POLL_BASE, (config.memPollMin?.get?.() ?? config.memPollMin) || DEFAULT_MEM_POLL_MIN);
-        }
+        restartTrend(config);
     });
     // ── HTTP API route for client-side trend data ────────────────────────
-    // The webServer type augmentation lives in @deepseek-ai/dsh-host-webserver
-    // which is not a direct dependency; cast through `any` for the register calls.
+    // Uses a structural HostWebServer type instead of `any`. cordis's inject()
+    // callback is statically typed as Context (the real webServer augmentation
+    // lives in @deepseek-ai/dsh-host-webserver, not a compile-time dep here), so
+    // the injected service is read through one narrow cast inside the callback —
+    // when inject(keys) fires, the service is guaranteed present — then used
+    // under the strong HostWebServer type for the whole register/effect block.
     ctx.inject(['webServer'], (wsCtx) => {
+        const ws = wsCtx.webServer;
         // GET /plugins/dsh-flash-mem-mon/memory-trend
         // Returns memory trend data for the client's config popup.
         // `mode=summary` returns a lightweight snapshot (current, peak, trend direction);
         // `mode=full` returns the raw samples for rendering a chart.
         // Optional `since` (unix ms) limits the range.
-        wsCtx.effect(() => wsCtx.webServer.register({
+        wsCtx.effect(() => ws.register({
             kind: 'exact',
             path: '/plugins/dsh-flash-mem-mon/memory-trend',
             handler: async (req, res) => {
@@ -347,24 +370,20 @@ export function apply(ctx, config) {
                 const since = parseInt(u.searchParams.get('since') || '0', 10) || 0;
                 const mode = u.searchParams.get('mode') || 'summary';
                 if (mode === 'full') {
-                    // For gcEvents: when no explicit `since` is requested (since=0),
-                    // pass 0 so ALL stored events are returned — not just the last 5 min.
-                    // gcEvents(0) → cutoff=0 → returns everything.
-                    // gcEvents(undefined) → cutoff=now-5min → only recent events.
-                    // The sparkline may span hours, so we need the full range.
-                    const gcSince = since > 0 ? since : 0;
-                    // Only return full (major) GC events to the client — minor GC is too
-                    // frequent and clutters the chart.  These are already coalesced into
-                    // one event per real cycle by `_startGcObserver`.  Minor GC stats are
+                    // `since` is already >= 0 here; 0 means "entire range" (SINCE_ALL),
+                    // so both `query` and `gcEvents` share the same bounds convention.
+                    // Only full (major) GC events are sent — minor GC is too frequent
+                    // and clutters the chart.  These are already coalesced into one
+                    // event per real cycle by `_startGcObserver`.  Minor GC stats are
                     // still available via mode=summary (majorPerMin, gcPausePerMin).
-                    const majorGcEvents = _memoryTrend.gcEvents(gcSince);
+                    const majorGcEvents = _memoryTrend.gcEvents(since);
                     sendJson(res, 200, {
-                        samples: _memoryTrend.query(since || undefined),
+                        samples: _memoryTrend.query(since),
                         gcEvents: majorGcEvents,
                     });
                 }
                 else {
-                    sendJson(res, 200, _memoryTrend.summary(since || undefined));
+                    sendJson(res, 200, _memoryTrend.summary(since));
                 }
             },
         }), 'dsh-flash-mem-mon: GET /plugins/dsh-flash-mem-mon/memory-trend');

package/dist/pure.js

@@ -0,0 +1,66 @@
+// Pure, dependency-free helpers extracted from index.ts so they can be unit
+// tested without pulling in cordis / node HTTP / GC-entry types. Everything
+// here is a pure function of its inputs.
+export const DEFAULT_ALERT_CONFIG = {
+    memThresholdInfo: 256,
+    memThresholdWarning: 512,
+    memThresholdError: 1024,
+    memThresholdCritical: 1536,
+    memPollBase: 30000,
+    memPollMin: 2000,
+    gcThresholdInfo: 2,
+    gcThresholdWarning: 5,
+    gcThresholdError: 10,
+    memGrowthAlertPerMin: 1,
+};
+/**
+ * Classify a V8 GC `kind` bitmask as a full (major) cycle.
+ *
+ * V8 GC entry `kind` is a bitmask:
+ *   1 << 0 = Scavenge (minor / young-gen)
+ *   1 << 1 = MarkSweepCompact (major / full)
+ *   1 << 2 = IncrementalMarking
+ *   1 << 3 = ProcessWeakCallbacks
+ *
+ * In practice modern V8/Node reports a full MarkSweepCompact cycle through the
+ * IncrementalMarking (4) and ProcessWeakCallbacks (8) phases — the standalone
+ * "major" bit (2) is almost never emitted on its own.  Classifying Full GC by
+ * `kind === 2` alone therefore misses (nearly) every real full collection.
+ * The robust test: a Full GC is any NON-scavenge cycle, i.e. the Scavenge bit
+ * (1) is NOT set.  This captures 2, 4, 6, 8, 10, 12, 14 while excluding minor
+ * (1) scavenges.
+ */
+export function isFullGc(kind) {
+    return (kind & 1) === 0 && kind > 0;
+}
+/**
+ * Linear-regression slope of `rss` over the last `tailCount` samples, expressed
+ * in MB/min. Returns 0 when there are not enough samples (fewer than 3) or the
+ * tail time span is not positive.
+ *
+ * The average sample interval MUST be derived from the tail's OWN first/last
+ * timestamps, NOT from the whole buffer span (see index.ts summary()). Using a
+ * larger span inflates the interval, deflates samplesPerMin, and under-reports
+ * MB/min — a monotonic-leak false negative.
+ */
+export function rssSlopePerMin(samples, tailCount = 20) {
+    const tail = samples.slice(-tailCount);
+    if (tail.length < 3)
+        return 0;
+    const n = tail.length;
+    let sumX = 0, sumY = 0, sumXY = 0, sumXX = 0;
+    for (let i = 0; i < n; i++) {
+        sumX += i;
+        sumY += tail[i].rss;
+        sumXY += i * tail[i].rss;
+        sumXX += i * i;
+    }
+    // slope = bytes per sample-index step.
+    const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
+    const tailSpanMs = Math.max(tail[tail.length - 1].ts - tail[0].ts, 0);
+    if (tailSpanMs <= 0)
+        return 0;
+    const avgIntervalMs = tailSpanMs / (n - 1);
+    const samplesPerMinute = 60000 / avgIntervalMs;
+    return Math.round((slope * samplesPerMinute / 1048576) * 100) / 100;
+}