dexterm-cli 0.1.2 → 0.1.4

package/dist/packages/data/src/intel/live-signals.js

@@ -0,0 +1,185 @@
+// dexterm — LIVE holder / rug SIGNALS engine (task-1404). Pure + deterministic.
+//
+// The token screen used to read holders and safety ONCE, when you opened it. This engine turns a stream of
+// repeated OBSERVATIONS of a token's holder/rug state into SIGNAL events — the changes worth telling a trader
+// about while the token is open or on the watchlist: a dev/creator sell, a top-holder / top-10 concentration
+// shift, LP removal or an unlock change, a mint/freeze authority flip, a new bundle / sniper cluster, a
+// fresh-wallet inflow, bonding-curve progress, a migration.
+//
+// Every signal is a RISK FLAG, never a certificate, and carries its SOURCE and the AGE of the data it read, with
+// an honest `stale` flag. No I/O, no clock, no randomness: the caller feeds `now` and already-fetched readings,
+// so a recording replays to the same signals and the tests can assert each one. Nothing here signs or trades.
+//
+// Baseline rule: a signal only fires on a comparison between two FRESH readings of the same field. A reading that
+// is stale (its panel kept the last value after a failed refresh, or it is older than `staleAfterMs`) updates the
+// latest-known value but never fires a signal off it — we cannot honestly timestamp a change we did not see land.
+// The first observation of a mint sets the baseline and fires nothing (so opening a token never floods).
+export const DEFAULT_SIGNAL_THRESHOLDS = {
+    devSellPct: 1,
+    concentrationPct: 3,
+    lpDropPct: 1,
+    liqDropFrac: 0.25,
+    bundlePct: 1,
+    sniperCount: 1,
+    freshPct: 5,
+    bondingStepPct: 5,
+    staleAfterMs: 60_000,
+};
+/** Every signal kind, for docs / UI / the alerts trigger catalogue. */
+export const SIGNAL_KINDS = [
+    'dev-sell', 'concentration', 'lp-unlock', 'liquidity', 'authority', 'bundle', 'sniper', 'fresh-wallet', 'bonding', 'migrated',
+];
+const CUMULATIVE = new Set(['bonding', 'bundled', 'snipers', 'fresh']);
+const r1 = (n) => Math.round(n * 10) / 10;
+export class LiveSignalsEngine {
+    thresholds;
+    state = new Map();
+    constructor(opts = {}) {
+        this.thresholds = { ...DEFAULT_SIGNAL_THRESHOLDS, ...opts.thresholds };
+    }
+    /** Whether a reading is too stale to fire a signal from (still updates the latest-known baseline). */
+    stale(reading, now) {
+        return reading.stale || now - reading.fetchedAt > this.thresholds.staleAfterMs;
+    }
+    /**
+     * Record one observation and return the signals it produced (empty for the first observation of a mint, or
+     * when nothing crossed a threshold). Baseline discipline (see module note):
+     *  - the first reading of a field sets the baseline and fires nothing;
+     *  - a STALE reading neither fires nor advances the baseline (so when it is fresh again we compare to the last
+     *    value we actually saw and never miss a change that happened while stale, nor fire off stale data);
+     *  - a fresh LEVEL field (dev / top10 / lpLocked / liq / authorities) is compared to the previous value and the
+     *    baseline then advances to the current value;
+     *  - a fresh CUMULATIVE field (bonding / bundled / snipers / fresh) advances its baseline ONLY when it fires, so
+     *    gradual drift between fast pushes accumulates until it crosses the threshold instead of being lost.
+     */
+    observe(obs) {
+        const t = this.thresholds;
+        const now = obs.at;
+        const prev = this.state.get(obs.mint) ?? { latest: {}, latestBool: {}, anchor: {} };
+        const next = { latest: { ...prev.latest }, latestBool: { ...prev.latestBool }, anchor: { ...prev.anchor } };
+        const out = [];
+        const mk = (kind, level, title, text, reading, value, delta) => {
+            out.push({ kind, mint: obs.mint, level, title, text, source: reading.source, dataAgeMs: Math.max(0, now - reading.fetchedAt), stale: false, value, delta, at: now });
+            return true;
+        };
+        const num = (key, reading, fire) => {
+            if (!reading || reading.value === null || !Number.isFinite(reading.value))
+                return;
+            const cur = reading.value;
+            const prevLatest = prev.latest[key];
+            const state = { value: cur, source: reading.source, fetchedAt: reading.fetchedAt };
+            const cumulative = CUMULATIVE.has(key);
+            if (!prevLatest) {
+                next.latest[key] = state;
+                if (cumulative)
+                    next.anchor[key] = cur;
+                return;
+            } // first: baseline only
+            if (this.stale(reading, now))
+                return; // stale: keep the last fresh value, fire nothing, do not advance
+            next.latest[key] = state; // latest always tracks the newest fresh value
+            const anchor = cumulative ? (prev.anchor[key] ?? prevLatest.value) : prevLatest.value;
+            const fired = fire(anchor, cur, reading) === true;
+            if (cumulative && fired)
+                next.anchor[key] = cur; // cumulative anchor advances only when a signal fires
+        };
+        num('dev', obs.dev, (was, cur, reading) => was - cur >= t.devSellPct && mk('dev-sell', 'warn', 'dev sold', `creator sold — dev holding ${r1(was)}% → ${r1(cur)}%`, reading, r1(cur), r1(cur - was)));
+        num('top10', obs.top10, (was, cur, reading) => {
+            const d = cur - was;
+            return Math.abs(d) >= t.concentrationPct && mk('concentration', d > 0 ? 'warn' : 'info', d > 0 ? 'top-10 up' : 'top-10 down', `top-10 concentration ${r1(was)}% → ${r1(cur)}% (pools excluded)`, reading, r1(cur), r1(d));
+        });
+        num('lpLocked', obs.lpLocked, (was, cur, reading) => was - cur >= t.lpDropPct && mk('lp-unlock', 'down', 'LP unlocked', `LP locked dropped ${r1(was)}% → ${r1(cur)}%`, reading, r1(cur), r1(cur - was)));
+        num('liq', obs.liq, (was, cur, reading) => {
+            if (was > 0 && cur < was && (was - cur) / was >= t.liqDropFrac) {
+                const pct = Math.round(((was - cur) / was) * 100);
+                return mk('liquidity', 'down', 'liquidity fell', `liquidity fell ~${pct}% ($${fmtUsd(was)} → $${fmtUsd(cur)})`, reading, Math.round(cur), Math.round(cur - was));
+            }
+            return false;
+        });
+        num('bundled', obs.bundled, (was, cur, reading) => cur - was >= t.bundlePct && mk('bundle', 'warn', 'bundle up', `bundled supply ${r1(was)}% → ${r1(cur)}% of the top sample`, reading, r1(cur), r1(cur - was)));
+        num('snipers', obs.snipers, (was, cur, reading) => cur - was >= t.sniperCount && mk('sniper', 'warn', 'snipers up', `snipers ${Math.round(was)} → ${Math.round(cur)} in the launch window`, reading, Math.round(cur), Math.round(cur - was)));
+        num('fresh', obs.fresh, (was, cur, reading) => cur - was >= t.freshPct && mk('fresh-wallet', 'warn', 'fresh wallets', `fresh-at-buy wallets ${r1(was)}% → ${r1(cur)}% of the top sample`, reading, r1(cur), r1(cur - was)));
+        num('cluster', obs.cluster, () => false); // tracked for the rules field only; concentration covers the UI
+        num('bonding', obs.bonding, (was, cur, reading) => cur - was >= t.bondingStepPct && mk('bonding', 'info', 'bonding', `bonding curve ${r1(was)}% → ${r1(cur)}%`, reading, r1(cur), r1(cur - was)));
+        // --- authorities: a false→true flip is the risk (minting / freezing re-enabled); true→false is good news.
+        const auth = (key, reading, label, risk) => {
+            if (!reading || reading.present === null)
+                return;
+            const cur = reading.present;
+            const was = prev.latestBool[key];
+            const state = { value: cur, source: reading.source, fetchedAt: reading.fetchedAt };
+            if (!was) {
+                next.latestBool[key] = state;
+                return;
+            }
+            if (this.stale(reading, now))
+                return;
+            if (was.value !== cur) {
+                if (cur)
+                    mk('authority', 'warn', `${label} on`, `${label} re-enabled — ${risk}`, reading, 1, 1);
+                else
+                    mk('authority', 'up', `${label} revoked`, `${label} revoked`, reading, 0, -1);
+            }
+            next.latestBool[key] = state;
+        };
+        auth('mintAuth', obs.mintAuth, 'mint authority', 'new supply can be minted');
+        auth('freezeAuth', obs.freezeAuth, 'freeze authority', 'transfers can be frozen');
+        // --- migration: once, on the false→true flip.
+        if (obs.migrated && obs.migrated.value !== null) {
+            const cur = obs.migrated.value;
+            const was = prev.latestBool.migrated;
+            const state = { value: cur, source: obs.migrated.source, fetchedAt: obs.migrated.fetchedAt };
+            if (!was) {
+                next.latestBool.migrated = state;
+            }
+            else if (!this.stale(obs.migrated, now)) {
+                if (!was.value && cur)
+                    mk('migrated', 'info', 'migrated', 'migrated to a DEX pool — bonding curve closed', obs.migrated, 1, 1);
+                next.latestBool.migrated = state;
+            }
+        }
+        this.state.set(obs.mint, next);
+        return out;
+    }
+    /** The latest-known numeric fields for a mint, for the rules engine (null when never observed). */
+    fields(mint) {
+        const s = this.state.get(mint);
+        const n = (x) => (x ? x.value : null);
+        const b = (x) => (x ? (x.value ? 1 : 0) : null);
+        return {
+            top10: n(s?.latest.top10), dev: n(s?.latest.dev), bundled: n(s?.latest.bundled), snipers: n(s?.latest.snipers), fresh: n(s?.latest.fresh),
+            cluster: n(s?.latest.cluster), lpLocked: n(s?.latest.lpLocked), bonding: n(s?.latest.bonding),
+            mintable: b(s?.latestBool.mintAuth), freezable: b(s?.latestBool.freezeAuth),
+        };
+    }
+    /** A per-field snapshot with age + stale for the UI (null source = never observed). */
+    snapshot(mint, now) {
+        const s = this.state.get(mint);
+        const fromNum = (x) => this.snap(x, now);
+        const fromBool = (x) => (x ? { value: x.value ? 1 : 0, source: x.source, ageMs: Math.max(0, now - x.fetchedAt), stale: now - x.fetchedAt > this.thresholds.staleAfterMs } : { value: null, source: null, ageMs: null, stale: false });
+        return {
+            top10: fromNum(s?.latest.top10), dev: fromNum(s?.latest.dev), bundled: fromNum(s?.latest.bundled), snipers: fromNum(s?.latest.snipers),
+            fresh: fromNum(s?.latest.fresh), cluster: fromNum(s?.latest.cluster), lpLocked: fromNum(s?.latest.lpLocked), bonding: fromNum(s?.latest.bonding),
+            liq: fromNum(s?.latest.liq), mintable: fromBool(s?.latestBool.mintAuth), freezable: fromBool(s?.latestBool.freezeAuth), migrated: fromBool(s?.latestBool.migrated),
+        };
+    }
+    snap(x, now) {
+        if (!x)
+            return { value: null, source: null, ageMs: null, stale: false };
+        return { value: x.value, source: x.source, ageMs: Math.max(0, now - x.fetchedAt), stale: now - x.fetchedAt > this.thresholds.staleAfterMs };
+    }
+    /** Drop a mint's baseline (closed token the UI no longer tracks). */
+    forget(mint) { this.state.delete(mint); }
+    /** Known mints (for hygiene / tests). */
+    tracked() { return [...this.state.keys()]; }
+}
+function fmtUsd(n) {
+    const a = Math.abs(n);
+    if (a >= 1e9)
+        return `${r1(n / 1e9)}B`;
+    if (a >= 1e6)
+        return `${r1(n / 1e6)}M`;
+    if (a >= 1e3)
+        return `${r1(n / 1e3)}K`;
+    return String(Math.round(n));
+}

