dexterm-cli 0.2.0 → 0.2.2

package/dist/packages/cli/src/dash/server.js

@@ -0,0 +1,92 @@
+// `dexterm dash` (task-1749): the loopback server and the static export of the strategy performance dashboard.
+// Binds 127.0.0.1 only. GET/HEAD only. Serves four files from assets/dash plus /api/dash.json (recomputed at most every
+// few seconds). A Host header outside the allow list is refused (DNS-rebinding guard: a web page cannot read the
+// dashboard through a hostname that resolves to 127.0.0.1); a private proxy in front (e.g. `tailscale serve`) is
+// allowed by naming its host with --allow-host. No external request is made or referenced: the page has no CDN, font
+// or analytics URL, and the CSP forbids any.
+import { createServer } from 'node:http';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { collectDash } from "./data.js";
+const HERE = dirname(fileURLToPath(import.meta.url));
+export const ASSET_DIR = resolve(HERE, '..', '..', 'assets', 'dash');
+export const ASSETS = { '/': 'index.html', '/index.html': 'index.html', '/dash.css': 'dash.css', '/dash.js': 'dash.js', '/icon.svg': 'icon.svg' };
+const TYPES = { html: 'text/html; charset=utf-8', css: 'text/css; charset=utf-8', js: 'text/javascript; charset=utf-8', svg: 'image/svg+xml', json: 'application/json; charset=utf-8' };
+export const CSP = "default-src 'none'; script-src 'self'; style-src 'self'; img-src 'self' data:; connect-src 'self'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'";
+/** Is this Host header one we serve? Loopback names on any port, plus the hosts allowed explicitly (with or without a port). */
+export function hostAllowed(host, allow) {
+    if (!host)
+        return false;
+    const h = host.toLowerCase();
+    const name = h.startsWith('[') ? h.slice(0, h.indexOf(']') + 1) : h.replace(/:\d+$/, '');
+    if (name === '127.0.0.1' || name === 'localhost' || name === '[::1]')
+        return true;
+    return allow.some((a) => { const x = a.toLowerCase(); return x === h || x === name; });
+}
+export function startDashServer(opts, port) {
+    let cache = null;
+    const data = () => {
+        const now = Date.now();
+        if (!cache || now - cache.at > (opts.cacheMs ?? 5000))
+            cache = { at: now, body: JSON.stringify(collectDash({ homes: opts.homes, books: opts.books, baseline: opts.baseline, now })) };
+        return cache.body;
+    };
+    const server = createServer((req, res) => {
+        const base = { 'Content-Security-Policy': CSP, 'X-Content-Type-Options': 'nosniff', 'Referrer-Policy': 'no-referrer', 'Cache-Control': 'no-store' };
+        if (!hostAllowed(req.headers.host, opts.allowHosts)) {
+            res.writeHead(421, { ...base, 'Content-Type': 'text/plain' });
+            res.end('misdirected request: this host name is not allowed (dexterm dash --allow-host NAME)\n');
+            return;
+        }
+        if (req.method !== 'GET' && req.method !== 'HEAD') {
+            res.writeHead(405, { ...base, Allow: 'GET, HEAD' });
+            res.end();
+            return;
+        }
+        const path = (req.url ?? '/').split('?')[0];
+        try {
+            if (path === '/api/dash.json') {
+                const body = data();
+                res.writeHead(200, { ...base, 'Content-Type': TYPES.json });
+                res.end(req.method === 'HEAD' ? undefined : body);
+                return;
+            }
+            const file = ASSETS[path];
+            if (!file) {
+                res.writeHead(404, { ...base, 'Content-Type': 'text/plain' });
+                res.end('not found\n');
+                return;
+            }
+            const body = readFileSync(join(ASSET_DIR, file));
+            res.writeHead(200, { ...base, 'Content-Type': TYPES[file.split('.').pop()] ?? 'application/octet-stream' });
+            res.end(req.method === 'HEAD' ? undefined : body);
+        }
+        catch (e) {
+            res.writeHead(500, { ...base, 'Content-Type': 'text/plain' });
+            res.end(`dashboard error: ${String(e?.message ?? e).slice(0, 200)}\n`);
+        }
+    });
+    return new Promise((ok, fail) => { server.once('error', fail); server.listen(port, '127.0.0.1', () => { server.off('error', fail); ok(server); }); });
+}
+/**
+ * A static, read-only SNAPSHOT: the same page + the data as data.json (the page reads it instead of /api/dash.json and
+ * shows "snapshot" with its time, no auto-refresh). `redactMints` drops the mints (coin symbols stay).
+ */
+export function exportSnapshot(d, outDir, { redactMints = false } = {}) {
+    mkdirSync(outDir, { recursive: true });
+    const data = redactMints ? JSON.parse(JSON.stringify(d, (k, v) => (k === 'mint' ? null : v))) : d;
+    const written = [];
+    for (const f of new Set(Object.values(ASSETS))) {
+        let body = readFileSync(join(ASSET_DIR, f), 'utf8');
+        if (f === 'index.html')
+            body = body.replace('content="api/dash.json"', 'content="data.json"').replace('data-mode="live"', 'data-mode="snapshot"');
+        writeFileSync(join(outDir, f), body);
+        written.push(f);
+    }
+    writeFileSync(join(outDir, 'data.json'), JSON.stringify({ ...data, snapshot: true }));
+    written.push('data.json');
+    writeFileSync(join(outDir, '_headers'), `/*\n  Content-Security-Policy: ${CSP}\n  X-Content-Type-Options: nosniff\n  Referrer-Policy: no-referrer\n`);
+    written.push('_headers');
+    return written;
+}

