dexterm-cli 0.1.7 → 0.2.1

package/dist/packages/classifier/src/registry.js

@@ -0,0 +1,42 @@
+// Config -> Provider. The CLI and MCP server call `providerFromConfig`; the LLM runners (Claude CLI, local Ollama)
+// are injected by the caller so this package never spawns a model process or opens a socket on its own.
+import fs from 'node:fs';
+import { fileUsage, readTypesafeKey } from "./config.js";
+import { heuristicProvider } from "./providers/heuristic.js";
+import { jevOpenProvider } from "./providers/jev-open.js";
+import { llmProvider } from "./providers/llm.js";
+import { jevHostedProvider, kevLocalProvider } from "./providers/systemone-http.js";
+import { ClassifierError } from "./types.js";
+export const PROVIDERS = [
+    { id: 'heuristic', title: 'Built-in scores (H1 p(rug) + LARP link score)', network: 'none', needs: 'nothing' },
+    { id: 'kev-local', title: 'Kev decision model via llama.cpp (open, Apache-2.0)', network: 'local', needs: 'a downloaded Kev GGUF + llama-server' },
+    { id: 'jev-hosted', title: "TypeSafe's hosted Jev (flagship, your own API key)", network: 'remote', needs: 'your TypeSafe API key' },
+    { id: 'jev-open', title: 'JEV open students (autotrust/JEV-*) via vLLM', network: 'local', needs: 'a vLLM server with the JEV decision adapter (>= 24 GB GPU)' },
+    { id: 'claude', title: 'Claude zero-shot (comparison baseline)', network: 'remote', needs: 'the Claude CLI, signed in' },
+    { id: 'ollama-llm', title: 'Ollama chat model zero-shot (comparison baseline)', network: 'local', needs: 'Ollama with a chat model' },
+];
+export function providerFromConfig(c, id = c.provider, d = {}) {
+    switch (id) {
+        case 'heuristic': return heuristicProvider();
+        case 'kev-local': return kevLocalProvider({ endpoint: c.kev.endpoint, modelId: c.kev.model, fetch: d.fetch });
+        case 'jev-hosted': return jevHostedProvider({
+            endpoint: c.jev.endpoint, model: c.jev.model, apiKey: () => readTypesafeKey(d.env), pricePerMTokUsd: c.jev.pricePerMTokUsd,
+            maxCallsPerDay: c.jev.maxCallsPerDay, usage: fileUsage(d.env), fetch: d.fetch,
+        });
+        case 'jev-open': {
+            if (!c.jevOpen.headPath || !c.jevOpen.calibrationPath)
+                throw new ClassifierError('not_ready', 'jev-open needs jevOpen.headPath (adapter_vllm/decision_head.json) and jevOpen.calibrationPath (calibration.json) from the model repo');
+            const head = JSON.parse(fs.readFileSync(c.jevOpen.headPath, 'utf8'));
+            const calibration = JSON.parse(fs.readFileSync(c.jevOpen.calibrationPath, 'utf8'));
+            return jevOpenProvider({ endpoint: c.jevOpen.endpoint, modelId: c.jevOpen.model, head, calibration, fetch: d.fetch });
+        }
+        case 'claude':
+            if (!d.claudeRunner)
+                throw new ClassifierError('not_ready', 'claude baseline: no Claude runner wired');
+            return llmProvider({ id: 'claude', model: c.llm.claudeModel, run: d.claudeRunner });
+        case 'ollama-llm':
+            if (!d.ollamaRunner || !c.llm.ollamaModel)
+                throw new ClassifierError('not_ready', 'ollama-llm baseline: set llm.ollamaModel and have Ollama running');
+            return llmProvider({ id: 'ollama-llm', model: c.llm.ollamaModel, run: d.ollamaRunner });
+    }
+}

package/dist/packages/classifier/src/snapshot.js

@@ -0,0 +1,31 @@
+// The app's live token row (@dexterm/data TokenSnapshot: token + pair + stats + audit) -> CoinInput, so the screener,
+// the MCP tools and watch rules all build the same dossier the benchmark scored.
+import { coinDossier } from "./dossier.js";
+const n = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
+export function coinInputFromSnapshot(s, now = Date.now()) {
+    const p = s.pair, st = s.stats, a = s.audit;
+    const created = n(s.token.createdAt) ?? n(p?.createdAt);
+    const h1 = st?.perWindow?.h1 ?? null;
+    return {
+        mint: s.mint ?? s.token.mint,
+        symbol: s.token.symbol ?? null,
+        name: s.token.name ?? null,
+        age_min: created === null ? null : Math.max(0, (now - created) / 60_000),
+        liquidity_usd: n(p?.liquidityUsd),
+        mcap_usd: n(p?.mcap) ?? n(p?.fdv),
+        vol5m_usd: n(p?.volume?.m5),
+        vol1h_usd: n(p?.volume?.h1),
+        buys5m: n(p?.txns?.m5?.buys), sells5m: n(p?.txns?.m5?.sells),
+        buys1h: n(p?.txns?.h1?.buys), sells1h: n(p?.txns?.h1?.sells),
+        change5m_pct: n(p?.priceChange?.m5), change1h_pct: n(p?.priceChange?.h1),
+        holders: n(st?.holderCount), organic_score: n(st?.organicScore),
+        traders1h: n(h1?.numTraders), net_buyers1h: n(h1?.numNetBuyers),
+        top10_pct: n(a?.top10Pct), dev_pct: n(a?.devPct), dev_other_mints: n(a?.devMints),
+        mint_authority: a?.mintAuthority ?? null, freeze_authority: a?.freezeAuthority ?? null,
+        launchpad: typeof s.token.launchpad === 'string' ? s.token.launchpad : null,
+        dex: p?.dex ?? null,
+    };
+}
+export function dossierFromSnapshot(s, now = Date.now()) {
+    return coinDossier(coinInputFromSnapshot(s, now));
+}

package/dist/packages/classifier/src/systemone.js