package/dist/packages/data/src/trade/copy/index.js

@@ -2,7 +2,7 @@
 // capped auto-mirror copy mandate (Tier 3). Personal, self-directed, non-custodial; paper/devnet only; nothing
 // here signs, holds a key, or arms anything without the plan engine's own keypress gate.
 export { SOL_LEG_MIN_LAMPORTS, tokenDeltasForOwner, lamportsDeltaFor, decodeTx, decodeWalletTrades } from "./trades.js";
-export { WIN_RATE_MIN_N, positionsOf, earlyEntryScore, walletStats } from "./stats.js";
+export { WIN_RATE_MIN_N, positionsOf, earlyEntryScore, walletStats, fmtHoldMs } from "./stats.js";
 export { FOLLOW_NAME_MAX, FOLLOWS_MAX, defaultFollowsPath, isWalletAddress, cleanFollowName, FollowStore, shortAddr } from "./follows.js";
 export { WalletTracker, TRACKER_DEFAULTS } from "./tracker.js";
 export { MIRROR_LIMITS, leaderFillPriceUsd, buildMirror, leaderSoldSince } from "./mirror.js";

package/dist/packages/data/src/trade/copy/stats.js

@@ -17,12 +17,13 @@ export function positionsOf(trades) {
         const delta = BigInt(tr.tokenDelta);
         let p = pos.get(tr.mint);
         if (!p) {
-            p = { mint: tr.mint, tokensRaw: 0n, peakRaw: 0n, costSol: 0, realisedSol: 0, buys: 0, sells: 0, transfers: 0, flagged: false, closed: false, firstT: tr.t, lastT: tr.t };
+            p = { mint: tr.mint, tokensRaw: 0n, peakRaw: 0n, costSol: 0, realisedSol: 0, buys: 0, sells: 0, transfers: 0, flagged: false, closed: false, firstT: tr.t, lastT: tr.t, firstKnown: tr.tKnown, lastKnown: tr.tKnown, holdMs: null };
             pos.set(tr.mint, p);
         }
         const L = lots.get(tr.mint) ?? [];
         lots.set(tr.mint, L);
         p.lastT = tr.t;
+        p.lastKnown = tr.tKnown;
         if (delta > 0n) {
             // a buy with a SOL leg carries cost; a token-swap leg or an airdrop is cost 0 and flagged
             const cost = tr.side === 'buy' && tr.solDelta !== null ? Math.abs(tr.solDelta) : 0;
@@ -76,8 +77,34 @@ export function positionsOf(trades) {
         }
         p.closed = closedNow(p);
     }
+    // hold time = first buy → last sell, only trustworthy for a CLOSED position whose first+last block times are both real
+    for (const p of pos.values())
+        p.holdMs = p.closed && p.firstKnown && p.lastKnown && p.lastT > p.firstT ? p.lastT - p.firstT : null;
     return [...pos.values()].sort((a, b) => b.lastT - a.lastT);
 }