package/dist/packages/cli/src/dash-cmd.js

@@ -0,0 +1,113 @@
+// `dexterm dash` (task-1749): the STRATEGY PERFORMANCE DASHBOARD. Local-first: it reads your own autotrade run ledgers
+// ($DEXTERM_HOME/autotrade/runs) and serves a page on 127.0.0.1 only; no account, no cloud, nothing leaves the machine.
+// Read-only: it never writes into the engine's state. PAPER results are simulated; not financial advice.
+import { existsSync } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
+import { dextermHome } from '../../custom/src/index.js';
+import { defaultDbPath } from '../../data/src/index.js';
+import { collectDash, homeLabel } from "./dash/data.js";
+import { exportSnapshot, startDashServer } from "./dash/server.js";
+export const DASH_PORT = 4317;
+export const DASH_HELP = `dexterm dash: track how your autotrade strategies perform, in a browser, on this machine only. Read-only.
+
+  dexterm dash                          serve the dashboard on http://127.0.0.1:${DASH_PORT}/ (Ctrl-C stops it)
+  dexterm dash --json                   print the numbers the page shows and exit
+  dexterm dash --export DIR [--redact-mints]   write a static read-only snapshot (the page + data.json) and exit
+
+  --port N            the loopback port (default ${DASH_PORT}; 0 = any free port)
+  --home DIR          a dexterm home to read (default $DEXTERM_HOME or ~/.dexterm); repeat for several
+  --db PATH           the market cache DB for pool reads (default: dexterm.db next to a .dexterm home, else DEXTERM_DB_PATH or the default DB)
+  --books FILE        add books from a dexterm-dash-books/1 JSON file (your own script's output); repeat for several
+  --baseline ID       the strategy every other one is compared against
+  --allow-host NAME   also answer requests for this host name (a private proxy in front, e.g. tailscale serve)
+
+  Overview, strategy detail, rugs & stuck, compare (vs the baseline, with the 95% interval) and live status, refreshed
+  every 30 s. The server binds 127.0.0.1 only, makes no network request and loads nothing from the internet.
+  PAPER results are simulated. Not financial advice.`;
+const VALUE = new Set(['port', 'home', 'db', 'books', 'baseline', 'allow-host', 'export']);
+const BOOL = new Set(['json', 'help', 'redact-mints']);
+function parse(argv) {
+    const o = { _: [], flags: new Map(), bools: new Set() };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '-h') {
+            o.bools.add('help');
+            continue;
+        }
+        if (!a.startsWith('--')) {
+            o._.push(a);
+            continue;
+        }
+        const [k, inline] = a.slice(2).split(/=(.*)/s, 2);
+        if (BOOL.has(k)) {
+            o.bools.add(k);
+            continue;
+        }
+        if (!VALUE.has(k))
+            return `unknown flag --${k}`;
+        const v = inline ?? argv[++i];
+        if (v === undefined || v === '')
+            return `--${k} needs a value`;
+        o.flags.set(k, [...(o.flags.get(k) ?? []), v]);
+    }
+    return o;
+}
+/** A home given as DIR: the .dexterm folder itself, or a folder holding one (the kit's layout: <dir>/.dexterm + <dir>/dexterm.db). */
+export function resolveHome(dir, env, db) {
+    let d = resolve(dir);
+    if (basename(d) !== '.dexterm' && !existsSync(join(d, 'autotrade')) && existsSync(join(d, '.dexterm')))
+        d = join(d, '.dexterm');
+    const sibling = basename(d) === '.dexterm' ? join(dirname(d), 'dexterm.db') : null;
+    return { dir: d, label: homeLabel(d), db: db ?? (sibling && existsSync(sibling) ? sibling : env.DEXTERM_DB_PATH || defaultDbPath(env)) };
+}
+export async function dashCommand(argv, io, { wait = true } = {}) {
+    const o = parse(argv);
+    if (typeof o === 'string') {
+        io.stderr.write(`dexterm dash: ${o}\n\n${DASH_HELP}\n`);
+        return 2;
+    }
+    if (o.bools.has('help') || o._[0] === 'help') {
+        io.stdout.write(`${DASH_HELP}\n`);
+        return 0;
+    }
+    if (o._.length) {
+        io.stderr.write(`dexterm dash: unexpected argument ${o._[0]}\n\n${DASH_HELP}\n`);
+        return 2;
+    }
+    const db = o.flags.get('db')?.[0];
+    const homes = (o.flags.get('home') ?? [dextermHome(io.env)]).map((h) => resolveHome(h, io.env, db));
+    const books = (o.flags.get('books') ?? []).map((b) => resolve(b));
+    const baseline = o.flags.get('baseline')?.[0] ?? null;
+    if (o.bools.has('json')) {
+        io.stdout.write(`${JSON.stringify(collectDash({ homes, books, baseline }), null, 1)}\n`);
+        return 0;
+    }
+    const out = o.flags.get('export')?.[0];
+    if (out) {
+        const files = exportSnapshot(collectDash({ homes, books, baseline }), resolve(out), { redactMints: o.bools.has('redact-mints') });
+        io.stdout.write(`snapshot written to ${resolve(out)}: ${files.join(', ')}\nIt is a static read-only copy of what this machine shows now. Publishing it is your decision; check it first. Not financial advice.\n`);
+        return 0;
+    }
+    const port = Number(o.flags.get('port')?.[0] ?? DASH_PORT);
+    if (!Number.isInteger(port) || port < 0 || port > 65535) {
+        io.stderr.write(`dexterm dash: --port must be 0-65535\n`);
+        return 2;
+    }
+    let server;
+    try {
+        server = await startDashServer({ homes, books, baseline, allowHosts: o.flags.get('allow-host') ?? [] }, port);
+    }
+    catch (e) {
+        io.stderr.write(`dexterm dash: cannot listen on 127.0.0.1:${port} (${e.code ?? e}); try --port N\n`);
+        return 1;
+    }
+    const addr = server.address();
+    const p = typeof addr === 'object' && addr ? addr.port : port;
+    io.stdout.write(`dexterm dash: http://127.0.0.1:${p}/  (reading ${homes.map((h) => h.label).join(', ')}${books.length ? ` + ${books.length} books file(s)` : ''}; loopback only, read-only; Ctrl-C stops)\nPaper trading, not financial advice.\n`);
+    if (!wait) {
+        server.close();
+        return 0;
+    }
+    await new Promise((done) => { const stop = () => { server.close(() => done()); }; process.once('SIGINT', stop); process.once('SIGTERM', stop); });
+    return 0;
+}