@@ -0,0 +1,88 @@
+// The System One wire protocol (`POST /v1/systemone`): TypeSafe's public API, which llama.cpp's llama-server
+// (PR #29818, 2026-10-02) and the Kev reference server also implement. One request = one state + named questions.
+//
+// Request : { model?, state, questions: { id: { type, instructions, criteria? } } }
+// Response: { model, answers: { id: { type, choice?|noul?|score?, probabilities?, confidence?, legend? } }, usage }
+//
+// Normalised here into `Answer` (probs per label + ln-p logits + top + confidence). Anything malformed raises
+// ClassifierError('bad_response') rather than guessing.
+import { labelsOf } from "./questions.js";
+import { ClassifierError } from "./types.js";
+export function buildRequest(set, state, model) {
+    const questions = {};
+    for (const q of set.questions) {
+        const entry = { type: q.type, instructions: q.instructions };
+        if (q.criteria !== undefined)
+            entry.criteria = q.criteria;
+        questions[q.id] = entry;
+    }
+    return model ? { model, state, questions } : { state, questions };
+}
+const EPS = 1e-12;
+/** Entropy-based confidence (1 - H/ln n): 0 for a uniform answer, 1 for a certain one. */
+export function entropyConfidence(probs) {
+    const ps = Object.values(probs);
+    if (ps.length < 2)
+        return 1;
+    const h = -ps.reduce((s, p) => s + (p > 0 ? p * Math.log(p) : 0), 0);
+    return Math.max(0, Math.min(1, 1 - h / Math.log(ps.length)));
+}
+export function finishAnswer(type, probs, confidence) {
+    const sum = Object.values(probs).reduce((a, b) => a + b, 0);
+    if (!(sum > 0))
+        throw new ClassifierError('bad_response', 'answer has no probability mass');
+    const norm = {};
+    const logits = {};
+    let top = '';
+    let best = -1;
+    for (const [k, v] of Object.entries(probs)) {
+        const p = v / sum;
+        norm[k] = p;
+        logits[k] = Math.log(Math.max(p, EPS));
+        if (p > best) {
+            best = p;
+            top = k;
+        }
+    }
+    const conf = typeof confidence === 'number' && Number.isFinite(confidence) ? Math.max(0, Math.min(1, confidence)) : entropyConfidence(norm);
+    return { type, probs: norm, logits, top, confidence: conf };
+}
+function num(v) {
+    return typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : null;
+}
+/** Parse a /v1/systemone response body against the question set that was asked. */
+export function parseResponse(set, body) {
+    if (!body || typeof body !== 'object')
+        throw new ClassifierError('bad_response', 'response is not an object');
+    const b = body;
+    if (!b.answers || typeof b.answers !== 'object')
+        throw new ClassifierError('bad_response', 'response has no answers');
+    const raw = b.answers;
+    const answers = {};
+    for (const q of set.questions) {
+        const a = raw[q.id];
+        if (!a || typeof a !== 'object')
+            throw new ClassifierError('bad_response', `no answer for ${q.id}`);
+        if (q.type === 'noul') {
+            const p = num(a.noul);
+            if (p === null || p > 1)
+                throw new ClassifierError('bad_response', `${q.id}: noul is not a probability`);
+            answers[q.id] = finishAnswer('noul', { yes: p, no: 1 - p }, null);
+            continue;
+        }
+        const pr = a.probabilities;
+        if (!pr || typeof pr !== 'object')
+            throw new ClassifierError('bad_response', `${q.id}: no probabilities`);
+        const labels = labelsOf(q);
+        const probs = {};
+        for (const l of labels) {
+            const p = num(pr[l]);
+            if (p === null)
+                throw new ClassifierError('bad_response', `${q.id}: missing probability for ${l}`);
+            probs[l] = p;
+        }
+        answers[q.id] = finishAnswer(q.type, probs, num(a.confidence));
+    }
+    const tokens = num(b.usage?.input_tokens);
+    return { model: typeof b.model === 'string' ? b.model : '', answers, inputTokens: tokens };
+}

package/dist/packages/classifier/src/types.js

@@ -0,0 +1,18 @@
+// Shared types for @dexterm/classifier (task-1822).
+//
+// A classifier answers TYPED QUESTIONS about ONE DOCUMENT (the coin dossier) with a probability per label. The
+// question shapes follow the System One API (`POST /v1/systemone`, TypeSafe's public API, also served by llama.cpp
+// for Kev GGUFs): `choice` (one of named options), `noul` (yes/no, probability of yes), `score` (ordered levels).
+// Every result names the provider, model id/version and how its probabilities were calibrated, and is labelled a
+// model estimate. Nothing here signs, trades, arms anything or raises a cap.
+export const PROVIDER_IDS = ['heuristic', 'kev-local', 'jev-hosted', 'jev-open', 'claude', 'ollama-llm'];
+export class ClassifierError extends Error {
+    code;
+    retryAfterMs;
+    constructor(code, message, retryAfterMs = null) {
+        super(message);
+        this.name = 'ClassifierError';
+        this.code = code;
+        this.retryAfterMs = retryAfterMs;
+    }
+}

package/dist/packages/cli/assets/dash/dash.css