+/** Compact human hold time: 45s · 12m · 3.2h · 2.1d. null → '—'. */
+export function fmtHoldMs(ms) {
+    if (ms === null)
+        return '—';
+    const s = ms / 1000;
+    if (s < 90)
+        return `${Math.round(s)}s`;
+    const m = s / 60;
+    if (m < 90)
+        return `${Math.round(m)}m`;
+    const h = m / 60;
+    if (h < 48)
+        return `${h.toFixed(1)}h`;
+    return `${(h / 24).toFixed(1)}d`;
+}
+/** Median over the numbers (already finite); undefined on an empty list. */
+function median(xs) {
+    if (!xs.length)
+        return undefined;
+    const s = [...xs].sort((a, b) => a - b);
+    const mid = Math.floor(s.length / 2);
+    return s.length % 2 ? s[mid] : (s[mid - 1] + s[mid]) / 2;
+}
 /** Early-entry score = median over tokens of (1 − rank / buyers); null without ranks (design §4.3). */
 export function earlyEntryScore(inputs) {
     const xs = inputs.filter((e) => e.buyers > 0 && e.rank >= 0 && e.rank < e.buyers).map((e) => 1 - e.rank / e.buyers).sort((a, b) => a - b);
@@ -96,6 +123,11 @@ export function walletStats(wallet, trades, opts = {}) {
     const ts = trades.map((t) => t.t).filter((t) => t > 0);
     const winRate = closed.length >= WIN_RATE_MIN_N ? wins / closed.length : null;
     const txs = opts.txs ?? new Set(trades.map((t) => t.sig)).size;
+    const holds = closed.map((p) => p.holdMs).filter((m) => m !== null);
+    const holdMedianMs = median(holds) ?? null;
+    const holdNote = holdMedianMs === null
+        ? (closed.length ? `no closed position with both block times known (${closed.length} closed)` : 'no closed positions yet')
+        : `median first-buy→last-sell over ${holds.length} closed position${holds.length === 1 ? '' : 's'} with known times`;
     return {
         wallet,
         trades: trades.length,
@@ -112,9 +144,11 @@ export function walletStats(wallet, trades, opts = {}) {
         winRateNote: closed.length >= WIN_RATE_MIN_N ? `${wins}/${closed.length} closed` : `hidden under n=${WIN_RATE_MIN_N} (${wins}/${closed.length} closed so far)`,
         open: positions.length - closed.length,
         earlyEntry: earlyEntryScore(opts.earlyEntry ?? []),
+        holdMedianMs,
+        holdNote,
         positions,
         firstT: ts.length ? Math.min(...ts) : null,
         lastT: ts.length ? Math.max(...ts) : null,
-        sample: { txs, complete: !!opts.complete, note: opts.complete ? `all ${txs} txs` : `last ${txs} txs only · older history not fetched` },
+        sample: { txs, complete: !!opts.complete, note: opts.complete ? `all ${txs} txs` : `last ${txs} txs only · older history not fetched`, source: 'helius-history', asOf: opts.asOf ?? null },
     };
 }

package/dist/packages/data/src/trade/copy/tracker.js

@@ -63,7 +63,7 @@ export class WalletTracker {
     alerts(limit = 50) { return this.alertLog.slice(-limit).reverse(); }
     stats(addr) {
         const w = this.wallets.get(addr);
-        return walletStats(addr, w?.trades ?? [], { solUsd: this.solUsd(), txs: w?.txs ?? 0, complete: w?.complete ?? false, earlyEntry: this.earlyEntry(addr) });
+        return walletStats(addr, w?.trades ?? [], { solUsd: this.solUsd(), txs: w?.txs ?? 0, complete: w?.complete ?? false, earlyEntry: this.earlyEntry(addr), asOf: w?.asOf ?? null });
     }
     /** Per-wallet poll error (shown on the row), null when the last poll was clean. */
     walletError(addr) { return this.wallets.get(addr)?.error ?? null; }
@@ -89,11 +89,12 @@ export class WalletTracker {
         for (const f of this.follows.list()) {
             let w = this.wallets.get(f.addr);
             if (!w) {
-                w = { primed: false, seen: new Set(), trades: [], txs: 0, complete: false, lastSlot: 0, error: null };
+                w = { primed: false, seen: new Set(), trades: [], txs: 0, complete: false, lastSlot: 0, error: null, asOf: null };
                 this.wallets.set(f.addr, w);
             }
             try {
                 const page = await this.history.transactions(f.addr, { limit: w.primed ? this.pageLimit : this.backfillLimit, sortOrder: 'desc' });
+                w.asOf = page.fetchedAt;
                 const fresh = page.data.filter((tx) => { const s = tx.transaction?.signatures?.[0]; return !!s && !w.seen.has(s); });
                 for (const tx of fresh)
                     w.seen.add(tx.transaction.signatures[0]);

package/dist/packages/mcp/assets/kb/app-help/app-help-command.md

@@ -0,0 +1,35 @@
+---
+id: app-help-command
+title: Get help on how dexterm works (dexterm help)
+kind: app-help
+screen: all
+feature: app-help
+tags:
+  - app-help
+  - help
+  - how
+  - topic
+  - topics
+  - guide
+  - manual
+  - docs
+  - commands
+commands:
+  - help
+flags:
+  - --help
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+`dexterm help [topic]` answers "how do I ..." from the generated app-help knowledge base — the same entries the analyst's `app_help` tool uses, so they cannot drift from the app. `dexterm help` lists the topics; `dexterm help <topic|key|command>` prints the matching entry with the exact key or command. `--help` (or `-h`) on any command prints its usage. The analyst searches app-help first and never invents a key.
+
+CLI: `dexterm help`.

package/dist/packages/mcp/assets/kb/app-help/ask-the-analyst.md

@@ -0,0 +1,43 @@
+---
+id: ask-the-analyst
+title: Ask the analyst a question
+kind: app-help
+screen: analyst
+feature: analyst
+tags:
+  - app-help
+  - analyst
+  - ask
+  - claude
+  - ai
+  - question
+  - dossier
+  - chat
+keys:
+  - a
+  - enter
+actions:
+  - analyst.toggle
+  - open
+flags:
+  - --no-ai
+tools:
+  - get_dossier
+  - kb_search
+  - app_help
+  - case_lookup
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+The analyst is your own `claude` login. ⏎ on a coin runs a full dossier; `a` runs a rug-check (or a trench-scan of the screener when nothing is selected). Type a follow-up and ⏎ to send. If `claude` is missing or logged out the panel shows the one-line fix and the rest of dexterm keeps working. Start without AI using `--no-ai`.
+
+Keys: `a`, `⏎` (screener).

package/dist/packages/mcp/assets/kb/app-help/backtest.md

@@ -0,0 +1,33 @@
+---
+id: backtest
+title: Backtest the rug model or skills
+kind: app-help
+screen: all
+feature: skill-backtest
+tags:
+  - app-help
+  - backtest
+  - eval
+  - accuracy
+  - model
+  - metrics
+  - history
+commands:
+  - backtest
+tools:
+  - rug_backtest
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+`dexterm backtest --subject heuristic|skills|larp|pack_verdicts` scores a subject against the recorder's outcome-labelled history and prints honest metrics (precision/recall, Brier vs base rate, AUC, calibration) with leakage checks. With no labelled outcomes it says so and prints no metrics rather than fabricating any.
+
+CLI: `dexterm backtest`.

package/dist/packages/mcp/assets/kb/app-help/bubble-map.md

@@ -0,0 +1,35 @@
+---
+id: bubble-map
+title: Open the bubble map
+kind: app-help
+screen: token
+feature: bubble-map
+tags:
+  - app-help
+  - bubble
+  - bubbles
+  - map
+  - cluster
+  - clusters
+  - holders
+  - wallets
+  - cabal
+keys:
+  - M
+actions:
+  - intel.bubbles
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+Press `M` on a token to open the BUBBLE MAP: top holders as discs (area = share of supply, colour = the rule that labelled the wallet), linked-cluster rings, a CLUSTERS table and a WHY THIS LABEL panel. Keyless it uses the public holder list with static labels; a free Helius key adds funders and the launch window.
+
+Keys: `M` (token).

package/dist/packages/mcp/assets/kb/app-help/calm-mode.md

@@ -0,0 +1,31 @@
+---
+id: calm-mode
+title: Turn on calm mode (effects off)
+kind: app-help
+screen: all
+feature: look
+tags:
+  - app-help
+  - calm
+  - effects
+  - rain
+  - glitch
+  - quiet
+  - still
+  - intensity
+flags:
+  - --calm
+  - --intensity
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+Press `c` to toggle calm mode: rain, glitch, blink and scanlines off, back to the last intensity when pressed again. Start calm with `--calm` (or `DEXTERM_CALM=1`); `--intensity normal|fever|off` picks a tier. The analyst can toggle calm for you.

package/dist/packages/mcp/assets/kb/app-help/change-voice-speed.md

@@ -0,0 +1,31 @@
+---
+id: change-voice-speed
+title: Change the voice speed (rate)
+kind: app-help
+screen: all
+feature: jarvis
+tags:
+  - app-help
+  - voice
+  - speed
+  - rate
+  - faster
+  - slower
+  - wpm
+commands:
+  - voice
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+Voice speed is `voice.rate` in `~/.dexterm/config.json` (words per minute, 80–400). Edit it there and restart. Voice settings are yours alone: the analyst/agent CANNOT change them (the voice path is denied to models) — only you set them. `dexterm voice status` shows the current voice engines.
+
+CLI: `dexterm voice`.

package/dist/packages/mcp/assets/kb/app-help/change-voice.md

@@ -0,0 +1,30 @@
+---
+id: change-voice
+title: Change which voice speaks
+kind: app-help
+screen: all
+feature: jarvis
+tags:
+  - app-help
+  - voice
+  - choose
+  - speak
+  - say
+  - name
+commands:
+  - voice
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+The default speaking voice is the neural Piper voice once it is set up (`dexterm voice setup`), with the built-in macOS `say` as the fallback. Press `,` to cycle the `say` voice while running, or set `voice.name` in `~/.dexterm/config.json` (that chooses the `say` fallback voice; Piper has one fixed voice). Nothing is sent to a paid API. Voice is user-only: the analyst/agent cannot change it (the voice path is denied to models) — only the keyboard or your config sets it.
+
+CLI: `dexterm voice`.

package/dist/packages/mcp/assets/kb/app-help/chart-popup-selftest.md

@@ -0,0 +1,32 @@
+---
+id: chart-popup-selftest
+title: Run the popup self-test (dexterm popup --self-test)
+kind: app-help
+screen: all
+feature: popup-selftest
+tags:
+  - app-help
+  - self-test
+  - selftest
+  - test
+  - shell
+  - fps
+  - diagnose
+  - hotkey
+commands:
+  - popup
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+`dexterm popup --self-test [--browser] [--seconds N] [--theme NAME]` opens a chart popup on fixture data and reports the shell, hotkey and fps it can measure headlessly, labelling what still needs a human at an unlocked Mac. In-app, open the popup for real with `C` on the token screen (see "Open the chart popup").
+
+CLI: `dexterm popup`.

package/dist/packages/mcp/assets/kb/app-help/coin-images.md

@@ -0,0 +1,29 @@
+---
+id: coin-images
+title: Turn coin images on or off
+kind: app-help
+screen: all
+feature: coin-images
+tags:
+  - app-help
+  - images
+  - image
+  - pictures
+  - icons
+  - logos
+  - off
+flags:
+  - --no-images
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+Coin pictures render as real pixels in image-capable terminals (kitty/iTerm2/sixel) and as block art everywhere else. Turn them off with `--no-images` (or `DEXTERM_IMAGES=0`, or `enabled:false` in `~/.dexterm/images.json`). `dexterm doctor` has a Coin images line that says which path you get.

package/dist/packages/mcp/assets/kb/app-help/configure-rpc-key.md

@@ -0,0 +1,28 @@
+---
+id: configure-rpc-key
+title: Configure a Helius / RPC key for holders
+kind: app-help
+screen: all
+feature: keyless
+tags:
+  - app-help
+  - helius
+  - rpc
+  - key
+  - holders
+  - free
+  - api
+  - ranked
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+dexterm is free-forever and keyless by default. The one real keyless gap is the ranked top-holder list: add a free RPC key for it. Save a Helius key ONLY at `~/.dexterm/helius.key` (mode 600, never a repo or command line), or set `DEXTERM_RPC_URL` to any read-only RPC. `dexterm doctor` prints the exact command. Without a key the holders panel shows count + top-10% via Jupiter.

package/dist/packages/mcp/assets/kb/app-help/connect-an-agent-registry.md

@@ -0,0 +1,35 @@
+---
+id: connect-an-agent-registry
+title: Manage connected agents (dexterm agent)
+kind: app-help
+screen: all
+feature: mcp
+tags:
+  - app-help
+  - agent
+  - agents
+  - registry
+  - tier
+  - pause
+  - resume
+  - kick
+  - audit
+  - bus
+  - serve
+commands:
+  - agent
+confidence: high
+owner: maintainers
+origin: app-help-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/app keymap + overlay + mcp tools + cli (task-1413)
+sources:
+  - packages/tui/src/keymap.ts
+  - packages/cli/src/main.ts
+  - packages/mcp/src/server.ts
+date: 2026-10-16
+---
+
+`dexterm agent add|list|rotate|remove|tier|pause|resume|kick|audit|packs` manages your bring-your-own-agent registry and the loopback bus; `dexterm agent serve` runs a standalone bus on fixtures and `connect` attaches one. Every agent is untrusted and read-only: it can never sign, arm, raise a cap, touch keys or change network settings.
+
+CLI: `dexterm agent`.