package/dist/packages/cli/src/doctor.js

@@ -204,6 +204,7 @@ export function defaultDeps(env = process.env, isTTY = process.stdout.isTTY ===
         claude: () => claudeProbe(),
         codex: () => codexProbe(4000, env),
         ollama: () => ollamaFacts(env),
+        classifier: () => classifierFacts(env),
         analystEngine: env.DEXTERM_ANALYST_ENGINE ?? loadConfig(dextermHome(env)).config.analyst?.engine ?? null,
         probe: (url) => livingProbe(url),
         checkWritable: writableProbe,
@@ -325,6 +326,12 @@ export async function runDoctor(deps) {
     // 3c. Local engine (task-1543): the user's own Ollama on this machine, the model, tool calling, context, profile.
     if (ol)
         checks.push(ollamaCheck(ol, claude !== 'missing' || codexUsable));
+    // 3d. Classification model (task-1822, EXPERIMENTAL): hardware tier + the picked model. Never fails the doctor.
+    if (deps.classifier) {
+        const cf = await deps.classifier().catch(() => null);
+        if (cf)
+            checks.push(classifierCheck(cf));
+    }
     // 4b. Login with X (optional, task-1357): the user's own X app + login unlock X posts in the SOCIAL panel / TRENDING.
     {
         const xs = new XTokenStore({ env: deps.env });
@@ -471,6 +478,33 @@ export function renderDoctor(result, opts = {}) {
         lines.push(paint(`${fails} check${fails === 1 ? '' : 's'} failed — fix the ✗ lines above, then re-run \`dexterm doctor\`.`, color ? ANSI.fail : ''));
     return lines.join('\n');
 }
+/** task-1822: what `dexterm classifier doctor` says, as one doctor line. */
+export async function classifierFacts(env = process.env) {
+    const { describeHardware, detectHardware, loadClassifierConfig, providerFromConfig, recommendTier } = await import('../../classifier/src/index.js');
+    const hw = await detectHardware();
+    const rec = recommendTier(hw);
+    const c = loadClassifierConfig(env).config;
+    let st = { ready: false, detail: '' };
+    let model = c.provider;
+    try {
+        const p = providerFromConfig(c, c.provider, { env });
+        model = p.model();
+        st = await p.status();
+    }
+    catch (e) {
+        st = { ready: false, detail: e.message };
+    }
+    return { hardware: describeHardware(hw), recommended: rec.model, bestQuality: rec.bestQuality, why: rec.why, provider: c.provider, model, ready: st.ready, detail: st.detail };
+}
+export function classifierCheck(f) {
+    const tier = f.recommended ? `recommended model here: ${f.recommended}${f.bestQuality ? ` (best quality: ${f.bestQuality})` : ''}` : 'recommended: the built-in scores';
+    const name = 'Classification model (experimental)';
+    if (f.provider === 'heuristic')
+        return { name, status: 'pass', detail: `built-in scores (no download) · ${f.hardware} · ${tier}` };
+    if (f.ready)
+        return { name, status: 'pass', detail: `${f.provider} ${f.model} ready · ${tier}` };
+    return { name, status: 'warn', detail: `${f.provider} ${f.model} not ready: ${f.detail}`, fix: f.provider === 'kev-local' ? `dexterm classifier pull ${f.model}, then dexterm classifier serve (answers fall back to the built-in scores meanwhile)` : 'dexterm classifier doctor' };
+}
 /**
  * The Ollama line (task-1543). Optional while claude/codex can run the analyst; a warning with the 2-minute
  * setup when nothing can, or when the user chose ollama and it is not ready.

package/dist/packages/cli/src/live/screens/token-live.js

@@ -19,6 +19,7 @@ import { launchIntelCells, holderTags } from "../intel.js";
 import { devBookOf, devRows } from "../dev-history.js";
 import { EX_POOL_TAGS } from '../../../../data/src/index.js';
 import { layoutFor } from "../../custom.js";
+import { narrativeCell } from "../../narratives.js";
 import { chartMode, chartTitle, priceModeOf, chartAxisOf, chartMarkersOn, mcapAt, positionPriceCells, levelCell, supplyRatio } from "../../display.js";
 const dash = '—';
 const EX_POOL_TAG_SET = EX_POOL_TAGS;
@@ -211,6 +212,9 @@ export function renderTokenLive(c, state, v) {
             ['RugCheck score', ...(v.rug === null || v.rug.score === null ? na(v.panels.rugcheck.state === 'error' ? `unavailable: ${v.panels.rugcheck.reason ?? ''}`.trim() : dash) : [`${Math.round(v.rug.score)}/100`, v.rug.score < 30 ? 'ok' : v.rug.score < 60 ? 'warn' : 'bad'])],
             ['GoPlus', ...goplusRow(v)],
             ...devTail,
+            // task-1818 (EXPERIMENTAL): the coin's narrative from the already-built tracker (measured heat, not advice). Never builds
+            // one here (the 26 h replay runs only from N → n); warn = copy-cat saturated or fading/dead, else neutral na (never a green ok).
+            ['Narrative', ...narrativeCell(state, v.mint)],
         ];
         for (const [label, val0, lvl] of fitRows(rows, sb.y + sb.h - sy)) {
             if (sy >= sb.y + sb.h)

package/dist/packages/cli/src/live/signals.js

@@ -69,6 +69,8 @@ export class LiveSignalsLive {
     logByMint = new Map();
     /** Signals emitted this session (all mints), newest last — a cheap counter/feed for the smoke script + tests. */
     emitted = [];
+    /** task-1427: extra read-only listeners (the MCP follow session forwards each signal to the spectator hub). */
+    listeners = new Set();
     constructor(opts = {}) {
         this.engine = new LiveSignalsEngine({ thresholds: opts.thresholds });
         this.now = opts.now ?? (() => Date.now());
@@ -86,6 +88,12 @@ export class LiveSignalsLive {
             this.logByMint.set(s.mint, arr);
             this.emitted.push(s);
             this.onSignal?.(s);
+            for (const l of this.listeners) {
+                try {
+                    l(s);
+                }
+                catch { /* a listener never breaks the engine */ }
+            }
         }
         return sigs;
     }

package/dist/packages/cli/src/main.js

@@ -47,6 +47,7 @@ import { recordLarpVerdict } from "./larp-record.js";
 import { newAutotradeUi, defaultDeps as autotradeDeps, autotradeCapturing, autotradeTick, reloadList as autotradeReload, refreshRunner as autotradeRefreshRunner } from "./screens/autotrade-ui.js";
 import { autotradeAction, autotradeKey } from "./screens/autotrade-keys.js";
 import { workerJobs as autotradeWorkerJobs } from "./screens/autotrade-worker.js";
+import { narrativesUiOf, kickNarratives, heatRows, drillDetail } from "./narratives.js";
 import { rulesUiOf, rulesTick, rulesMove, beginRuleInput, saveRuleInput, dryRunNow, removeSelectedRule, toggleSelectedRule, dismissSelectedProposal, actOnSelectedProposal, RULE_INPUT_MAX } from "./rules.js";
 import { buildNotifier, hasPushChannel } from "./alerts/notifier.js";
 import { copyAlertToDelivery } from "./alerts/format.js";
@@ -306,12 +307,16 @@ export const HELP = `dexterm ${VERSION} (live: screener, token, new pairs, watch
   dexterm kb list|show|new|edit|check|reset|path     your knowledge-base entries (~/.dexterm/kb/entries) over the bundled 18
   dexterm skill list|show|new|edit|check|reset|path  your analyst skills (~/.dexterm/skills) over the bundled ones (read tools only)
   dexterm narrative [--window 1h|24h] [--summary]  the narrative board over recorded history (no network, no model)
+  dexterm narratives [top|detail ID|of MINT|export]  EXPERIMENTAL memes + narratives tracker over recorded history: themes, heat, lifecycle (measured heat, not advice)
   dexterm backtest [--subject heuristic|pack_verdicts] [--horizon SEC]  honest rug-model metrics over recorded outcomes (no network, no model)
   dexterm ledger trades|positions|summary|equity|compare|export|card|sync|verify  the unified trade ledger: paper, agent desk, autotrade runs (no network; 'dexterm ledger help')
+  dexterm dash [--port N] [--home DIR] [--baseline ID] [--export DIR]  your strategies' performance in a browser on 127.0.0.1 (read-only, no network; 'dexterm dash --help')
   dexterm wallet link|unlink|status|panic|resume  link a Phantom wallet via a local bridge (pubkey only); panic halts autotrade + the paper desk, resume needs a TTY keypress
   dexterm plan propose|list|arm|cancel|journal     conditional order plans (entry/ladder/take-profit/moon bag/stop); arming needs a physical keypress
   dexterm mandate draft|list|arm|revoke            standing capped mandates (paper fills); arming needs a physical keypress — voice/agents can never arm
   dexterm follow add|remove|list|stats|trades|mirror|purge  copy trading tier 1: follow a wallet (your list, local labels), its decoded swaps + FIFO PnL + win rate/early-entry; 'mirror' previews a one-key MIRROR TICKET from the wallet's latest buy (inert; arm in the app)
+  dexterm classifier [list|pick|pull|serve|doctor|bench|try|key]  classification models (EXPERIMENTAL): Kev on your own machine
+                                              (llama.cpp), hosted Jev with your own key, or the built-in heuristic; model estimates, never advice
   dexterm ai [status|engine|model|host|restrictions|probe|ask|agent]  the AI engine: your claude / codex CLI or a free LOCAL model on
                                               your own Ollama (localhost); restriction profiles observe|propose|paper|full ('dexterm ai help')
   dexterm mcp [install <client>|doctor]            read-only MCP server for your own agent; 'install' writes the config for claude-code|claude-desktop|cursor|codex|generic (asks first, idempotent, backs up); 'doctor' verifies the connection
@@ -849,6 +854,12 @@ export async function main(argv, io = process, proc = process) {
         const { runSpectate } = await import("./spectate-cmd.js");
         return runSpectate(argv.slice(1), io);
     }
+    // `dexterm overlay` → the streamer overlay (task-1427): OBS browser-source scenes (agent activity, the coin card,
+    // the PAPER / LIVE PnL card) fed by the read-only spectator stream or a replay; loopback, single-use ticket → token.
+    if (argv[0] === 'overlay') {
+        const { runOverlay } = await import("./overlay-cmd.js");
+        return runOverlay(argv.slice(1), io);
+    }
     // `dexterm recorder <cmd>` → the history recorder's tables: stats, label, prune, export (task-1329). No network.
     if (argv[0] === 'recorder') {
         const { recorderCli } = await import('../../recorder/src/index.js');
@@ -859,11 +870,21 @@ export async function main(argv, io = process, proc = process) {
         const { narrativeCommand } = await import("./narrative-cmd.js");
         return narrativeCommand(argv.slice(1), { stdout: io.stdout, stderr: io.stderr, env: io.env });
     }
+    // `dexterm narratives [top|detail ID|of MINT|export]` → the MEMES + NARRATIVES tracker (task-1818, EXPERIMENTAL). No network, no model.
+    if (argv[0] === 'narratives') {
+        const { narrativesCommand } = await import("./narratives-cmd.js");
+        return narrativesCommand(argv.slice(1), { stdout: io.stdout, stderr: io.stderr, env: io.env });
+    }
     // `dexterm ledger …` → the unified trade ledger (task-1530): reads fold the file + the sources; only `sync` writes. No network, no model, no keys.
     if (argv[0] === 'ledger') {
         const { ledgerCommand } = await import("./ledger-cmd.js");
         return ledgerCommand(argv.slice(1), { stdout: io.stdout, stderr: io.stderr, env: io.env });
     }
+    // `dexterm dash` → the strategy performance dashboard (task-1749): run ledgers → a page on 127.0.0.1 only. Read-only, no network, no model, no keys.
+    if (argv[0] === 'dash') {
+        const { dashCommand } = await import("./dash-cmd.js");
+        return dashCommand(argv.slice(1), { stdout: io.stdout, stderr: io.stderr, env: io.env });
+    }
     // `dexterm autotrade validate|list|backtest|sweep …` and `dexterm backtest --subject strategy` → the paper autotrade engine (task-1503). No network, no model, no keys.
     if (argv[0] === 'autotrade' || argv[0] === 'backtest') {
         const at = await import("./autotrade-cmd.js");
@@ -1001,6 +1022,11 @@ export async function main(argv, io = process, proc = process) {
         const { aiCommand } = await import("./ai-cmd.js");
         return aiCommand(argv[0] === 'ask' ? ['ask', ...argv.slice(1)] : argv.slice(1), { stdin: io.stdin, stdout: io.stdout, stderr: io.stderr, env: io.env });
     }
+    // task-1822: `dexterm classifier …` (pick / pull / serve the classification model; hardware tiers; hosted key).
+    if (argv[0] === 'classifier') {
+        const { classifierCommand } = await import("./classifier-cmd.js");
+        return classifierCommand(argv.slice(1), { stdin: io.stdin, stdout: io.stdout, stderr: io.stderr, env: io.env });
+    }
     // `dexterm doctor` → a pre-flight that says whether dexterm will run here and how to fix what won't (task-1305).
     if (argv[0] === 'doctor') {
         const { defaultDeps, runDoctor, renderDoctor } = await import("./doctor.js");
@@ -1433,6 +1459,20 @@ function rulesScreenMove(state, delta) {
     rulesMove(state.rulesUi, delta);
     return true;
 }
+// task-1818: j/k on the N screen's EXPERIMENTAL heat table move its cursor, or the member cursor while drilled in. The theme
+// board (the default mode) keeps the shared state.selected cursor.
+function narrativesMove(state, delta) {
+    const ui = state.narrativesUi;
+    if (state.screen !== 'narrative' || ui?.mode !== 'heat')
+        return false;
+    if (ui.drill) {
+        const n = drillDetail(state)?.memberList.length ?? 0;
+        ui.drill.selected = Math.max(0, Math.min(n - 1, ui.drill.selected + delta));
+        return true;
+    }
+    ui.selected = Math.max(0, Math.min(heatRows(state).length - 1, ui.selected + delta));
+    return true;
+}
 function plansMove(state, delta) {
     if (state.screen !== 'plans' || !state.plansUi)
         return false;
@@ -1519,7 +1559,7 @@ export function applyAction(state, action, stack) {
         // updates the context injected next turn); PgUp/PgDn scroll the chat transcript. On the token
         // screen (QA M12) the movement keys scroll the answer. Keys reach here only when input is NOT focused.
         case 'move.down':
-            if (plansMove(state, 1) || followsMove(state, 1) || rulesScreenMove(state, 1))
+            if (narrativesMove(state, 1) || plansMove(state, 1) || followsMove(state, 1) || rulesScreenMove(state, 1))
                 break;
             if (bubbleMove(state, 1))
                 break;
@@ -1528,7 +1568,7 @@ export function applyAction(state, action, stack) {
             state.selected = Math.min(rows().length - 1, (state.selected || 0) + 1);
             break;
         case 'move.up':
-            if (plansMove(state, -1) || followsMove(state, -1) || rulesScreenMove(state, -1))
+            if (narrativesMove(state, -1) || plansMove(state, -1) || followsMove(state, -1) || rulesScreenMove(state, -1))
                 break;
             if (bubbleMove(state, -1))
                 break;
@@ -1537,7 +1577,7 @@ export function applyAction(state, action, stack) {
             state.selected = Math.max(0, (state.selected || 0) - 1);
             break;
         case 'move.pagedown':
-            if (plansMove(state, PAGE_ROWS) || followsMove(state, PAGE_ROWS) || rulesScreenMove(state, PAGE_ROWS))
+            if (narrativesMove(state, PAGE_ROWS) || plansMove(state, PAGE_ROWS) || followsMove(state, PAGE_ROWS) || rulesScreenMove(state, PAGE_ROWS))
                 break;
             if (analystChatScroll(state, PAGE_ROWS))
                 break;
@@ -1546,7 +1586,7 @@ export function applyAction(state, action, stack) {
             state.selected = Math.min(rows().length - 1, (state.selected || 0) + PAGE_ROWS);
             break;
         case 'move.pageup':
-            if (plansMove(state, -PAGE_ROWS) || followsMove(state, -PAGE_ROWS) || rulesScreenMove(state, -PAGE_ROWS))
+            if (narrativesMove(state, -PAGE_ROWS) || plansMove(state, -PAGE_ROWS) || followsMove(state, -PAGE_ROWS) || rulesScreenMove(state, -PAGE_ROWS))
                 break;
             if (analystChatScroll(state, -PAGE_ROWS))
                 break;
@@ -1555,14 +1595,14 @@ export function applyAction(state, action, stack) {
             state.selected = Math.max(0, (state.selected || 0) - PAGE_ROWS);
             break;
         case 'move.top':
-            if (plansMove(state, -1e9) || followsMove(state, -1e9))
+            if (narrativesMove(state, -1e9) || plansMove(state, -1e9) || followsMove(state, -1e9))
                 break;
             if (chatScroll(state, -1e9))
                 break;
             state.selected = 0;
             break;
         case 'move.bottom':
-            if (plansMove(state, 1e9) || followsMove(state, 1e9))
+            if (narrativesMove(state, 1e9) || plansMove(state, 1e9) || followsMove(state, 1e9))
                 break;
             if (chatScroll(state, 1e9))
                 break;
@@ -1715,6 +1755,10 @@ export function applyAction(state, action, stack) {
                 state.copyUi.detail = null;
                 break;
             } // task-1399: esc closes the wallet detail view before leaving the screen
+            if (state.screen === 'narrative' && state.narrativesUi?.drill) {
+                state.narrativesUi.drill = null;
+                break;
+            } // task-1818: esc in a drill-down returns to the heat table
             const prev = stack.pop();
             if (prev)
                 state.screen = prev;
@@ -1982,6 +2026,46 @@ export function applyAction(state, action, stack) {
             stack.push(state.screen);
             state.screen = 'narrative';
             state.narrative = computeNarrativeView(state, state.narrative?.window ?? '1h');
+            if (state.narrativesUi?.mode === 'heat')
+                kickNarratives(state); // task-1818: back on the heat table → refresh if it is older than 60 s
+            break;
+        }
+        // task-1818: n flips the theme board ⇄ the EXPERIMENTAL heat table. The first flip starts the tracker build (the recorder's
+        // last 26 h, ~30 s; never at app start); the table shows "building…" until it lands, later refreshes come from the tick.
+        case 'narrative.view': {
+            if (state.screen !== 'narrative')
+                break;
+            const ui = narrativesUiOf(state);
+            ui.mode = ui.mode === 'heat' ? 'board' : 'heat';
+            ui.drill = null;
+            if (ui.mode === 'heat')
+                kickNarratives(state);
+            break;
+        }
+        // task-1818: ⏎ on the heat table drills into the selected narrative; ⏎ on a member opens that coin's token screen (live
+        // mode; fixtures say so). On the theme board ⏎ keeps its old meaning (the shared `open`).
+        case 'narrative.drill': {
+            if (state.screen !== 'narrative')
+                break;
+            const ui = state.narrativesUi;
+            if (ui?.mode !== 'heat')
+                return applyAction(state, 'open', stack);
+            if (!ui.drill) {
+                const r = heatRows(state)[ui.selected];
+                if (r)
+                    ui.drill = { id: r.id, selected: 0 };
+                break;
+            }
+            const m = drillDetail(state)?.memberList[ui.drill.selected];
+            if (!m)
+                break;
+            if (!live) {
+                state.pendingToast = `token detail needs live mode (${m.symbol} ${m.mint.slice(0, 8)}…)`;
+                break;
+            }
+            live.openToken(seedForMint(state, live, m.mint, m.symbol));
+            stack.push(state.screen);
+            state.screen = 'token';
             break;
         }
         case 'narrative.window': {
@@ -4283,6 +4367,11 @@ export function interactive(state, io, depth, args, proc = process) {
             // execution moment, pause / kill) draws over this terminal while it follows. Calm mode = reduced motion.
             state.agentHud = { story: followSession.story, clock: () => Date.now(), dataLabel: args.replay ? 'REPLAY DATA' : null };
             void followSession.start();
+            // task-1427: the open coin's live holder/rug signals ride the spectator stream too (the streamer overlay's coin card).
+            {
+                const fs = followSession;
+                state.live?.signals.listeners.add((sig) => fs.liveFlag(sig));
+            }
             if (size()[1] < HUD_MIN_H)
                 say('following agents over MCP · ctrl+p pause · ctrl+k stop · any key takes over', 'ai', 6);
             if (agentPaper)
@@ -6169,6 +6258,9 @@ export function interactive(state, io, depth, args, proc = process) {
                         say(state.updateNotice, 'info', 8);
                         state.updateNotice = null;
                     }
+                    // task-1818: refresh the EXPERIMENTAL narratives tracker at most every 60 s while its heat table is on screen.
+                    if (state.screen === 'narrative' && state.narrativesUi?.mode === 'heat' && !state.paused)
+                        kickNarratives(state);
                     // task-1508: the autotrade screen re-reads the paper runner's status file every 2 s while it is open.
                     if (state.screen === 'autotrade' && state.autotradeUi)
                         autotradeTick(state.autotradeUi);

package/dist/packages/cli/src/mcp-follow.js

@@ -116,7 +116,10 @@ export class McpFollowSession {
         };
         this.follow = new FollowController({ controls, activityCap: Math.max(1, opts.activityCap ?? 200) });
         this.story = new AgentStory(this.agentLabel);
-        this.hub.on((ev) => { this.follow.apply(ev); this.story.apply(ev); });
+        // task-1427: a live signal the TERMINAL fired (liveFlag) rides the hub for the stream only; it is not an agent call
+        // or an agent thought, so the follow view and the story never fold it (the story would show a note as a thought).
+        this.hub.on((ev) => { if (ev.phase === 'note' && ev.tool === 'live_signal')
+            return; this.follow.apply(ev); this.story.apply(ev); });
     }
     /** Arm the rendezvous (so a `dexterm mcp` server starts emitting) and begin tailing. Idempotent. */
     async start() {
@@ -304,6 +307,23 @@ export class McpFollowSession {
         }
         catch { /* ignore */ }
     }
+    /**
+     * task-1427: a live holder / rug signal the owner's terminal fired for a coin (the task-1404 engine) → one `note`
+     * event in the hub, so the streamer overlay's coin card can show it with its age. Only while armed (an agent is
+     * being followed); it describes data the terminal already read, and carries nothing anyone can act on.
+     */
+    liveFlag(s) {
+        if (!this.armed)
+            return;
+        const detail = sanitizeDetail({ coin: { mint: s.mint }, liveFlags: [{ kind: s.kind, level: s.level, title: s.title, text: s.text, source: s.source, at: s.at, ageSec: Math.max(0, s.dataAgeMs / 1000), stale: s.stale }] });
+        if (!detail?.liveFlags)
+            return;
+        this.hub.emit({ phase: 'note', agent: this.currentAgent, transport: 'mcp', tool: 'live_signal', summary: `${s.title}: ${s.text}`.slice(0, 140), detail, ok: true, t: s.at });
+        try {
+            this.opts.onEvent?.();
+        }
+        catch { /* ignore */ }
+    }
     /** True when the terminal should mirror the agent: the agent still has control and is active. */
     canFollow() {
         if (this.follow.controlState !== 'agent')