@@ -0,0 +1,139 @@
+/* dexterm dash (task-1749): the strategy performance dashboard. dexterm's terminal look (site/src/css/site.css tokens) in
+   dark, a paper-white counterpart in light. Mobile first; no web fonts, no external URL. */
+:root {
+  color-scheme: light;
+  --bg: #f6f7f4; --panel: #ffffff; --panel-2: #eef1ec; --text: #0b120e; --muted: #47524b; --line: #d5dbd4; --line-2: #b9c3ba;
+  --accent: #006b78; --series: #0f7a34; --series-soft: rgba(15, 122, 52, .14); --dd: #b4233f; --dd-soft: rgba(180, 35, 63, .14);
+  --up: #0b6e2e; --down: #b0173d; --warn: #7a5a00; --ok-bg: #e2f3e6; --warn-bg: #fbf0cf; --down-bg: #f9e0e5; --idle-bg: #ebedea;
+  --focus: #006b78; --badge: #5a4300; --badge-bg: #fdf3c6;
+  --mono: ui-monospace, 'SF Mono', Menlo, Monaco, 'Cascadia Code', 'DejaVu Sans Mono', monospace;
+  --sans: system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif;
+  --r: 10px; --s1: 4px; --s2: 8px; --s3: 12px; --s4: 16px; --s5: 24px;
+}
+@media (prefers-color-scheme: dark) {
+  :root:where(:not([data-theme="light"])) {
+    color-scheme: dark;
+    --bg: #020507; --panel: #04090c; --panel-2: #071114; --text: #eafff0; --muted: #9fd8b2; --line: #0c3a24; --line-2: #1b5a3a;
+    --accent: #00f0ff; --series: #39ff14; --series-soft: rgba(57, 255, 20, .14); --dd: #ff5c82; --dd-soft: rgba(255, 92, 130, .16);
+    --up: #5dff6e; --down: #ff6b8b; --warn: #f5ff2d; --ok-bg: #062512; --warn-bg: #2a2a05; --down-bg: #2d0812; --idle-bg: #0b1512;
+    --focus: #00f0ff; --badge: #f5ff2d; --badge-bg: #22230a;
+  }
+}
+:root[data-theme="dark"] {
+  color-scheme: dark;
+  --bg: #020507; --panel: #04090c; --panel-2: #071114; --text: #eafff0; --muted: #9fd8b2; --line: #0c3a24; --line-2: #1b5a3a;
+  --accent: #00f0ff; --series: #39ff14; --series-soft: rgba(57, 255, 20, .14); --dd: #ff5c82; --dd-soft: rgba(255, 92, 130, .16);
+  --up: #5dff6e; --down: #ff6b8b; --warn: #f5ff2d; --ok-bg: #062512; --warn-bg: #2a2a05; --down-bg: #2d0812; --idle-bg: #0b1512;
+  --focus: #00f0ff; --badge: #f5ff2d; --badge-bg: #22230a;
+}
+* { box-sizing: border-box; }
+html { -webkit-text-size-adjust: 100%; }
+body { margin: 0; background: var(--bg); color: var(--text); font: 15px/1.45 var(--sans); }
+a { color: var(--accent); }
+:focus-visible { outline: 2px solid var(--focus); outline-offset: 2px; border-radius: 4px; }
+main:focus, main:focus-visible { outline: none; } /* the route target (tabindex -1), focused for screen readers only */
+.skip { position: absolute; left: -999px; top: 0; }
+.skip:focus { left: 8px; top: 8px; background: var(--panel); padding: 8px; z-index: 10; }
+.mono, .num, table, .tile .v, .brand { font-family: var(--mono); }
+.num { font-variant-numeric: tabular-nums; white-space: nowrap; }
+.up { color: var(--up); } .down { color: var(--down); } .muted { color: var(--muted); }
+
+header.top { position: sticky; top: 0; z-index: 5; background: var(--bg); border-bottom: 1px solid var(--line); }
+.bar { display: flex; align-items: center; gap: var(--s3); padding: var(--s2) var(--s4); max-width: 1440px; margin: 0 auto; }
+.brand { font-weight: 700; letter-spacing: .02em; font-size: 16px; white-space: nowrap; }
+.brand b { color: var(--series); }
+.paper { display: inline-block; border: 1px solid var(--line-2); border-radius: 999px; padding: 2px 10px; font: 600 12px/1.6 var(--mono); color: var(--text); background: var(--panel-2); }
+.updated { margin-left: auto; font-size: 12px; color: var(--muted); text-align: right; }
+.updated .dot { display: inline-block; width: 8px; height: 8px; border-radius: 50%; background: var(--series); margin-right: 6px; vertical-align: 1px; }
+.updated.stale .dot { background: var(--down); }
+button.theme { background: var(--panel-2); color: var(--text); border: 1px solid var(--line-2); border-radius: 8px; padding: 6px 10px; font: 13px var(--mono); min-height: 36px; cursor: pointer; }
+nav.tabs { display: flex; gap: 2px; overflow-x: auto; padding: 0 var(--s3); max-width: 1440px; margin: 0 auto; scrollbar-width: none; }
+nav.tabs a { flex: none; padding: 10px 12px; min-height: 44px; display: inline-flex; align-items: center; color: var(--muted); text-decoration: none; border-bottom: 2px solid transparent; font: 600 14px var(--sans); }
+nav.tabs a[aria-current="page"] { color: var(--text); border-bottom-color: var(--series); }
+
+main { max-width: 1440px; margin: 0 auto; padding: var(--s4); }
+h1 { font-size: 20px; margin: 4px 0 4px; } h2 { font-size: 16px; margin: var(--s5) 0 var(--s2); } h3 { font-size: 14px; margin: 0 0 6px; }
+p.lead { margin: 0 0 var(--s3); color: var(--muted); font-size: 14px; }
+.disclaimer { border: 1px dashed var(--line-2); border-radius: var(--r); padding: var(--s2) var(--s3); font-size: 13px; color: var(--muted); margin: 0 0 var(--s4); }
+.disclaimer strong { color: var(--text); }
+
+.grid { display: grid; gap: var(--s3); grid-template-columns: 1fr; }
+@media (min-width: 640px) { .grid { grid-template-columns: repeat(2, 1fr); } }
+@media (min-width: 1080px) { .grid { grid-template-columns: repeat(3, 1fr); } }
+@media (min-width: 1360px) { .grid.g4 { grid-template-columns: repeat(4, 1fr); } }
+.card { background: var(--panel); border: 1px solid var(--line); border-radius: var(--r); padding: var(--s3); min-width: 0; }
+.card.base { border-color: var(--series); box-shadow: inset 0 0 0 1px var(--series); }
+a.card { color: inherit; text-decoration: none; display: block; }
+a.card:hover { border-color: var(--line-2); }
+.card .head { display: flex; align-items: baseline; gap: var(--s2); flex-wrap: wrap; }
+.card .id { font: 700 15px var(--mono); overflow-wrap: anywhere; }
+.card .grp { font-size: 12px; color: var(--muted); }
+.card .label { font-size: 13px; color: var(--muted); margin: 2px 0 6px; }
+.kv { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 6px 10px; margin: 8px 0; }
+.kv div { min-width: 0; } .kv .v.sm { font-size: 12px; } .kv .v.md { font-size: 13px; }
+p.note { font-size: 12px; margin: 8px 0 0; }
+ .kv .k { font-size: 11.5px; color: var(--muted); } .kv .v { font: 600 14px var(--mono); font-variant-numeric: tabular-nums; }
+.badge { display: inline-block; font: 600 11.5px/1.5 var(--mono); padding: 0 7px; border-radius: 999px; border: 1px solid currentColor; }
+.badge.expl { color: var(--badge); background: var(--badge-bg); }
+.badge.ok { color: var(--up); }
+.badge.base { color: var(--series); }
+.badge.none { color: var(--muted); }
+.spark { display: block; width: 100%; height: 40px; }
+.spark .ln { fill: none; stroke: var(--series); stroke-width: 2; stroke-linejoin: round; stroke-linecap: round; }
+.spark .ref { stroke: var(--line-2); stroke-width: 1; stroke-dasharray: 3 3; }
+
+.tiles { display: grid; gap: var(--s2); grid-template-columns: repeat(2, minmax(0, 1fr)); margin: var(--s3) 0; }
+@media (min-width: 760px) { .tiles { grid-template-columns: repeat(4, minmax(0, 1fr)); } }
+@media (min-width: 1200px) { .tiles { grid-template-columns: repeat(6, minmax(0, 1fr)); } }
+.tile { background: var(--panel); border: 1px solid var(--line); border-radius: var(--r); padding: 10px 12px; min-width: 0; }
+.tile .k { font-size: 12px; color: var(--muted); } .tile .v { font-size: 20px; font-weight: 700; font-variant-numeric: tabular-nums; } .tile .s { font-size: 12px; color: var(--muted); font-family: var(--mono); }
+
+.chart { width: 100%; height: auto; display: block; touch-action: pan-y; }
+.chart .grid line { stroke: var(--line); stroke-width: 1; }
+.chart .axis text, .chart .tick { fill: var(--muted); font: 11px var(--mono); }
+.chart .ln { fill: none; stroke: var(--series); stroke-width: 2; stroke-linejoin: round; stroke-linecap: round; }
+.chart .area { fill: var(--series-soft); }
+.chart .dd-area { fill: var(--dd-soft); }
+.chart .dd { fill: none; stroke: var(--dd); stroke-width: 2; stroke-linejoin: round; }
+.chart .ref { stroke: var(--muted); stroke-width: 1; stroke-dasharray: 4 4; }
+.chart .zero { stroke: var(--muted); stroke-width: 1.5; }
+.chart .dot { fill: var(--series); stroke: var(--panel); stroke-width: 2; }
+.chart .ci { stroke: var(--text); stroke-width: 2; stroke-linecap: round; }
+.chart .mean { fill: var(--accent); stroke: var(--panel); stroke-width: 2; }
+.chart .bar { fill: var(--series); }
+.chart .bar.neg { fill: var(--dd); }
+.chart .lbl { fill: var(--text); font: 12px var(--mono); }
+.chart .xh { stroke: var(--muted); stroke-width: 1; }
+.chart .hit { fill: transparent; }
+.chartbox { position: relative; background: var(--panel); border: 1px solid var(--line); border-radius: var(--r); padding: var(--s2); }
+.tip { position: absolute; pointer-events: none; background: var(--panel-2); color: var(--text); border: 1px solid var(--line-2); border-radius: 6px; padding: 4px 8px; font: 12px var(--mono); white-space: nowrap; transform: translate(-50%, -110%); display: none; z-index: 3; }
+
+.tw { overflow-x: auto; border: 1px solid var(--line); border-radius: var(--r); background: var(--panel); -webkit-overflow-scrolling: touch; }
+table { border-collapse: collapse; width: 100%; font-size: 13px; }
+th, td { text-align: left; padding: 7px 10px; border-bottom: 1px solid var(--line); white-space: nowrap; vertical-align: top; }
+td.wrap { white-space: normal; min-width: 220px; }
+th { color: var(--muted); font-weight: 600; position: sticky; top: 0; background: var(--panel); }
+th.r, td.r { text-align: right; }
+tr.base td { background: var(--panel-2); }
+tbody tr:last-child td { border-bottom: 0; }
+caption { text-align: left; padding: 8px 10px; color: var(--muted); font-size: 12px; }
+
+select { font: 14px var(--mono); padding: 8px; min-height: 44px; background: var(--panel); color: var(--text); border: 1px solid var(--line-2); border-radius: 8px; max-width: 100%; }
+label.pick { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; font-size: 13px; color: var(--muted); }
+.rule { border-left: 3px solid var(--accent); padding: 6px 10px; background: var(--panel); font-size: 13.5px; margin: var(--s2) 0 var(--s3); }
+.status { border-left: 4px solid var(--line-2); }
+.status.ok { border-left-color: var(--up); } .status.warn { border-left-color: var(--warn); } .status.down { border-left-color: var(--down); }
+.st { font: 700 12px var(--mono); padding: 1px 8px; border-radius: 999px; }
+.st.ok { background: var(--ok-bg); color: var(--up); } .st.warn { background: var(--warn-bg); color: var(--warn); } .st.down { background: var(--down-bg); color: var(--down); } .st.idle { background: var(--idle-bg); color: var(--muted); }
+dl.items { display: grid; grid-template-columns: minmax(110px, 40%) 1fr; gap: 4px 10px; margin: 8px 0 0; font-size: 13px; }
+dl.items dt { color: var(--muted); } dl.items dd { margin: 0; overflow-wrap: anywhere; }
+footer { max-width: 1440px; margin: 0 auto; padding: var(--s4); color: var(--muted); font-size: 12.5px; border-top: 1px solid var(--line); }
+footer ul { padding-left: 18px; margin: 6px 0; }
+.empty { padding: var(--s4); color: var(--muted); }
+@media (max-width: 480px) { .updated .long { display: none; } .bar { gap: 8px; } nav.tabs { padding: 0 4px; } nav.tabs a { padding: 10px 7px; font-size: 13px; } nav.tabs .wide { display: none; } }
+@media (prefers-reduced-motion: reduce) { * { transition: none !important; animation: none !important; } }
+@media (forced-colors: active) { .chart .ln, .chart .dd, .spark .ln { stroke: CanvasText; } }
+
+.only-wide { display: none; } .only-narrow { display: grid; gap: var(--s2); }
+@media (min-width: 640px) { .only-wide { display: block; } .only-narrow { display: none; } }
+.card.rug .head .r { margin-left: auto; font: 700 15px var(--mono); }

