dsh-opencode-go-router 0.1.5 → 0.2.0

package/CHANGELOG.en.md

@@ -3,6 +3,26 @@
 All notable changes to this project are documented here. Versioning follows
 [Semantic Versioning](https://semver.org/).
 
+## [0.2.0] - 2026-11-08
+
+### Added
+
+- Persists one performance record per silent switch: the slow trigger samples plus the average TTFT and throughput of the first `sampleSize` requests after the switch. The window freezes once full.
+- Adds a settings-page performance panel in the DSH Web host showing before/after speed, percentage change, and sampling progress, refreshed every five seconds.
+- Exposes a top-level `history` array from the status route; routes written by older versions are backfilled as `backfilled` rows.
+- Adds the client bundle (`dsh.client`) and a registration test.
+
+### Fixed
+
+- The settings-page trigger summary no longer shows the throughput threshold as `?`.
+- The `cordis.patch.yml` insert name now matches the npm package name so the Host does not skip the client `dsh.client` declaration.
+
+## [0.1.6] - 2026-11-08
+
+### Fixed
+
+- Fixed path portability in the test suite on Linux CI and wait for pending state writes before removing temporary directories.
+
 ## [0.1.5] - 2026-11-08
 
 First public release.

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 本项目的所有重要变更都记录在这里，版本号遵循
 [语义化版本](https://semver.org/lang/zh-CN/)。
 
+## [0.2.0] - 2026-11-08
+
+### 新增
+
+- 持久化每次静默切换的性能记录：切换前的触发样本，以及切换后首批 `sampleSize` 条请求的平均 TTFT/吞吐；采样窗口满后冻结。
+- 在 DSH Web 宿主中新增插件设置页性能面板，展示每次切换的前后速度、变化百分比和采样进度；每五秒刷新。
+- 状态路由新增顶层 `history` 数组；旧版本留下的路由会补录为历史行并标记 `backfilled`。
+- 新增客户端 bundle（`dsh.client`）及注册测试。
+
+### 修复
+
+- 插件设置页的触发条件不再把吞吐阈值显示成 `?`。
+- `cordis.patch.yml` 的插入名与 npm 包名保持一致，避免客户端的 `dsh.client` 声明被宿主跳过。
+
+## [0.1.6] - 2026-11-08
+
+### 修复
+
+- 修复测试在 Linux CI 上的路径可移植性问题，并在清理临时目录前等待状态文件写入完成。
+
 ## [0.1.5] - 2026-11-08
 
 首个公开版本。

package/README.md

@@ -30,7 +30,7 @@ The plugin does not compress anything itself and does not change the prompt or t
 - **Routing.** A persisted route maps the DSH session id to a generated `ses_...` value. The `llm-pi-ai/request-headers` waterfall runs after pi-ai assembles its header set and before the request is sent, so setting `x-opencode-session` there reaches the wire. In the reference setup a companion injector such as `dsh-opencode-ip-guard` supplies a baseline value equal to the DSH session id; when a route exists this plugin replaces it, and the injector's no-overwrite fallback leaves the value alone.
 - **No billion-context, no effect.** If the sessions directory or the session state file is absent, the monitor stays idle. The header hook has no route and does nothing. No exception is thrown into DSH.
 
-The first fold seen after a plugin start is a baseline and never causes rotation. Rotation happens on a later fold, matching "at the next fold rebuild". The first system prompt seen in a session is only a fingerprint baseline; a rewrite rotation requires a subsequent observed change. The current session is considered eligible only while its latest ordinary conversation request is an OpenCode Go DeepSeek-series request.
+The first fold seen after a plugin start is a baseline and never causes rotation; this baseline rule applies to the fold path only. Rotation happens on a later fold, matching "at the next fold rebuild". The system-prompt-rewrite path is independent of any fold: even when the session has never recorded a fold, a changed system prompt with slow samples can rotate on the rewrite request itself (the fold cache condition is bypassed). The first system prompt seen in a session is only a fingerprint baseline; a rewrite rotation requires a subsequent observed change. The current session is considered eligible only while its latest ordinary conversation request is an OpenCode Go DeepSeek-series request.
 
 A rotation changes only the upstream routing id. billion-context keeps writing the same state file for the DSH session, so the monitor keeps following it; after recording the fold that triggered the rotation it advances its fold cursor. The same rebuild cannot rotate twice, but a later rebuild can rotate again.
 
@@ -100,8 +100,9 @@ Because the plugin entry point reloads `lib/impl.js` with a cache-busting query
 
 ## Status route
 
-`GET /opencode-router/status` returns JSON with the effective config, persisted routes, and per-session monitor state:
+`GET /opencode-router/status` returns JSON with the effective config, persisted routes, rotation history, and per-session monitor state:
 
+- `history` — recent silent switches, newest first, with `sessionId`, `at`, `reason`, `foldSeq`, `cacheHitPct`, the routing `value`, before/after TTFT and throughput, sample progress, and a `backfilled` marker;
 - `eligibility` — the configured providers and the fixed `deepseek` model prefix;
 - `baselineReady` and `lastFoldSeq` — fold cursor;
 - `latestFold` — latest fold record (including `hPct`);
@@ -116,9 +117,17 @@ Because the plugin entry point reloads `lib/impl.js` with a cache-busting query
 
 The route is localhost-only when the host's web server is bound to localhost. Treat the JSON as diagnostics.
 
+## Settings page
+
+In the DSH Web client, open the plugin manager and select this bundle. Its detail page renders a **Silent switch performance log** above the bundle configuration rows.
+
+For each silent switch it shows the time, a short session id, the trigger (`Fold + speed` or `System rewrite`), the fold number and cache hit behind the decision, average TTFT and throughput before the switch, the first `sampleSize` eligible samples after it, and the percentage change. Rows refresh every five seconds from `GET /opencode-router/status`. The after window is frozen once it has `sampleSize` samples, so later traffic does not rewrite history.
+
+Routes created before 0.2.0 are backfilled as one row per still-known route and marked `Reconstructed`; their after values come from samples retained after that rotation. The panel lives in the Web client and does not affect host routing.
+
 ## Privacy and safety
 
-- Stored data is limited to DSH session ids, generated routing ids, fold numbers, cache percentages, TTFT, throughput, and timestamps. No prompts, messages, tool output, or API keys are stored.
+- Stored data is limited to DSH session ids, generated routing ids, fold numbers, cache percentages, TTFT, throughput, rotation history, and timestamps. No prompts, messages, tool output, or API keys are stored.
 - Every host callback catches its own errors. A missing or malformed billion-context state file only produces a log entry.
 - Rotating a header is a routing hint, not a guarantee that the gateway picks a different physical backend. If the gateway ignores unknown or new session values, the plugin cannot force a move.
 - billion-context's state file is an internal format. If its layout changes, the monitor may see no folds and stay idle; the plugin will not corrupt anything.
@@ -129,7 +138,7 @@ The route is localhost-only when the host's web server is bound to localhost. Tr
 node --test
 ```
 
-The suite covers fold parsing, the cache/performance decision, system-prompt extraction/fingerprinting, the system-rewrite decision, DeepSeek-only eligibility, state persistence, the monitor state machine, header routing, and stream measurement.
+The suite covers fold parsing, the cache/performance decision, system-prompt extraction/fingerprinting, the system-rewrite decision, DeepSeek-only eligibility, state persistence, rotation history, the monitor state machine, header routing, stream measurement, and the client bundle registration.
 
 ## License
 

package/README.zh-CN.md

@@ -30,7 +30,7 @@ OpenCode Go 通过请求头 `x-opencode-session` 把一条会话固定到一个
 - **路由。** 持久化 "DSH 会话 id -> 生成的 `ses_...` 值" 的映射；`llm-pi-ai/request-headers` 瀑布在 pi-ai 组装完请求头之后、真正发请求之前执行，所以在这里设置 `x-opencode-session` 能到达线上请求。参考配置里由伴生插件（如 `dsh-opencode-ip-guard`）提供兜底值（等于 DSH 会话 id）；有路由时本插件覆盖它，伴生插件的"已有头不覆盖"规则则保证原值不被二次改动。
 - **没有 billion-context 也能安全存在。** 找不到 sessions 目录或会话状态文件时，监控器保持空闲；请求头钩子没有可用路由时什么也不做；不会向 DSH 抛异常。
 
-插件启动后看到的第一次折叠只作为基线，绝不触发轮换；轮换发生在之后的折叠，符合"在下一次折叠重建时轮换"。会话中第一次看到的系统提示词只作为指纹基线；改写轮换需要之后观察到实际变化。只有会话最近一次普通对话请求仍是 OpenCode Go 的 DeepSeek 系列请求时，该会话才处于合格状态。
+插件启动后看到的第一次折叠只作为基线，绝不触发轮换；这条基线规则只约束折叠路径，轮换发生在之后的折叠，符合"在下一次折叠重建时轮换"。系统提示词改写路径不依赖任何折叠：即使会话从未记录过折叠，只要系统提示词发生变化且最近样本性能慢，也可以在改写请求本身上轮换（折叠缓存条件被绕过）。会话中第一次看到的系统提示词只作为指纹基线；改写轮换需要之后观察到实际变化。只有会话最近一次普通对话请求仍是 OpenCode Go 的 DeepSeek 系列请求时，该会话才处于合格状态。
 
 轮换只改变上游路由 id。billion-context 仍在同一个状态文件里记录这个 DSH 会话，监控器继续跟踪该文件；记录完触发轮换的那次折叠后，它会把折叠游标推进到该处。同一次重建不会触发两次轮换，但之后的另一次重建仍可再次轮换。
 
@@ -100,8 +100,9 @@ dsh plugin add dsh-opencode-go-router --profile <profile>
 
 ## 状态路由
 
-`GET /opencode-router/status` 返回 JSON：生效配置、已持久化路由、每个会话的监控状态：
+`GET /opencode-router/status` 返回 JSON：生效配置、已持久化路由、轮换性能记录、每个会话的监控状态：
 
+- `history` —— 最近的静默切换记录，最新在前，字段包括 `sessionId`、`at`、`reason`、`foldSeq`、`cacheHitPct`、路由 `value`、切换前后 TTFT/吞吐、样本进度和 `backfilled` 标记；
 - `eligibility` —— 配置的 provider 与固定的 `deepseek` 模型前缀；
 - `baselineReady` 与 `lastFoldSeq` —— 折叠游标；
 - `latestFold` —— 最新折叠记录（含 `hPct`）；
@@ -116,9 +117,17 @@ dsh plugin add dsh-opencode-go-router --profile <profile>
 
 如果宿主 Web 服务只监听 localhost，该路由也只在 localhost 可达。JSON 仅供诊断。
 
+## 设置页
+
+在 DSH Web 客户端打开插件管理器，选中本插件。详情页会在 bundle 配置行上方显示 **静默切换性能记录**。
+
+每条记录展示切换时间、短会话 id、触发原因（`折叠 + 性能` 或 `系统提示词改写`）、触发时的折叠序号与缓存命中率、切换前的平均 TTFT/吞吐、切换后首批 `sampleSize` 条合格样本，以及变化百分比。数据来自 `GET /opencode-router/status`，每五秒刷新一次。切换后的采样窗口凑满 `sampleSize` 条后即冻结，之后的流量不会改写历史。
+
+0.2.0 之前已经写入的路由会按“每个仍保留的路由一行”补录，并标记为 `补录`；其切换后数值来自该次轮换之后仍保留的样本。面板只存在于 Web 客户端，不影响宿主侧路由。
+
 ## 隐私与安全
 
-- 只保存 DSH 会话 id、生成的路由 id、折叠序号、缓存百分比、TTFT、吞吐和时间戳；不保存提示词、消息、工具输出或 API key。
+- 只保存 DSH 会话 id、生成的路由 id、折叠序号、缓存百分比、TTFT、吞吐、轮换性能记录和时间戳；不保存提示词、消息、工具输出或 API key。
 - 所有宿主回调都自行捕获异常。billion-context 状态文件缺失或损坏只会产生日志。
 - 轮换请求头只是路由提示，不保证网关一定换到另一台物理后端。如果网关忽略新的会话值，插件无法强制迁移。
 - billion-context 的状态文件是内部格式。若其结构变化，监控器可能看不到折叠并保持空闲，但不会破坏任何数据。
@@ -129,7 +138,7 @@ dsh plugin add dsh-opencode-go-router --profile <profile>
 node --test
 ```
 
-测试覆盖折叠解析、缓存/性能判定、系统提示词提取与指纹、系统提示词改写判定、仅 DeepSeek 资格、状态持久化、监控状态机、请求头路由和流式耗时测量。
+测试覆盖折叠解析、缓存/性能判定、系统提示词提取与指纹、系统提示词改写判定、仅 DeepSeek 资格、状态持久化、轮换性能记录、监控状态机、请求头路由、流式耗时测量和客户端 bundle 注册。
 
 ## 许可证
 

package/cordis.patch.yml

@@ -2,4 +2,4 @@
 # Defaults live in lib/core.js; override them by id in the profile cordis.patch.yml.
 - insert:
     - id: opencode-router
-      name: 'opencode-router'
+      name: 'dsh-opencode-go-router'

package/lib/client.js

@@ -0,0 +1,380 @@
+/**
+ * Settings-page performance panel for dsh-opencode-go-router.
+ *
+ * This is a hand-written client bundle: the DSH web client loads it through
+ * window.__ModuleLoader__.load, and the only runtime dependency is React.
+ * It renders inside the plugin detail page, so it is scoped to this bundle.
+ */
+
+window.__ModuleLoader__.load({
+  id: 'dsh-opencode-go-router',
+  factory: function (require) {
+    var module = { exports: {} };
+    var exports = module.exports;
+    var React = require('react');
+    var h = React.createElement;
+    var NS = 'opencode-router';
+    var REFRESH_MS = 5000;
+
+    var zh = {
+      title: '静默切换性能记录',
+      subtitle: '每次因缓存丢失或系统提示词改写而切换上游后，对比切换前后请求的速度。',
+      empty: '还没有静默切换记录。',
+      loading: '正在读取状态…',
+      error: '读取状态失败：',
+      retry: '重试',
+      criteria: '触发条件：缓存命中 ≤ {cache}% 且 TTFT ≥ {ttft}s 或吞吐 ≤ {tps} tok/s；系统提示词改写可以绕过缓存条件。',
+      summary: '共 {total} 次切换，{complete} 次已采满样本',
+      avg: '已采满样本的平均变化：TTFT {ttft}，吞吐 {tps}',
+      before: '切换前',
+      after: '切换后',
+      change: '变化',
+      ttft: 'TTFT',
+      tps: '吞吐',
+      fold: '折叠',
+      noFold: '无折叠',
+      cache: '缓存命中',
+      samples: '样本',
+      reasonFold: '折叠 + 性能',
+      reasonRewrite: '系统提示词改写',
+      backfilled: '补录',
+      waiting: '等待样本',
+      none: '—',
+      updated: '更新于',
+      version: '版本',
+      incomplete: '采样中',
+      complete: '已完成',
+    };
+
+    var en = {
+      title: 'Silent switch performance log',
+      subtitle: 'Speed before and after each upstream switch caused by cache loss or a system-prompt rewrite.',
+      empty: 'No silent switches recorded yet.',
+      loading: 'Reading status…',
+      error: 'Failed to read status: ',
+      retry: 'Retry',
+      criteria: 'Triggers: cache hit ≤ {cache}% and TTFT ≥ {ttft}s or throughput ≤ {tps} tok/s; a system-prompt rewrite bypasses the cache condition.',
+      summary: '{total} switches, {complete} with a complete sample window',
+      avg: 'Average change over complete windows: TTFT {ttft}, throughput {tps}',
+      before: 'Before',
+      after: 'After',
+      change: 'Change',
+      ttft: 'TTFT',
+      tps: 'Throughput',
+      fold: 'Fold',
+      noFold: 'No fold',
+      cache: 'Cache hit',
+      samples: 'Samples',
+      reasonFold: 'Fold + speed',
+      reasonRewrite: 'System rewrite',
+      backfilled: 'Reconstructed',
+      waiting: 'Waiting for samples',
+      none: '—',
+      updated: 'Updated',
+      version: 'Version',
+      incomplete: 'Sampling',
+      complete: 'Complete',
+    };
+
+    function fill(template, values) {
+      return String(template).replace(/\{(\w+)\}/g, function (_, key) {
+        return values && values[key] != null ? String(values[key]) : '';
+      });
+    }
+
+    function formatTime(ms) {
+      if (!Number.isFinite(Number(ms))) return '';
+      try {
+        return new Date(Number(ms)).toLocaleString(undefined, {
+          month: '2-digit',
+          day: '2-digit',
+          hour: '2-digit',
+          minute: '2-digit',
+        });
+      } catch {
+        return String(ms);
+      }
+    }
+
+    function shortSession(id) {
+      var text = String(id == null ? '' : id);
+      if (text.indexOf('session-') === 0) text = text.slice(8);
+      return text.length > 12 ? text.slice(0, 8) + '…' : text;
+    }
+
+    function formatTtft(ms) {
+      var value = Number(ms);
+      if (!Number.isFinite(value) || value < 0) return '—';
+      if (value < 1000) return Math.round(value) + ' ms';
+      return (value / 1000).toFixed(1) + ' s';
+    }
+
+    function formatTps(tps) {
+      var value = Number(tps);
+      if (!Number.isFinite(value) || value <= 0) return '—';
+      return (value >= 10 ? value.toFixed(0) : value.toFixed(1)) + ' tok/s';
+    }
+
+    function formatPct(value) {
+      var n = Number(value);
+      if (!Number.isFinite(n)) return '—';
+      return (n >= 0 ? '+' : '') + n.toFixed(1) + '%';
+    }
+
+    function changePct(before, after) {
+      var b = Number(before);
+      var a = Number(after);
+      if (!Number.isFinite(b) || !Number.isFinite(a) || b === 0) return null;
+      return ((a - b) / b) * 100;
+    }
+
+    function useStatus() {
+      var [state, setState] = React.useState({ loading: true, error: '', data: null });
+      var [reloadAt, setReloadAt] = React.useState(0);
+      React.useEffect(function () {
+        var alive = true;
+        var timer = null;
+        async function load() {
+          try {
+            var response = await fetch('/opencode-router/status', { cache: 'no-store' });
+            if (!response.ok) throw new Error('HTTP ' + String(response.status));
+            var data = await response.json();
+            if (alive) setState({ loading: false, error: '', data: data });
+          } catch (error) {
+            if (alive) {
+              setState(function (previous) {
+                return {
+                  loading: false,
+                  error: String(error && error.message ? error.message : error),
+                  data: previous.data,
+                };
+              });
+            }
+          }
+          if (alive) timer = setTimeout(load, REFRESH_MS);
+        }
+        load();
+        return function () {
+          alive = false;
+          if (timer) clearTimeout(timer);
+        };
+      }, [reloadAt]);
+      return { state: state, retry: function () { setReloadAt(function (value) { return value + 1; }); } };
+    }
+
+    function Metric(props) {
+      return h('div', { style: { minWidth: 0 } }, [
+        h('div', { key: 'label', style: { fontSize: 11, opacity: 0.65, marginBottom: 3 } }, props.label),
+        h('div', { key: 'value', style: { fontSize: 14, fontWeight: 600, whiteSpace: 'nowrap', color: props.color || 'inherit' } }, props.value),
+      ]);
+    }
+
+    function ChangeMetric(props) {
+      var pct = changePct(props.before, props.after);
+      var improved = pct != null && (props.lowerIsBetter ? pct < 0 : pct > 0);
+      return h(Metric, {
+        label: props.label,
+        value: pct == null ? '—' : formatPct(pct),
+        color: pct == null ? 'inherit' : (improved ? '#1f9d55' : '#d64545'),
+      });
+    }
+
+    function HistoryRow(props) {
+      var entry = props.entry;
+      var t = props.t;
+      var beforeTtft = entry.beforeTtftMs;
+      var beforeTps = entry.beforeTps;
+      var afterTtft = entry.afterTtftMs;
+      var afterTps = entry.afterTps;
+      var hasAfter = Number.isFinite(Number(afterTtft)) || Number.isFinite(Number(afterTps));
+      var reason = entry.reason === 'system-rewrite' ? t('reasonRewrite') : t('reasonFold');
+      var reasonColor = entry.reason === 'system-rewrite' ? '#7c5cff' : '#0b7fab';
+      var progress = String(entry.afterSamples || 0) + '/' + String(entry.afterTarget || 5);
+      var afterLabel = hasAfter ? t('after') : t('waiting');
+      var metaParts = [
+        entry.foldSeq == null ? t('noFold') : t('fold') + ' #' + String(entry.foldSeq),
+        entry.cacheHitPct == null ? t('cache') + ' —' : t('cache') + ' ' + String(entry.cacheHitPct) + '%',
+        t('samples') + ' ' + progress,
+      ];
+      return h('div', {
+        key: entry.id,
+        style: {
+          border: '1px solid var(--dsh-border-subtle, rgba(127,127,127,0.22))',
+          borderRadius: 10,
+          padding: '10px 12px',
+          background: 'var(--dsh-surface-secondary, rgba(127,127,127,0.045))',
+        },
+      }, [
+        h('div', { key: 'head', style: { display: 'flex', flexWrap: 'wrap', alignItems: 'center', gap: 8, marginBottom: 8 } }, [
+          h('span', { key: 'time', style: { fontSize: 13, fontWeight: 600 } }, formatTime(entry.at)),
+          h('span', { key: 'session', style: { fontSize: 12, opacity: 0.65, fontFamily: 'monospace' } }, shortSession(entry.sessionId)),
+          h('span', {
+            key: 'reason',
+            style: {
+              fontSize: 11,
+              lineHeight: '18px',
+              padding: '0 7px',
+              borderRadius: 999,
+              color: reasonColor,
+              border: '1px solid ' + reasonColor + '55',
+              background: reasonColor + '14',
+            },
+          }, reason),
+          entry.backfilled ? h('span', {
+            key: 'backfilled',
+            title: t('backfilled'),
+            style: { fontSize: 10, opacity: 0.6, border: '1px dashed currentColor', borderRadius: 999, padding: '0 6px' },
+          }, t('backfilled')) : null,
+          h('span', { key: 'state', style: { marginLeft: 'auto', fontSize: 11, opacity: 0.65 } },
+            entry.afterComplete ? t('complete') : t('incomplete')),
+        ]),
+        h('div', {
+          key: 'metrics',
+          style: {
+            display: 'grid',
+            gridTemplateColumns: 'repeat(3, minmax(0, 1fr))',
+            gap: 10,
+            paddingTop: 8,
+            borderTop: '1px dashed var(--dsh-border-subtle, rgba(127,127,127,0.22))',
+          },
+        }, [
+          h('div', { key: 'before' }, [
+            h('div', { key: 'title', style: { fontSize: 11, opacity: 0.6, marginBottom: 5 } }, t('before')),
+            h('div', { key: 'values', style: { display: 'flex', gap: 12, flexWrap: 'wrap' } }, [
+              h(Metric, { key: 'ttft', label: t('ttft'), value: formatTtft(beforeTtft) }),
+              h(Metric, { key: 'tps', label: t('tps'), value: formatTps(beforeTps) }),
+            ]),
+          ]),
+          h('div', { key: 'after' }, [
+            h('div', { key: 'title', style: { fontSize: 11, opacity: 0.6, marginBottom: 5 } }, afterLabel),
+            h('div', { key: 'values', style: { display: 'flex', gap: 12, flexWrap: 'wrap' } }, hasAfter ? [
+              h(Metric, { key: 'ttft', label: t('ttft'), value: formatTtft(afterTtft) }),
+              h(Metric, { key: 'tps', label: t('tps'), value: formatTps(afterTps) }),
+            ] : [
+              h('div', { key: 'waiting', style: { fontSize: 12, opacity: 0.55 } }, t('waiting') + ' ' + progress),
+            ]),
+          ]),
+          h('div', { key: 'change' }, [
+            h('div', { key: 'title', style: { fontSize: 11, opacity: 0.6, marginBottom: 5 } }, t('change')),
+            h('div', { key: 'values', style: { display: 'flex', gap: 12, flexWrap: 'wrap' } }, [
+              h(ChangeMetric, { key: 'ttft', label: t('ttft'), before: beforeTtft, after: afterTtft, lowerIsBetter: true }),
+              h(ChangeMetric, { key: 'tps', label: t('tps'), before: beforeTps, after: afterTps, lowerIsBetter: false }),
+            ]),
+          ]),
+        ]),
+        h('div', { key: 'meta', style: { marginTop: 8, fontSize: 11, opacity: 0.55 } }, metaParts.join(' · ')),
+      ]);
+    }
+
+    function averageChange(entries, field, lowerIsBetter) {
+      var values = entries
+        .map(function (entry) {
+          var pct = changePct(entry['before' + field], entry['after' + field]);
+          return pct;
+        })
+        .filter(function (value) { return Number.isFinite(value); });
+      if (values.length === 0) return null;
+      var total = values.reduce(function (sum, value) { return sum + value; }, 0);
+      return total / values.length;
+    }
+
+    function PerformancePanel(props) {
+      var hook = useStatus();
+      var state = hook.state;
+      var t = typeof props.t === 'function' ? props.t : function (key) { return en[key] || key; };
+      var data = state.data || {};
+      var history = Array.isArray(data.history) ? data.history : [];
+      var completed = history.filter(function (entry) {
+        return entry.afterComplete === true && Number.isFinite(Number(entry.afterTtftMs));
+      });
+      var avgTtft = averageChange(completed, 'TtftMs', true);
+      var avgTps = averageChange(completed, 'Tps', false);
+      var config = data.config || {};
+      var criteria = fill(t('criteria'), {
+        cache: config.cacheHitThresholdPct == null ? '?' : config.cacheHitThresholdPct,
+        ttft: config.ttftThresholdMs == null ? '?' : (Number(config.ttftThresholdMs) / 1000).toFixed(0),
+        tps: config.throughputThresholdTps == null ? '?' : config.throughputThresholdTps,
+      });
+
+      if (props.view && props.view !== 'page') return null;
+
+      var body;
+      if (state.loading && history.length === 0) {
+        body = h('div', { style: { fontSize: 13, opacity: 0.65, padding: '12px 0' } }, t('loading'));
+      } else if (state.error && history.length === 0) {
+        body = h('div', { style: { padding: '10px 0' } }, [
+          h('div', { key: 'error', role: 'alert', style: { color: '#d64545', fontSize: 13 } }, t('error') + state.error),
+          h('button', {
+            key: 'retry',
+            type: 'button',
+            onClick: hook.retry,
+            style: { marginTop: 8, padding: '4px 10px', cursor: 'pointer' },
+          }, t('retry')),
+        ]);
+      } else if (history.length === 0) {
+        body = h('div', { style: { fontSize: 13, opacity: 0.65, padding: '12px 0' } }, t('empty'));
+      } else {
+        body = h('div', {
+          style: {
+            display: 'flex',
+            flexDirection: 'column',
+            gap: 8,
+            maxHeight: 520,
+            overflowY: 'auto',
+            paddingRight: 4,
+          },
+        }, history.map(function (entry) {
+          return h(HistoryRow, { key: entry.id, entry: entry, t: t });
+        }));
+      }
+
+      var summary = history.length > 0 ? fill(t('summary'), {
+        total: history.length,
+        complete: completed.length,
+      }) : '';
+      var avg = (avgTtft != null || avgTps != null) ? fill(t('avg'), {
+        ttft: avgTtft == null ? '—' : formatPct(avgTtft),
+        tps: avgTps == null ? '—' : formatPct(avgTps),
+      }) : '';
+
+      return h('div', {
+        style: {
+          display: 'flex',
+          flexDirection: 'column',
+          gap: 10,
+          fontSize: 13,
+          lineHeight: 1.45,
+        },
+      }, [
+        h('div', { key: 'head', style: { display: 'flex', flexWrap: 'wrap', gap: 8, alignItems: 'baseline' } }, [
+          h('div', { key: 'title', style: { fontSize: 15, fontWeight: 650 } }, t('title')),
+          h('div', { key: 'ver', style: { marginLeft: 'auto', fontSize: 11, opacity: 0.55 } },
+            t('version') + ' ' + String(data.version || '?') + (data.updatedAt ? ' · ' + t('updated') + ' ' + formatTime(data.updatedAt) : '')),
+        ]),
+        h('div', { key: 'subtitle', style: { fontSize: 12, opacity: 0.65 } }, t('subtitle')),
+        h('div', { key: 'criteria', style: { fontSize: 11, opacity: 0.6 } }, criteria),
+        summary ? h('div', { key: 'summary', style: { display: 'flex', gap: 14, flexWrap: 'wrap', fontSize: 12 } }, [
+          h('span', { key: 'count' }, summary),
+          avg ? h('span', { key: 'avg', style: { opacity: 0.75 } }, avg) : null,
+        ]) : null,
+        state.error ? h('div', { key: 'stale', style: { color: '#d64545', fontSize: 11 } }, t('error') + state.error) : null,
+        body,
+      ]);
+    }
+
+    function apply(ctx) {
+      ctx.effect(function () {
+        return ctx.locale.register(NS, { zh: zh, en: en });
+      });
+      ctx.slots.inject('plugins.bundle.config', function* () {
+        yield ctx.slots.register({ name: 'plugins.bundle.config', key: 'dsh-opencode-go-router', locale: NS }, PerformancePanel);
+        yield ctx.slots.register({ name: 'plugins.bundle.config', key: 'opencode-router', locale: NS }, PerformancePanel);
+      });
+    }
+
+    var inject = ['slots', 'locale'];
+    exports.apply = apply;
+    exports.inject = inject;
+    return module.exports;
+  },
+});

package/lib/core.js

@@ -13,7 +13,7 @@ import os from 'node:os';
 import path from 'node:path';
 
 export const NAME = 'opencode-router';
-export const VERSION = '0.1.5';
+export const VERSION = '0.2.0';
 
 /**
  * Only OpenCode Go's DeepSeek-series models are eligible. The check is a

package/lib/impl.js

@@ -233,7 +233,7 @@ function registerStatusRoute(ctx, getStatus, logger) {
 export async function mount(ctx, rawConfig) {
   const logger = createLogger(ctx);
   const config = normalizeConfig(rawConfig);
-  const store = new RouterStore({ statePath: config.statePath, logger });
+  const store = new RouterStore({ statePath: config.statePath, logger, sampleSize: config.sampleSize });
   const monitor = new RouterMonitor({ config, store, logger });
   let disposed = false;
   // Observable proof that the waterfall actually stamped a request. This is
@@ -289,6 +289,7 @@ export async function mount(ctx, rawConfig) {
       updatedAt: snapshot.updatedAt,
       routes: snapshot.routes,
       routing: { ...routingStats },
+      history: store.history(100),
       sessions: monitor.status(),
     };
   };

package/lib/monitor.js

@@ -130,6 +130,31 @@ export class SessionMonitor {
     this.debug('target model ' + (next ? 'eligible' : 'not eligible') + ' for ' + this.sessionId);
   }
 
+  /**
+   * Persist one row for the settings page: the slow samples that justified the
+   * switch and, later, the first samples on the new upstream.
+   */
+  recordRotationHistory(record, performance) {
+    if (this.config.dryRun) return null;
+    try {
+      return this.store.addRotation({
+        sessionId: this.sessionId,
+        at: record.rotatedAt,
+        value: record.value,
+        reason: record.reason,
+        foldSeq: record.foldSeq,
+        cacheHitPct: record.cacheHitPct,
+        beforeTtftMs: record.avgTtftMs,
+        beforeTps: record.avgTps,
+        beforeSamples: performance && Number.isFinite(performance.count) ? performance.count : this.config.sampleSize,
+        afterTarget: this.config.sampleSize,
+      });
+    } catch (error) {
+      this.warn('failed to record rotation history: ' + errorText(error));
+      return null;
+    }
+  }
+
   /**
    * Compare the initial system prompt of an outgoing request with the previous
    * one. The first observation only establishes a baseline. A fingerprint
@@ -191,6 +216,7 @@ export class SessionMonitor {
     };
     if (!this.config.dryRun) {
       this.store.setRoute(this.sessionId, record);
+      this.recordRotationHistory(record, decision.performance);
     }
     this.rotations += 1;
     this.systemRewriteRotations += 1;
@@ -386,6 +412,7 @@ export class SessionMonitor {
     };
     if (!this.config.dryRun) {
       this.store.setRoute(this.sessionId, record);
+      this.recordRotationHistory(record, decision.performance);
     }
     this.rotations += 1;
     const message = 'rotated x-opencode-session for ' + this.sessionId

package/lib/store.js

@@ -10,9 +10,10 @@ import fsp from 'node:fs/promises';
 import path from 'node:path';
 
 const STATE_VERSION = 1;
+const HISTORY_LIMIT = 100;
 
 function emptyState() {
-  return { version: STATE_VERSION, updatedAt: 0, routes: {}, metrics: {} };
+  return { version: STATE_VERSION, updatedAt: 0, routes: {}, metrics: {}, history: [] };
 }
 
 function finiteOrNull(value) {
@@ -36,6 +37,66 @@ function sanitizeRoute(entry) {
   };
 }
 
+function clampCount(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n < 0) return 0;
+  return Math.min(50, Math.round(n));
+}
+
+function historyId(sessionId, at) {
+  return String(sessionId) + '@' + String(at);
+}
+
+function historyAverage(samples, at, target) {
+  const after = samples
+    .filter((sample) => Number.isFinite(Number(sample.at)) && Number(sample.at) >= at)
+    .sort((a, b) => Number(a.at) - Number(b.at))
+    .slice(0, target);
+  if (after.length === 0) {
+    return { ttftMs: null, tps: null, count: 0, complete: false };
+  }
+  let ttftTotal = 0;
+  let tpsTotal = 0;
+  for (const sample of after) {
+    ttftTotal += Number(sample.ttftMs);
+    tpsTotal += Number(sample.tps);
+  }
+  return {
+    ttftMs: Math.round((ttftTotal / after.length) * 10) / 10,
+    tps: Math.round((tpsTotal / after.length) * 100) / 100,
+    count: after.length,
+    complete: after.length >= target,
+  };
+}
+
+function sanitizeHistory(entry) {
+  if (!entry || typeof entry !== 'object') return null;
+  const sessionId = String(entry.sessionId == null ? '' : entry.sessionId).slice(0, 256);
+  const at = finiteOrNull(entry.at);
+  if (sessionId === '' || at == null) return null;
+  const afterTarget = Math.max(1, Math.min(50, clampCount(entry.afterTarget) || 5));
+  const value = typeof entry.value === 'string' ? entry.value.slice(0, 256) : '';
+  return {
+    id: typeof entry.id === 'string' && entry.id !== '' ? entry.id.slice(0, 512) : historyId(sessionId, at),
+    sessionId,
+    at,
+    value,
+    reason: typeof entry.reason === 'string' ? entry.reason.slice(0, 200) : 'unknown',
+    foldSeq: finiteOrNull(entry.foldSeq),
+    cacheHitPct: finiteOrNull(entry.cacheHitPct),
+    beforeTtftMs: finiteOrNull(entry.beforeTtftMs),
+    beforeTps: finiteOrNull(entry.beforeTps),
+    beforeSamples: clampCount(entry.beforeSamples),
+    afterTtftMs: finiteOrNull(entry.afterTtftMs),
+    afterTps: finiteOrNull(entry.afterTps),
+    afterSamples: clampCount(entry.afterSamples),
+    afterTarget,
+    afterComplete: entry.afterComplete === true,
+    afterUpdatedAt: finiteOrNull(entry.afterUpdatedAt),
+    backfilled: entry.backfilled === true,
+  };
+}
+
 function sanitizeMetric(entry) {
   if (!entry || typeof entry !== 'object') return null;
   const ttftMs = finiteOrNull(entry.ttftMs);
@@ -68,6 +129,13 @@ function sanitizeState(raw) {
       if (samples.length > 0) state.metrics[String(sessionId)] = samples;
     }
   }
+  if (Array.isArray(raw.history)) {
+    state.history = raw.history
+      .map(sanitizeHistory)
+      .filter(Boolean)
+      .sort((a, b) => a.at - b.at)
+      .slice(-HISTORY_LIMIT);
+  }
   return state;
 }
 
@@ -78,7 +146,9 @@ export class RouterStore {
     this.logger = opts.logger || console;
     this.now = typeof opts.now === 'function' ? opts.now : Date.now;
     this.debounceMs = Number.isFinite(Number(opts.debounceMs)) ? Number(opts.debounceMs) : 150;
+    this.sampleSize = Math.max(1, Math.min(50, clampCount(opts.sampleSize) || 5));
     this.state = this.load();
+    this.seedHistoryFromRoutes();
     this.dirty = false;
     this.timer = null;
     this.chain = Promise.resolve();
@@ -132,6 +202,102 @@ export class RouterStore {
     return clean;
   }
 
+  /**
+   * Record one silent routing switch. The before values come from the samples
+   * that justified it; the after values are filled in as the first requests on
+   * the new upstream finish, then frozen when the sample target is reached.
+   */
+  addRotation(entry) {
+    const clean = sanitizeHistory(entry);
+    if (!clean) return null;
+    const existing = this.state.history.find((item) => item.id === clean.id);
+    if (existing) return { ...existing };
+    this.state.history.push(clean);
+    this.trimHistory();
+    this.refreshHistoryForSession(clean.sessionId);
+    this.touch();
+    return { ...this.state.history.find((item) => item.id === clean.id) };
+  }
+
+  /**
+   * Existing route files predate the history array. Reconstruct one row per
+   * still-known route so the settings page has something to show immediately;
+   * after values use whatever samples remain from after that rotation.
+   */
+  seedHistoryFromRoutes() {
+    let changed = false;
+    for (const [sessionId, route] of Object.entries(this.state.routes)) {
+      const at = Number(route && route.rotatedAt);
+      if (!Number.isFinite(at)) continue;
+      const id = historyId(sessionId, at);
+      if (this.state.history.some((item) => item.id === id)) continue;
+      const entry = sanitizeHistory({
+        id,
+        sessionId,
+        at,
+        value: route.value,
+        reason: route.reason,
+        foldSeq: route.foldSeq,
+        cacheHitPct: route.cacheHitPct,
+        beforeTtftMs: route.avgTtftMs,
+        beforeTps: route.avgTps,
+        beforeSamples: this.sampleSize,
+        afterTarget: this.sampleSize,
+        backfilled: true,
+      });
+      if (!entry) continue;
+      this.state.history.push(entry);
+      changed = true;
+    }
+    if (!changed) return;
+    this.state.history.sort((a, b) => a.at - b.at);
+    this.trimHistory();
+    for (const entry of this.state.history) this.refreshHistoryForSession(entry.sessionId, false);
+    this.touch();
+  }
+
+  trimHistory() {
+    if (this.state.history.length > HISTORY_LIMIT) {
+      this.state.history = this.state.history.slice(-HISTORY_LIMIT);
+    }
+  }
+
+  refreshHistoryForSession(sessionId, notify = true) {
+    const key = String(sessionId == null ? '' : sessionId);
+    if (key === '') return;
+    const samples = Array.isArray(this.state.metrics[key]) ? this.state.metrics[key] : [];
+    let changed = false;
+    for (const entry of this.state.history) {
+      if (entry.sessionId !== key || entry.afterComplete) continue;
+      const summary = historyAverage(samples, entry.at, entry.afterTarget);
+      if (summary.count === 0) continue;
+      if (entry.afterSamples !== summary.count
+        || entry.afterTtftMs !== summary.ttftMs
+        || entry.afterTps !== summary.tps
+        || entry.afterComplete !== summary.complete) {
+        entry.afterSamples = summary.count;
+        entry.afterTtftMs = summary.ttftMs;
+        entry.afterTps = summary.tps;
+        entry.afterComplete = summary.complete;
+        entry.afterUpdatedAt = this.now();
+        changed = true;
+      }
+    }
+    if (changed && notify) this.touch();
+  }
+
+  history(limit = HISTORY_LIMIT) {
+    const requested = Number(limit);
+    const count = Number.isFinite(requested)
+      ? Math.max(1, Math.min(HISTORY_LIMIT, Math.round(requested)))
+      : HISTORY_LIMIT;
+    return this.state.history
+      .slice()
+      .sort((a, b) => b.at - a.at)
+      .slice(0, count)
+      .map((entry) => ({ ...entry }));
+  }
+
   recordSample(sessionId, sample, maxSamples) {
     const key = String(sessionId == null ? '' : sessionId);
     const clean = sanitizeMetric(sample);
@@ -140,6 +306,7 @@ export class RouterStore {
     const list = Array.isArray(this.state.metrics[key]) ? this.state.metrics[key] : [];
     list.push(clean);
     this.state.metrics[key] = list.slice(-limit);
+    this.refreshHistoryForSession(key, false);
     this.touch();
   }
 

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "dsh-opencode-go-router",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "description": "DeepSeek Harness plugin: rotate OpenCode Go routing after billion-context cache-losing folds or system-prompt rewrites.",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
     ".": "./lib/index.js",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./client": "./lib/client.js"
   },
   "files": [
     "lib",
@@ -24,6 +25,13 @@
     },
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-plugin-manager"
+      ]
     }
   },
   "keywords": [
@@ -56,7 +64,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "check": "node --check lib/index.js && node --check lib/core.js && node --check lib/impl.js && node --check lib/monitor.js && node --check lib/store.js && node --check test/core.test.js && node --check test/impl.test.js && node --check test/monitor.test.js && node --check test/store.test.js",
+    "check": "node --check lib/index.js && node --check lib/core.js && node --check lib/impl.js && node --check lib/monitor.js && node --check lib/store.js && node --check lib/client.js && node --check test/core.test.js && node --check test/impl.test.js && node --check test/monitor.test.js && node --check test/store.test.js && node --check test/client.test.js && node --check test/package.test.js",
     "test": "node --test",
     "prepack": "npm run check && npm test",
     "prepublishOnly": "npm run check && npm test"