package/dist/packages/cli/assets/dash/dash.js

@@ -0,0 +1,200 @@
+// dexterm dash (task-1749): the page. Plain JS, no dependency, no external request. Reads the JSON the local server
+// computes (or data.json in a static snapshot), renders five views by hash route and refreshes every 30 s.
+'use strict';
+(() => {
+  const SRC = document.querySelector('meta[name="dash-data"]').content;
+  const LIVE = document.body.dataset.mode === 'live';
+  const REFRESH_MS = 30_000;
+  const $ = (s) => document.querySelector(s);
+  const view = $('#view');
+  let D = null; let lastOk = 0; let lastSig = '';
+
+  // ---------- formatting ----------
+  const esc = (s) => String(s ?? '').replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
+  const fin = (x) => typeof x === 'number' && Number.isFinite(x);
+  const MINUS = '−';
+  const sgn = (x, d = 1) => (fin(x) ? `${x > 0 ? '+' : x < 0 ? MINUS : ''}${Math.abs(x).toFixed(d)}` : '–');
+  const pct = (x, d = 1) => (fin(x) ? `<span class="num ${x > 0 ? 'up' : x < 0 ? 'down' : ''}">${sgn(x, d)}%</span>` : '<span class="muted">–</span>');
+  const pp = (x) => (fin(x) ? `${sgn(x)} pp` : '–');
+  const money = (x, unit = 'USD', d) => (!fin(x) ? '–' : unit === 'SOL' ? `${x < 0 ? MINUS : ''}${Math.abs(x).toFixed(d ?? 4)} SOL` : `${x < 0 ? MINUS : ''}$${Math.abs(x).toFixed(d ?? 2)}`);
+  const smoney = (x, unit) => (fin(x) ? `<span class="num ${x > 0 ? 'up' : x < 0 ? 'down' : ''}">${x > 0 ? '+' : ''}${money(x, unit)}</span>` : '–');
+  const ci = (lo, hi) => (fin(lo) && fin(hi) ? `<span class="num muted">(${sgn(lo)} … ${sgn(hi)})</span>` : '');
+  const dtf = new Intl.DateTimeFormat(undefined, { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit', hour12: false });
+  const when = (t) => (fin(t) ? dtf.format(new Date(t)) : '–');
+  const ago = (t) => { if (!fin(t)) return '–'; const s = Math.max(0, Math.round((Date.now() - t) / 1000)); return s < 90 ? `${s} s ago` : s < 5400 ? `${Math.round(s / 60)} min ago` : s < 172800 ? `${Math.round(s / 3600)} h ago` : `${Math.round(s / 86400)} d ago`; };
+  const coin = (c) => `${esc(c.symbol ?? '?')}${c.mint ? ` <span class="muted mono">${esc(c.mint.slice(0, 4))}…${esc(c.mint.slice(-4))}</span>` : ''}`;
+  const byId = (id) => D.strategies.find((s) => s.id === id);
+  const minN = () => D.definitions.minClosed;
+  const badge = (s) => {
+    const r = s.row;
+    const b = r.sample === 'none' ? '<span class="badge none">no closed trades</span>' : r.sample === 'exploratory' ? `<span class="badge expl" title="Fewer than ${minN()} closed trades: read nothing into the numbers yet">exploratory · ${r.closed} closed &lt; ${minN()}</span>` : `<span class="badge ok">${r.closed} closed ≥ ${minN()}</span>`;
+    return b + (s.baseline ? ' <span class="badge base">baseline</span>' : '');
+  };
+  const eta = (r) => (r.closed >= minN() ? 'reached' : fin(r.etaDays) ? `≈ ${r.etaDays < 1 ? `${Math.round(r.etaDays * 24)} h` : `${r.etaDays.toFixed(1)} d`}` : 'no entries yet');
+
+  // ---------- charts (inline SVG, one series per chart, one y-axis) ----------
+  // the SVG is drawn at its container's width (320-720 user units) so 11 px axis text stays 11 px on a phone
+  let W = 720; let H = 240; const P = { l: 58, r: 12, t: 12, b: 26 };
+  const narrow = () => W < 520;
+  const fitWidth = () => { W = Math.round(Math.min(720, Math.max(320, view.clientWidth - 34))); H = narrow() ? 200 : 240; };
+  const ticks = (lo, hi, n = 4) => { if (lo === hi) { lo -= 1; hi += 1; } const step0 = (hi - lo) / n; const mag = 10 ** Math.floor(Math.log10(step0)); const step = [1, 2, 2.5, 5, 10].map((m) => m * mag).find((s) => s >= step0); const out = []; for (let v = Math.ceil(lo / step) * step; v <= hi + 1e-9; v += step) out.push(+v.toFixed(10)); return out; };
+  function spark(s) {
+    const pts = [{ v: s.equity.start }, ...s.equity.points.map((p) => ({ v: p.usd }))];
+    if (pts.length < 2) return '<svg class="spark" viewBox="0 0 120 40" aria-hidden="true"><line class="ref" x1="0" x2="120" y1="20" y2="20"/></svg>';
+    const vs = pts.map((p) => p.v); const lo = Math.min(...vs); const hi = Math.max(...vs); const span = hi - lo || 1;
+    const x = (i) => (i / (pts.length - 1)) * 116 + 2; const y = (v) => 36 - ((v - lo) / span) * 32;
+    return `<svg class="spark" viewBox="0 0 120 40" preserveAspectRatio="none" role="img" aria-label="Realized equity, ${esc(money(s.equity.start, s.unit))} to ${esc(money(s.equity.end, s.unit))}"><line class="ref" x1="0" x2="120" y1="${y(s.equity.start).toFixed(1)}" y2="${y(s.equity.start).toFixed(1)}"/><path class="ln" vector-effect="non-scaling-stroke" d="${pts.map((p, i) => `${i ? 'L' : 'M'}${x(i).toFixed(1)},${y(p.v).toFixed(1)}`).join('')}"/></svg>`;
+  }
+  /** A time-series line (or drawdown area) with a crosshair + tooltip. pts: [{t, v, tip}] */
+  function timeChart(id, pts, { ref = null, fmt = (v) => v.toFixed(2), kind = 'line', label }) {
+    if (pts.length < 2) return `<p class="empty">Not enough closed trades for a curve yet (${pts.length}).</p>`;
+    const t0 = pts[0].t; const t1 = pts[pts.length - 1].t; const tspan = t1 - t0 || 1;
+    const vs = pts.map((p) => p.v).concat(ref === null ? [] : [ref]); let lo = Math.min(...vs); let hi = Math.max(...vs);
+    if (kind === 'dd') { hi = 0; lo = Math.min(lo, -1); }
+    const pad = (hi - lo || 1) * 0.08; lo -= kind === 'dd' ? pad : pad; hi += kind === 'dd' ? 0 : pad;
+    const X = (t) => P.l + ((t - t0) / tspan) * (W - P.l - P.r); const Y = (v) => P.t + (1 - (v - lo) / (hi - lo)) * (H - P.t - P.b);
+    const yt = ticks(lo, hi); const path = pts.map((p, i) => `${i ? 'L' : 'M'}${X(p.t).toFixed(1)},${Y(p.v).toFixed(1)}`).join('');
+    const xt = [t0, t0 + tspan / 2, t1];
+    let body = `<g class="grid">${yt.map((v) => `<line x1="${P.l}" x2="${W - P.r}" y1="${Y(v).toFixed(1)}" y2="${Y(v).toFixed(1)}"/>`).join('')}</g>`;
+    body += `<g class="axis">${yt.map((v) => `<text x="${P.l - 6}" y="${(Y(v) + 4).toFixed(1)}" text-anchor="end">${esc(fmt(v))}</text>`).join('')}${xt.map((t, i) => `<text x="${X(t).toFixed(1)}" y="${H - 6}" text-anchor="${['start', 'middle', 'end'][i]}">${esc(when(t))}</text>`).join('')}</g>`;
+    if (ref !== null) body += `<line class="ref" x1="${P.l}" x2="${W - P.r}" y1="${Y(ref).toFixed(1)}" y2="${Y(ref).toFixed(1)}"/>`;
+    if (kind === 'dd') body += `<path class="dd-area" d="${path}L${X(t1).toFixed(1)},${Y(0).toFixed(1)}L${X(t0).toFixed(1)},${Y(0).toFixed(1)}Z"/><path class="dd" d="${path}"/>`;
+    else body += `<path class="area" d="${path}L${X(t1).toFixed(1)},${(H - P.b).toFixed(1)}L${X(t0).toFixed(1)},${(H - P.b).toFixed(1)}Z"/><path class="ln" d="${path}"/>`;
+    const last = pts[pts.length - 1];
+    if (kind !== 'dd') body += `<circle class="dot" r="4.5" cx="${X(last.t).toFixed(1)}" cy="${Y(last.v).toFixed(1)}"/>`;
+    body += `<line class="xh" id="${id}-xh" y1="${P.t}" y2="${H - P.b}" x1="-10" x2="-10"/><rect class="hit" x="${P.l}" y="0" width="${W - P.l - P.r}" height="${H}"/>`;
+    chartData[id] = { pts: pts.map((p) => ({ x: X(p.t), y: Y(p.v), tip: p.tip })) };
+    return `<div class="chartbox"><svg class="chart" id="${id}" viewBox="0 0 ${W} ${H}" role="img" aria-label="${esc(label)}">${body}</svg><div class="tip" id="${id}-tip"></div></div>`;
+  }
+  const chartData = {};
+  function wireCharts() {
+    for (const [id, cd] of Object.entries(chartData)) {
+      const svg = document.getElementById(id); if (!svg) continue;
+      const tip = document.getElementById(`${id}-tip`); const xh = document.getElementById(`${id}-xh`);
+      const move = (ev) => {
+        const r = svg.getBoundingClientRect(); const vx = ((ev.clientX - r.left) / r.width) * W;
+        let best = cd.pts[0]; for (const p of cd.pts) if (Math.abs(p.x - vx) < Math.abs(best.x - vx)) best = p;
+        xh.setAttribute('x1', best.x); xh.setAttribute('x2', best.x);
+        tip.innerHTML = best.tip; tip.style.display = 'block';
+        const box = svg.parentElement.getBoundingClientRect();
+        tip.style.left = `${Math.min(Math.max((best.x / W) * r.width + (r.left - box.left), 70), box.width - 70)}px`; tip.style.top = `${(best.y / H) * r.height + (r.top - box.top)}px`;
+      };
+      const out = () => { tip.style.display = 'none'; xh.setAttribute('x1', -10); xh.setAttribute('x2', -10); };
+      svg.addEventListener('pointermove', move); svg.addEventListener('pointerdown', move); svg.addEventListener('pointerleave', out);
+    }
+  }
+  /** Exit reasons as horizontal bars (count), the mean % per reason as text. */
+  function exitBars(exits) {
+    if (!exits.length) return '<p class="empty">No closed trades yet.</p>';
+    const max = Math.max(...exits.map((e) => e.n)); const rowH = 30; const h = exits.length * rowH + 8; const L = narrow() ? 92 : 150; const R = narrow() ? 92 : 150;
+    const rows = exits.map((e, i) => { const w = Math.max(4, (e.n / max) * (W - L - R)); const y = 4 + i * rowH;
+      return `<g><title>${esc(e.reason)}: ${e.n} closed, mean ${sgn(e.meanPct)}%, ${e.wins} wins</title><text class="lbl" x="${L - 8}" y="${y + 18}" text-anchor="end">${esc(e.reason.slice(0, narrow() ? 12 : 20))}</text><rect class="bar${fin(e.meanPct) && e.meanPct < 0 ? ' neg' : ''}" x="${L}" y="${y + 5}" width="${w.toFixed(1)}" height="18" rx="4"/><text class="lbl" x="${L + w + 8}" y="${y + 18}">${e.n} · ${esc(sgn(e.meanPct))}%</text></g>`; }).join('');
+    return `<div class="chartbox"><svg class="chart" viewBox="0 0 ${W} ${h}" role="img" aria-label="Closed trades by exit reason">${rows}</svg></div>`;
+  }
+  /** Compare: the difference in mean % per entry vs the baseline with its 95% interval (a dot and whisker per variant). */
+  function forest(cs) {
+    const ok = cs.filter((c) => fin(c.diff.mean)); if (!ok.length) return '<p class="empty">Nothing to compare yet.</p>';
+    const vals = ok.flatMap((c) => [c.diff.lo, c.diff.hi, c.diff.mean]).filter(fin).concat([0]); let lo = Math.min(...vals); let hi = Math.max(...vals); const pad = (hi - lo || 1) * 0.06; lo -= pad; hi += pad;
+    const L = narrow() ? 118 : 150; const R = 16; const rowH = 30; const h = ok.length * rowH + 34; const X = (v) => L + ((v - lo) / (hi - lo)) * (W - L - R);
+    const xt = ticks(lo, hi, 5);
+    let b = `<g class="grid">${xt.map((v) => `<line x1="${X(v).toFixed(1)}" x2="${X(v).toFixed(1)}" y1="4" y2="${h - 24}"/>`).join('')}</g><g class="axis">${xt.map((v) => `<text x="${X(v).toFixed(1)}" y="${h - 8}" text-anchor="middle">${esc(sgn(v, 0))}</text>`).join('')}</g><line class="zero" x1="${X(0).toFixed(1)}" x2="${X(0).toFixed(1)}" y1="4" y2="${h - 24}"/>`;
+    ok.forEach((c, i) => { const y = 4 + i * rowH + 14;
+      b += `<g><title>${esc(c.id)} − ${esc(c.base)}: ${pp(c.diff.mean)} (95% ${sgn(c.diff.lo)} … ${sgn(c.diff.hi)}), ${c.n} vs ${c.baseN} closed. ${esc(c.verdict)}</title><text class="lbl" x="${L - 8}" y="${y + 4}" text-anchor="end">${esc(c.id.slice(0, narrow() ? 15 : 18))}</text>${fin(c.diff.lo) && fin(c.diff.hi) ? `<line class="ci" x1="${X(c.diff.lo).toFixed(1)}" x2="${X(c.diff.hi).toFixed(1)}" y1="${y}" y2="${y}"/>` : ''}<circle class="mean" r="5.5" cx="${X(c.diff.mean).toFixed(1)}" cy="${y}"/></g>`; });
+    return `<div class="chartbox"><svg class="chart" viewBox="0 0 ${W} ${h}" role="img" aria-label="Difference in mean % per entry against the baseline, with 95% intervals">${b}</svg></div><p class="muted note">Dot = difference in mean % on cost per entry (variant minus baseline, percentage points); line = its 95% interval. A line that crosses 0 means the data cannot tell them apart.</p>`;
+  }
+
+  // ---------- views ----------
+  const disclaimer = () => `<p class="disclaimer"><strong>Paper trading, not financial advice.</strong> Simulated fills on paper books. Small samples say almost nothing: every number carries its sample size, and anything under ${minN()} closed trades is exploratory.</p>`;
+  function overview() {
+    const S = D.strategies;
+    if (!S.length) return `<h1>Overview</h1>${disclaimer()}<p class="empty">No strategies found. Run a paper strategy with <code>dexterm autotrade run</code>, then come back.</p>${notes()}`;
+    const cards = S.map((s) => { const r = s.row;
+      return `<a class="card${s.baseline ? ' base' : ''}" href="#/strategy/${encodeURIComponent(s.id)}"><div class="head"><span class="id">${esc(s.id)}</span><span class="grp">${esc(s.group)}</span></div><div class="label">${esc(s.label)}</div><div>${badge(s)}</div>
+        <div class="kv"><div><div class="k">mean / trade</div><div class="v">${pct(r.meanPct)}</div></div><div><div class="k">closed · open</div><div class="v">${r.closed} · ${r.open}</div></div><div><div class="k">wins · rugs</div><div class="v">${r.wins} · ${r.rugs}</div></div>
+        <div><div class="k">95% interval</div><div class="v sm">${fin(r.lo) ? `${sgn(r.lo)} … ${sgn(r.hi)}` : '–'}</div></div><div><div class="k">realized</div><div class="v md">${smoney(r.realizedUsd, s.unit)}</div></div><div><div class="k">ETA to ${minN()}</div><div class="v md">${eta(r)}</div></div></div>${spark(s)}</a>`; }).join('');
+    const rows = S.map((s) => { const r = s.row; return `<tr${s.baseline ? ' class="base"' : ''}><td><a href="#/strategy/${encodeURIComponent(s.id)}">${esc(s.id)}</a>${s.baseline ? ' <span class="badge base">baseline</span>' : ''}</td><td>${esc(s.group)}</td><td class="r num">${r.entries}</td><td class="r num">${r.closed}</td><td class="r num">${r.open}</td><td class="r num">${r.writtenOff}</td><td class="r num">${r.wins} / ${r.losses}</td><td class="r num">${r.rugs}${r.closed ? ` (${Math.round(r.rugRate * 100)}%)` : ''}</td><td class="r">${pct(r.meanPct)} ${ci(r.lo, r.hi)}</td><td class="r">${smoney(r.realizedUsd, s.unit)}</td><td class="r num">${fin(s.equity.maxDrawdownPct) ? `${s.equity.maxDrawdownPct.toFixed(1)}%` : '–'}</td><td class="r num">${fin(r.entriesPerDay) ? r.entriesPerDay.toFixed(1) : '–'}</td><td>${eta(r)}</td><td>${r.sample === 'exploratory' ? 'exploratory' : r.sample === 'none' ? '–' : 'n ≥ ' + minN()}</td></tr>`; }).join('');
+    return `<h1>Overview</h1><p class="lead">${S.length} strategies side by side${D.baseline ? `; the baseline is <strong class="mono">${esc(D.baseline)}</strong>` : ''}. Tap one for its detail.</p>${disclaimer()}<div class="grid g4">${cards}</div>
+      <h2>Table view</h2><div class="tw"><table><caption>Mean % on cost per closed trade with its 95% interval; rugs = closed at ${D.definitions.rugPct}% or worse; drawdown of the realized equity curve.</caption><thead><tr><th>strategy</th><th>group</th><th class="r">entries</th><th class="r">closed</th><th class="r">open</th><th class="r">written off</th><th class="r">wins / losses</th><th class="r">rugs</th><th class="r">mean % (95%)</th><th class="r">realized</th><th class="r">max DD</th><th class="r">entries/day</th><th>ETA to ${minN()}</th><th>sample</th></tr></thead><tbody>${rows}</tbody></table></div>${notes()}`;
+  }
+  function strategy(id) {
+    const S = D.strategies; if (!S.length) return overview();
+    const s = byId(id) ?? S[0]; const r = s.row; const u = s.unit;
+    const pick = `<label class="pick" for="pick">Strategy <select id="pick">${S.map((x) => `<option value="${esc(x.id)}"${x.id === s.id ? ' selected' : ''}>${esc(x.id)}${x.baseline ? ' (baseline)' : ''} · ${esc(x.group)}</option>`).join('')}</select></label>`;
+    const tiles = [['mean % on cost', pct(r.meanPct), fin(r.lo) ? `95% ${sgn(r.lo)} … ${sgn(r.hi)}` : 'no interval yet'], ['closed', `<span class="num">${r.closed}</span>`, `${r.entries} entries · ${r.open} open`], ['wins / losses', `<span class="num">${r.wins} / ${r.losses}</span>`, r.closed ? `${Math.round((r.wins / r.closed) * 100)}% won` : '–'],
+      ['rugs (≤ ' + D.definitions.rugPct + '%)', `<span class="num">${r.rugs}</span>`, r.closed ? `${Math.round(r.rugRate * 100)}% (95% ${Math.round((r.rugCi[0] ?? 0) * 100)}–${Math.round((r.rugCi[1] ?? 0) * 100)}%)` : '–'], ['realized', smoney(r.realizedUsd, u), `book ${money(s.equity.start, u)} → ${money(s.equity.end, u)}`], ['max drawdown', `<span class="num">${s.equity.maxDrawdownPct.toFixed(1)}%</span>`, `${fin(r.entriesPerDay) ? r.entriesPerDay.toFixed(1) : '–'} entries/day · ETA ${eta(r)}`]]
+      .map(([k, v, x]) => `<div class="tile"><div class="k">${k}</div><div class="v">${v}</div><div class="s">${x}</div></div>`).join('');
+    const eqPts = [{ t: s.firstEventAt ?? (s.equity.points[0]?.t ?? 0), v: s.equity.start, tip: `start ${money(s.equity.start, u)}` }, ...s.equity.points.map((p, i) => { const c = s.trades[i]; return { t: p.t, v: p.usd, tip: `${esc(when(p.t))} · ${money(p.usd, u)}${c ? ` · ${esc(c.symbol ?? '?')} ${sgn(c.pnlPct)}%` : ''}` }; })];
+    const ddPts = [{ t: eqPts[0].t, v: 0, tip: 'peak' }, ...s.equity.points.map((p) => ({ t: p.t, v: -p.drawdownPct, tip: `${esc(when(p.t))} · drawdown ${p.drawdownPct.toFixed(1)}%` }))];
+    const open = s.open.length ? `<div class="tw"><table><thead><tr><th>coin</th><th>profile</th><th class="r">cost</th><th class="r">engine mark</th><th class="r">pool liquidity</th><th class="r">realizable</th><th>state</th></tr></thead><tbody>${s.open.map((o) => `<tr><td>${coin(o)}</td><td>${esc(o.profile ?? '–')}</td><td class="r num">${money(o.costUsd, u)}</td><td class="r">${money(o.markUsd, u)} ${pct(o.markPct)}</td><td class="r num">${fin(o.liqUsd) ? `$${Math.round(o.liqUsd).toLocaleString()} <span class="muted">(${ago(o.liqAt)})</span>` : '<span class="muted">not read</span>'}</td><td class="r">${fin(o.realizableUsd) ? `${money(o.realizableUsd, u)} ${pct(o.realizablePct)}` : '<span class="muted">unknown (no pool read)</span>'}</td><td>${o.stuck ? '<strong class="down">stuck: no pool to sell into</strong>' : 'open'}</td></tr>`).join('')}</tbody></table></div>` : '<p class="empty">No open positions.</p>';
+    const trades = s.trades.length ? `<div class="tw"><table><thead><tr><th>closed</th><th>coin</th><th>profile</th><th class="r">% on cost</th><th class="r">P/L</th><th class="r">cost</th><th class="r">held</th><th>exit</th></tr></thead><tbody>${[...s.trades].reverse().slice(0, 300).map((c) => `<tr><td class="num">${esc(when(c.t))}</td><td>${coin(c)}</td><td>${esc(c.profile ?? '–')}</td><td class="r">${pct(c.pnlPct)}</td><td class="r">${smoney(c.pnlUsd, u)}</td><td class="r num">${money(c.costUsd, u)}</td><td class="r num">${fin(c.openedAt) ? `${Math.max(0, Math.round((c.t - c.openedAt) / 60000))} min` : '–'}</td><td>${c.writtenOff ? '<strong>written off</strong>' : esc(c.exitReason ?? '–')}</td></tr>`).join('')}</tbody></table></div>` : '<p class="empty">No closed trades yet.</p>';
+    return `<h1 class="mono">${esc(s.id)}</h1><p class="lead">${esc(s.label)} · ${esc(s.group)} · ${esc(s.mode ?? 'paper')} · ${badge(s)} · last event ${ago(s.lastEventAt)}</p>${pick}${disclaimer()}<div class="tiles">${tiles}</div>
+      <h2>Realized equity</h2>${timeChart('eq', eqPts, { ref: s.equity.start, fmt: (v) => (u === 'SOL' ? v.toFixed(2) : `$${v.toFixed(0)}`), label: `Realized equity of ${s.id} over time` })}
+      <h2>Drawdown from the running peak</h2>${timeChart('dd', ddPts, { fmt: (v) => `${v.toFixed(0)}%`, kind: 'dd', label: `Drawdown of ${s.id}` })}
+      <h2>Exit reasons</h2>${exitBars(r.exits)}
+      <h2>Open positions</h2><p class="lead">Engine mark = what the engine values it at. Realizable = that mark sold into the last pool read from the local cache (price impact on half the liquidity, 2.3% fees and slippage). Stuck = 0.</p>${open}
+      <h2>Trades (${s.trades.length})</h2>${trades}`;
+  }
+  function rugs() {
+    const all = D.strategies.flatMap((s) => s.rugs.map((c) => ({ s, c }))).sort((a, b) => b.c.t - a.c.t);
+    const stuckOpen = D.strategies.flatMap((s) => s.open.filter((o) => o.stuck).map((o) => ({ s, o })));
+    const rows = all.map(({ s, c }) => `<tr><td><a href="#/strategy/${encodeURIComponent(s.id)}">${esc(s.id)}</a></td><td>${coin(c)}</td><td class="num">${esc(when(c.t))}</td><td class="r">${pct(c.pnlPct)}</td><td class="r num">${money(c.costUsd, s.unit)}</td><td class="r num">${c.writtenOff ? money(c.realizedUsd, s.unit) : '–'}</td><td class="r num">${fin(c.entryAgeMin) ? `${c.entryAgeMin < 120 ? `${Math.round(c.entryAgeMin)} min` : `${(c.entryAgeMin / 60).toFixed(1)} h`}` : '–'}</td><td class="r num">${fin(c.entryLiqUsd) ? `$${Math.round(c.entryLiqUsd).toLocaleString()}` : '–'}</td><td class="wrap">${c.writtenOff ? `<strong>written off</strong>: ${esc(c.reason ?? '')}` : `closed ${esc(c.exitReason ?? '')}`}</td></tr>`).join('');
+    const age = (c) => (fin(c.entryAgeMin) ? (c.entryAgeMin < 120 ? `${Math.round(c.entryAgeMin)} min` : `${(c.entryAgeMin / 60).toFixed(1)} h`) : '–');
+    const cards = all.map(({ s, c }) => `<div class="card rug"><div class="head"><span class="id">${coin(c)}</span><span class="grp">${esc(s.id)}</span><span class="r">${pct(c.pnlPct)}</span></div><dl class="items"><dt>closed</dt><dd>${esc(when(c.t))}</dd><dt>cost → sold</dt><dd>${money(c.costUsd, s.unit)} → ${c.writtenOff ? money(c.realizedUsd, s.unit) : '–'}</dd><dt>pool at entry</dt><dd>${age(c)} old${fin(c.entryLiqUsd) ? ` · $${Math.round(c.entryLiqUsd).toLocaleString()} liq` : ''}</dd><dt>why</dt><dd>${c.writtenOff ? `<strong>written off</strong>: ${esc(c.reason ?? '')}` : `closed ${esc(c.exitReason ?? '')}`}</dd></dl></div>`).join('');
+    return `<h1>Rugs &amp; stuck</h1><p class="lead">Closed at ${D.definitions.rugPct}% or worse, plus every stuck position written off: the engine could not sell it (no pool to sell into) for ${D.definitions.writeOffMin} min or more, so it is closed here at what it actually sold; the unsold rest counts 0. The engine's own files are never edited.</p>${disclaimer()}
+      ${stuckOpen.length ? `<h2>Stuck now (not yet written off)</h2><div class="tw"><table><thead><tr><th>strategy</th><th>coin</th><th class="r">cost</th><th class="r">engine mark</th></tr></thead><tbody>${stuckOpen.map(({ s, o }) => `<tr><td>${esc(s.id)}</td><td>${coin(o)}</td><td class="r num">${money(o.costUsd, s.unit)}</td><td class="r">${money(o.markUsd, s.unit)}</td></tr>`).join('')}</tbody></table></div>` : ''}
+      <h2>Rugs and write-offs (${all.length})</h2>${all.length ? `<div class="only-narrow">${cards}</div><div class="tw only-wide"><table><thead><tr><th>strategy</th><th>coin</th><th>closed</th><th class="r">% on cost</th><th class="r">cost</th><th class="r">sold before stuck</th><th class="r">pool age at entry</th><th class="r">liquidity at entry</th><th>why</th></tr></thead><tbody>${rows}</tbody></table></div>` : '<p class="empty">None so far.</p>'}`;
+  }
+  function compare() {
+    if (!D.baseline) return `<h1>Compare</h1>${disclaimer()}<p class="empty">No baseline set. Start the dashboard with <code>--baseline ID</code> to compare every strategy with it.</p>`;
+    const rows = D.comparisons.map((c) => `<tr><td><a href="#/strategy/${encodeURIComponent(c.id)}">${esc(c.id)}</a></td><td class="r num">${c.n} / ${c.baseN}</td><td class="r num">${pp(c.diff.mean)}</td><td class="r">${ci(c.diff.lo, c.diff.hi)}</td><td>${esc(c.verdict)}</td></tr>`).join('');
+    return `<h1>Compare with the baseline</h1><p class="lead">Each strategy against <strong class="mono">${esc(D.baseline)}</strong>: the difference in mean % on cost per closed trade, with its 95% bootstrap interval.</p>${disclaimer()}<div class="rule"><strong>Decision rule.</strong> ${esc(D.decisionRule)}</div>${forest(D.comparisons)}
+      <h2>Table view</h2><div class="tw"><table><thead><tr><th>strategy</th><th class="r">closed (strategy / baseline)</th><th class="r">difference</th><th class="r">95% interval</th><th>verdict</th></tr></thead><tbody>${rows}</tbody></table></div>`;
+  }
+  function live() {
+    const cards = D.status.map((c) => `<section class="card status ${esc(c.state)}"><div class="head"><h3>${esc(c.title)}</h3><span class="st ${esc(c.state)}">${esc({ ok: 'up', warn: 'attention', down: 'down', idle: 'idle' }[c.state] ?? c.state)}</span></div><dl class="items">${c.items.map(([k, v]) => `<dt>${esc(k)}</dt><dd>${/^\d{4}-\d\d-\d\dT[\d:.]+Z$/.test(v) ? `${esc(when(Date.parse(v)))} <span class="muted">(${ago(Date.parse(v))})</span>` : esc(v)}</dd>`).join('')}</dl>${fin(c.updatedAt) ? `<p class="muted note">updated ${ago(c.updatedAt)}</p>` : ''}</section>`).join('');
+    const last = D.strategies.map((s) => `<tr><td>${esc(s.id)}</td><td>${esc(s.group)}</td><td class="num">${ago(s.lastEventAt)}</td><td class="r num">${s.open.length}</td></tr>`).join('');
+    return `<h1>Live status</h1><p class="lead">${LIVE ? `What is running now. This page re-reads the ledgers every ${REFRESH_MS / 1000} s.` : 'A snapshot: what was running when it was taken.'} Data computed ${ago(D.generatedAt)}.</p>${disclaimer()}<div class="grid">${cards || '<p class="empty">No status sources.</p>'}</div>
+      <h2>Last ledger event per strategy</h2><div class="tw"><table><thead><tr><th>strategy</th><th>group</th><th>last event</th><th class="r">open</th></tr></thead><tbody>${last}</tbody></table></div>${notes()}`;
+  }
+  const notes = () => (D.notes?.length ? `<h2>Notes</h2><ul class="muted">${D.notes.map((n) => `<li>${esc(n)}</li>`).join('')}</ul>` : '');
+  function foot() {
+    $('#foot').innerHTML = `<p><strong>Paper trading, not financial advice.</strong> Simulated trades on paper books; no real funds, no wallet, no keys. Simulated results say nothing about future results.</p><details><summary>What the numbers mean</summary><ul>${D.definitions.text.map((t) => `<li>${esc(t)}</li>`).join('')}</ul></details><p>${LIVE ? 'Served by <code>dexterm dash</code> on this machine (read-only).' : `Read-only snapshot taken ${esc(when(D.generatedAt))}.`}</p>`;
+  }
+
+  // ---------- routing, refresh, theme ----------
+  const route = () => { const h = location.hash.replace(/^#\/?/, '').split('/'); return { name: h[0] || 'overview', arg: h[1] ? decodeURIComponent(h[1]) : null }; };
+  function render() {
+    if (!D) return;
+    const r = route(); const focusPick = document.activeElement?.id === 'pick'; const sy = window.scrollY;
+    for (const k of Object.keys(chartData)) delete chartData[k];
+    fitWidth();
+    view.innerHTML = r.name === 'strategy' ? strategy(r.arg) : r.name === 'rugs' ? rugs() : r.name === 'compare' ? compare() : r.name === 'live' ? live() : overview();
+    for (const a of document.querySelectorAll('nav.tabs a')) { if (a.dataset.view === (['strategy', 'rugs', 'compare', 'live'].includes(r.name) ? r.name : 'overview')) a.setAttribute('aria-current', 'page'); else a.removeAttribute('aria-current'); }
+    const pick = $('#pick'); if (pick) { pick.addEventListener('change', () => { location.hash = `#/strategy/${encodeURIComponent(pick.value)}`; }); if (focusPick) pick.focus(); }
+    wireCharts(); foot(); window.scrollTo(0, sy);
+  }
+  function stamp(err) {
+    const el = $('#updated'); const t = $('#updated-text');
+    if (!D) { t.textContent = err ? `cannot read data (${err})` : 'loading…'; el.classList.toggle('stale', !!err); return; }
+    const stale = LIVE ? (Date.now() - lastOk > REFRESH_MS * 3 || !!err) : true;
+    el.classList.toggle('stale', LIVE && stale);
+    t.innerHTML = LIVE ? `updated ${esc(ago(D.generatedAt))}<span class="long"> · auto-refresh ${REFRESH_MS / 1000} s</span>${err ? ` · <strong>refresh failed</strong>` : ''}` : `snapshot ${esc(when(D.generatedAt))}`;
+  }
+  async function load() {
+    try {
+      const res = await fetch(SRC, { cache: 'no-store' }); if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const d = await res.json(); lastOk = Date.now(); D = d;
+      const sig = JSON.stringify([d.strategies, d.status, d.comparisons]);
+      if (sig !== lastSig) { lastSig = sig; render(); }
+      stamp(null);
+    } catch (e) { stamp(String(e.message ?? e)); }
+  }
+  const THEMES = ['auto', 'dark', 'light'];
+  function setTheme(t) { if (t === 'auto') delete document.documentElement.dataset.theme; else document.documentElement.dataset.theme = t; const b = $('#theme'); b.textContent = t; b.setAttribute('aria-label', `Theme: ${t}. Switch theme`); try { localStorage.setItem('dexterm-dash-theme', t); } catch { /* private mode */ } }
+  $('#theme').addEventListener('click', () => { const cur = document.documentElement.dataset.theme ?? 'auto'; setTheme(THEMES[(THEMES.indexOf(cur) + 1) % 3]); });
+  try { const t = new URLSearchParams(location.search).get('theme') ?? localStorage.getItem('dexterm-dash-theme'); if (THEMES.includes(t)) setTheme(t); } catch { /* none */ }
+  let lastW = 0; window.addEventListener('resize', () => { const w = view.clientWidth; if (Math.abs(w - lastW) > 40) { lastW = w; clearTimeout(window.__dashRs); window.__dashRs = setTimeout(render, 150); } });
+  window.addEventListener('hashchange', () => { render(); view.focus({ preventScroll: true }); window.scrollTo(0, 0); });
+  load();
+  if (LIVE) { setInterval(load, REFRESH_MS); setInterval(() => stamp(null), 10_000); }
+})();

package/dist/packages/cli/assets/dash/icon.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><rect width="32" height="32" rx="6" fill="#020507"/><path d="M5 22 L11 16 L16 19 L22 10 L27 13" fill="none" stroke="#39ff14" stroke-width="3" stroke-linecap="round" stroke-linejoin="round"/></svg>

package/dist/packages/cli/assets/dash/index.html

@@ -0,0 +1,36 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<meta name="dash-data" content="api/dash.json">
+<meta name="robots" content="noindex, nofollow">
+<meta name="referrer" content="no-referrer">
+<title>dexterm dash · strategy performance (PAPER)</title>
+<link rel="icon" href="icon.svg" type="image/svg+xml">
+<link rel="stylesheet" href="dash.css">
+</head>
+<body data-mode="live">
+<a class="skip" href="#view">Skip to content</a>
+<header class="top">
+  <div class="bar">
+    <span class="brand" aria-label="dexterm dash">dexterm<b>/</b>dash</span>
+    <span class="paper" title="Every number here is a simulation">PAPER</span>
+    <div class="updated" id="updated" role="status" aria-live="polite"><span class="dot" aria-hidden="true"></span><span id="updated-text">loading…</span></div>
+    <button class="theme" id="theme" type="button" aria-label="Theme: automatic. Switch theme">auto</button>
+  </div>
+  <nav class="tabs" aria-label="Views">
+    <a href="#/overview" data-view="overview">Overview</a>
+    <a href="#/strategy" data-view="strategy">Strategy</a>
+    <a href="#/rugs" data-view="rugs">Rugs &amp; stuck</a>
+    <a href="#/compare" data-view="compare">Compare</a>
+    <a href="#/live" data-view="live">Live<span class="wide">&nbsp;status</span></a>
+  </nav>
+</header>
+<main id="view" tabindex="-1"><p class="empty">Loading the run ledgers…</p></main>
+<footer id="foot">
+  <p><strong>Paper trading, not financial advice.</strong> Simulated trades on a paper book; no real funds, no wallet, no keys. Past simulated results say nothing about future results.</p>
+</footer>
+<script src="dash.js"></script>
+</body>
+</html>