dexterm-cli 0.1.1 → 0.1.3

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

@@ -0,0 +1,190 @@
+// dexterm — `dexterm watch` (task-1398): run the rules engine against the live feed with NO TUI and PUSH
+// every fired alert (and, when alerts.proposals is on, a one-line proposal summary) through the delivery
+// layer — so a price / holder / LARP / new-pair alert reaches you when the terminal is closed.
+//
+//   dexterm watch [--interval S] [--ticks N | --once] [--replay FILE] [--db PATH] [--verbose]
+//
+// SAFETY: this builds NO signer and passes no `trade` option; a rule can only alert / annotate / open an
+// inert PROPOSAL (RulesEngine's money-safety invariant). The notifier only reads an AlertDelivery. There is
+// no arm/sign/confirm/cap path anywhere under here (asserted by alerts-1398.test.ts).
+import { dextermHome, loadConfig, RulesEngine } from '../../custom/src/index.js';
+import { openHistoryReadOnly, LARP_PACK } from '../../recorder/src/index.js';
+import { buildNotifier } from "./alerts/notifier.js";
+import { alertToDelivery, proposalToDelivery } from "./alerts/format.js";
+import { redactCreds } from "./alerts/creds.js";
+import { larpGrade } from "./rules.js";
+export const WATCH_USAGE = `usage: dexterm watch [--interval S] [--ticks N | --once] [--replay FILE] [--db PATH] [--verbose]
+
+  Runs your rules headless and pushes alerts to the channels you enabled with \`dexterm alerts\`
+  (terminal line + desktop notification + your Telegram bot / Discord webhook). Ctrl-C to stop.
+`;
+function parseArgs(argv) {
+    const a = { intervalMs: 15_000, ticks: Infinity, replay: null, db: null, verbose: false, help: false };
+    for (let i = 0; i < argv.length; i++) {
+        const t = argv[i];
+        if (t === '--help' || t === '-h')
+            a.help = true;
+        else if (t === '--verbose' || t === '-v')
+            a.verbose = true;
+        else if (t === '--once')
+            a.ticks = 1;
+        else if (t === '--interval') {
+            const n = Number(argv[++i]);
+            if (!Number.isFinite(n) || n < 1)
+                return { error: '--interval needs seconds ≥ 1' };
+            a.intervalMs = Math.round(n * 1000);
+        }
+        else if (t === '--ticks') {
+            const n = Number(argv[++i]);
+            if (!Number.isInteger(n) || n < 1)
+                return { error: '--ticks needs an integer ≥ 1' };
+            a.ticks = n;
+        }
+        else if (t === '--replay') {
+            a.replay = argv[++i] ?? null;
+            if (!a.replay)
+                return { error: '--replay needs a FILE' };
+        }
+        else if (t === '--db') {
+            a.db = argv[++i] ?? null;
+            if (!a.db)
+                return { error: '--db needs a PATH' };
+        }
+        else
+            return { error: `unknown option "${t}"` };
+    }
+    return a;
+}
+/** Latest LARP verdict per mint from a read-only recorder DB (best effort; empty map on any problem). */
+function larpMapFromDb(path) {
+    const map = new Map();
+    if (!path || path === ':memory:')
+        return map;
+    const db = openHistoryReadOnly(path);
+    if (!db)
+        return map;
+    try {
+        const rows = db.prepare('SELECT mint, verdict FROM verdicts WHERE pack = ? AND verdict IS NOT NULL ORDER BY t').all(LARP_PACK);
+        for (const r of rows)
+            map.set(r.mint, r.verdict); // ORDER BY t → last write per mint wins
+    }
+    catch { /* table may not exist yet */ }
+    finally {
+        try {
+            db.close();
+        }
+        catch { /* ignore */ }
+    }
+    return map;
+}
+/** Map a screener row to a rule row (cluster is only known with the wallet-intel scan, absent headless; larp from the DB). */
+export function toRuleRow(r, larp) {
+    return Object.assign(Object.create(null), r, { cluster: null, larp: larpGrade(larp.get(r.mint)) });
+}
+/** The production source: refresh the live (or replay) feed, map rows, yield a snapshot. Replay yields once. */
+function createFeedSource(opts) {
+    let feed = null;
+    let yielded = 0;
+    const larp = larpMapFromDb(opts.db);
+    return {
+        async next() {
+            if (opts.stop.aborted)
+                return null;
+            const { createLiveFeed, createReplayFeed } = await import("./feed.js");
+            if (!feed)
+                feed = opts.replay ? createReplayFeed(opts.replay, {}) : createLiveFeed({ dbPath: opts.db ?? undefined });
+            else {
+                if (opts.replay)
+                    return null; // a recording is a single snapshot: one evaluate, then stop
+                await opts.stop.wait(opts.intervalMs);
+                if (opts.stop.aborted)
+                    return null;
+            }
+            const rows = await feed.refresh();
+            yielded++;
+            if (opts.verbose)
+                opts.io.stderr.write(`watch: tick ${yielded}, ${rows.length} rows\n`);
+            return { rows: rows.map((r) => toRuleRow(r, larp)), now: opts.now() };
+        },
+        close() { try {
+            feed?.close();
+        }
+        catch { /* ignore */ } },
+    };
+}
+export async function watchCommand(argv, io, deps = {}) {
+    const parsed = parseArgs(argv);
+    if ('error' in parsed) {
+        io.stderr.write(`dexterm watch: ${parsed.error}\n\n${WATCH_USAGE}`);
+        return 2;
+    }
+    if (parsed.help) {
+        io.stdout.write(WATCH_USAGE);
+        return 0;
+    }
+    const now = deps.now ?? (() => Date.now());
+    const home = dextermHome(io.env);
+    const loaded = loadConfig(home);
+    for (const e of loaded.errors)
+        io.stderr.write(`dexterm watch: config: ${e}\n`);
+    const rules = loaded.config.rules ?? [];
+    const engine = new RulesEngine({ rules, now: now() });
+    for (const e of engine.errors)
+        io.stderr.write(`dexterm watch: rule ${e.id}: ${e.msg}\n`);
+    const enabled = engine.rules.filter((r) => r.enabled).length;
+    if (enabled === 0)
+        io.stderr.write('dexterm watch: no enabled rules (add some with `dexterm rules add`); nothing will fire\n');
+    // SIGINT-aware sleeper for the production loop.
+    const stop = (() => {
+        let aborted = false;
+        let wake = () => { };
+        return {
+            get aborted() { return aborted; },
+            abort() { aborted = true; wake(); },
+            wake() { wake(); },
+            wait(ms) { return new Promise((res) => { const t = setTimeout(res, ms); wake = () => { clearTimeout(t); res(); }; }); },
+        };
+    })();
+    const notifier = deps.notifier ?? buildNotifier(home, loaded.config.alerts, {
+        toastSink: (line) => io.stdout.write(`${new Date(now()).toISOString().slice(11, 19)} ${line}\n`),
+    });
+    const source = deps.source ?? createFeedSource({ replay: parsed.replay, db: parsed.db, intervalMs: parsed.intervalMs, verbose: parsed.verbose, io, now, stop });
+    const ready = notifier.readyChannels();
+    if (parsed.verbose || !deps.notifier)
+        io.stderr.write(`dexterm watch: ${enabled} rule(s), channels: ${ready.length ? ready.join(', ') : 'toast'}\n`);
+    const onSigint = () => { io.stderr.write('\ndexterm watch: stopping…\n'); stop.abort(); };
+    const addSig = !deps.source; // only own SIGINT for the real loop (tests drive a finite source)
+    if (addSig)
+        process.on('SIGINT', onSigint);
+    let delivered = 0;
+    try {
+        for (let tick = 0; tick < parsed.ticks; tick++) {
+            const snap = await source.next();
+            if (!snap)
+                break;
+            engine.observe(snap.rows, snap.now);
+            const res = engine.evaluate(snap.rows, snap.now, { watchlist: snap.watchlist, positions: snap.positions });
+            for (const a of res.alerts) {
+                await notifier.deliver(alertToDelivery(a));
+                delivered++;
+            }
+            if (loaded.config.alerts?.proposals)
+                for (const p of res.proposals) {
+                    await notifier.deliver(proposalToDelivery(p));
+                    delivered++;
+                }
+        }
+    }
+    catch (e) {
+        io.stderr.write(`dexterm watch: ${redactCreds(e.message)}\n`);
+        return 1;
+    }
+    finally {
+        if (addSig)
+            process.removeListener('SIGINT', onSigint);
+        await source.close?.();
+    }
+    if (parsed.verbose || !deps.notifier)
+        io.stderr.write(`dexterm watch: delivered ${delivered} alert(s)\n`);
+    return 0;
+}

package/dist/packages/custom/src/rules.js

@@ -3,12 +3,13 @@ export const FIELDS = {
     vol5m: (r) => r.vol5m, vol1h: (r) => r.vol1h, vol24: (r) => r.vol24,
     holders: (r) => r.holders, org: (r) => r.org, top10: (r) => r.top10, dev: (r) => r.dev,
     lplocked: (r) => r.lpLocked, bundled: (r) => r.bundled, snipers: (r) => r.snipers,
-    cluster: (r) => r.cluster,
+    cluster: (r) => r.cluster, larp: (r) => r.larp,
+    fresh: (r) => r.fresh, mintable: (r) => r.mintable, freezable: (r) => r.freezable,
     age: (r) => r.ageMin, m5: (r) => r.chg?.m5, h1: (r) => r.chg?.h1, h6: (r) => r.chg?.h6, h24: (r) => r.chg?.h24,
     buys: (r) => r.buys, sells: (r) => r.sells, bonding: (r) => r.bonding,
 };
 export const FIELD_NAMES = Object.keys(FIELDS);
-const ALIASES = { vol: 'vol24', volume: 'vol24', liquidity: 'liq', cap: 'mcap', mc: 'mcap', holder: 'holders', organic: 'org', top: 'top10', locked: 'lplocked', 'cluster%': 'cluster', clusterpct: 'cluster' };
+const ALIASES = { vol: 'vol24', volume: 'vol24', liquidity: 'liq', cap: 'mcap', mc: 'mcap', holder: 'holders', organic: 'org', top: 'top10', locked: 'lplocked', 'cluster%': 'cluster', clusterpct: 'cluster', freshwallets: 'fresh', mintauth: 'mintable', freezeauth: 'freezable' };
 const OPS = { '>': (a, b) => a > b, '>=': (a, b) => a >= b, '<': (a, b) => a < b, '<=': (a, b) => a <= b, '=': (a, b) => a === b, '==': (a, b) => a === b, '!=': (a, b) => a !== b };
 const TAGS = {
     launchpad: (r, v) => (r.launchpad ?? '').toLowerCase().replace('.fun', '') === v.toLowerCase().replace('.fun', ''),

package/dist/packages/custom/src/schema.js

@@ -199,6 +199,9 @@ export const SCHEMAS = {
             token: { type: 'object', additional: false, props: { tape: { type: 'boolean' }, social: { type: 'boolean' }, analyst: { type: 'boolean' } } },
         } },
     screenLayout: { oneOf: ['layoutNode', { type: 'object', additional: false, props: { wide: 'layoutNode', standard: 'layoutNode', compact: 'layoutNode' } }] },
+    /** task-1398: one alert-delivery channel. A `levels` filter (subset of up|down|info|warn); absent = every level. */
+    alertLevels: { type: 'array', max: 4, items: { type: 'string', enum: ['up', 'down', 'info', 'warn'] } },
+    alertChannel: { type: 'object', additional: false, props: { enabled: { type: 'boolean' }, levels: 'alertLevels' } },
     ruleJson: { type: 'object', additional: false, required: ['id', 'when', 'then'], props: {
             id: { type: 'string', pattern: NAME },
             name: { type: 'string', max: 80 },
@@ -258,6 +261,26 @@ export const SCHEMAS = {
                     /** Reserved: the trading gate is NOT here (signer policy owns it); listed so a proposal that tries gets a precise refusal. */
                     gate: { type: 'string', enum: ['keypress'] },
                 } },
+            /** task-1393: voice-out preferences. `/voice` is user-only (DENIED_FOR_MODELS), so only the keyboard sets it. */
+            voice: { type: 'object', additional: false, props: {
+                    name: { type: 'string', max: 64 },
+                    rate: { type: 'number', int: true, min: 80, max: 400 },
+                    pitch: { type: 'number', int: true, min: 0, max: 100 },
+                } },
+            /**
+             * task-1398: alert delivery routing. Enable flags + a per-channel `levels` filter ONLY; NO credentials here
+             * (bot tokens / webhook URLs live in ~/.dexterm/telegram.json and discord.json, 0600, like every other key).
+             * `/alerts` is user-only (DENIED_FOR_MODELS) so a model can never redirect your alerts to its own channel.
+             */
+            alerts: { type: 'object', additional: false, props: {
+                    channels: { type: 'object', additional: false, props: {
+                            toast: 'alertChannel', desktop: 'alertChannel',
+                            telegram: { type: 'object', additional: false, props: { enabled: { type: 'boolean' }, levels: 'alertLevels', chatId: { type: 'string', pattern: '^-?[0-9]{1,19}$' } } },
+                            discord: 'alertChannel',
+                        } },
+                    /** Deliver a one-line summary of ticket/ask PROPOSALS too (never the ticket itself; off by default). */
+                    proposals: { type: 'boolean' },
+                } },
             scan: { type: 'object', additional: true },
             popups: { type: 'object', additional: false, props: { rain: { type: 'object', additional: false, props: { enabled: { type: 'boolean' }, speedScale: { type: 'number', min: 0, max: 4 }, density: { type: 'number', min: 0, max: 1 } } } } },
             /** Forward-compat bag: unknown sections from a newer dexterm survive a downgrade here. */
@@ -403,7 +426,7 @@ export function applyOps(doc, ops) {
 export const DENIED_FOR_MODELS = [
     /^\/signer(\/|$)/, /^\/trading(\/|$)/, /^\/keys(\/|$)/, /^\/caps(\/|$)/, /^\/mandates?(\/|$)/, /^\/wallet(\/|$)/,
     /^\/packs(\/|$)/, /^\/plugins\/[^/]+\/(capabilities|enabled)(\/|$)/, /^\/plugins\/[^/]+$/, /^\/plugins$/,
-    /^\/jarvis\/gate(\/|$)/, /^\/jarvis\/configAssistant$/, /^\/voice(\/|$)/, /^\/agents(\/|$)/, /^\/version$/,
+    /^\/jarvis\/gate(\/|$)/, /^\/jarvis\/configAssistant$/, /^\/voice(\/|$)/, /^\/alerts(\/|$)/, /^\/agents(\/|$)/, /^\/version$/,
     /^\/rules\/(\d+|-)\/then\/(\d+|-)\/args\/(arm|armed|auto|autoArm|confirm|execute|sign|send)(\/|$)/,
 ];
 /** Keys a model-authored VALUE may never contain at any depth (money/secret-shaped), whatever the path. */

package/dist/packages/data/src/analyst-actions.js

@@ -18,8 +18,53 @@ export const BASE58_RE = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
 export const ACTION_FILE_ENV = 'DEXTERM_ACTION_FILE';
 /** Env var carrying the per-run random token that authenticates channel lines. */
 export const ACTION_TOKEN_ENV = 'DEXTERM_ACTION_TOKEN';
-/** The five non-financial UI actions the analyst may request. */
-export const ANALYST_ACTION_TYPES = ['open_token', 'show_in_screener', 'add_to_watchlist', 'switch_feed', 'open_ticket'];
+/**
+ * The non-financial UI actions the analyst may request (task-1313, extended in task-1413).
+ *
+ * Two tiers (see `ACTION_TIER`):
+ *  - `view`   — local, reversible runtime changes applied immediately with an "analyst did X" note.
+ *  - `config` — a persisted change to `config.json`. It is NOT applied by the model; the consumer turns
+ *               it into a one-line PROPOSAL the user accepts with a keypress, then writes it through the
+ *               journaled config path (`applyAndJournal`, actor `analyst`, so `ctrl+z` undoes it).
+ *
+ * FORBIDDEN forever (task-1413 tier c): there is deliberately NO action kind that touches wallets, keys,
+ * credentials, alert-channel secrets, signing/arming/caps/mandates, trade tickets beyond the existing
+ * PAPER `open_ticket`, network/RPC settings, or software install/update. Such a request fails here as an
+ * "unknown action type". The journaled config paths a `config` action may write are a closed list
+ * (`CONFIG_ACTION_PATHS`), AND the consumer re-runs `policyCheck(..., non-user actor)` on the journal op, so
+ * no `config` action may ever write a `DENIED_FOR_MODELS` path — none of the paths below is denied or a
+ * money/secret path.
+ *
+ * NOTE (task-1413 r2): voice rate / voice name are NOT analyst actions. `/voice` is `DENIED_FOR_MODELS`
+ * ("only the keyboard sets it", schema.ts), and the gate stays the gate: a model may never write it, even
+ * behind a keypress proposal. The analyst still EXPLAINS how to change the voice (app-help: edit config.json
+ * or the `,` key); it just cannot write it. Re-enabling it would need a maintainer-approved DENIED_FOR_MODELS carve-out.
+ */
+export const ANALYST_ACTION_TYPES = [
+    // task-1313 (unchanged):
+    'open_token', 'show_in_screener', 'add_to_watchlist', 'switch_feed', 'open_ticket',
+    // task-1413 view-only:
+    'switch_screen', 'switch_workspace', 'chart_popup', 'toggle_calm', 'set_scan', 'export_view',
+    // task-1413 persisted config (user-confirmed, journaled; non-denied display paths only):
+    'set_theme', 'set_price_mode', 'set_intensity',
+];
+/** Tier of each action: `view` = immediate runtime, `config` = persisted via a user-confirmed journal write. */
+export const ACTION_TIER = {
+    open_token: 'view', show_in_screener: 'view', add_to_watchlist: 'view', switch_feed: 'view', open_ticket: 'view',
+    switch_screen: 'view', switch_workspace: 'view', chart_popup: 'view', toggle_calm: 'view', set_scan: 'view', export_view: 'view',
+    set_theme: 'config', set_price_mode: 'config', set_intensity: 'config',
+};
+/**
+ * The exact `config.json` JSON-Pointer each `config` action writes — a closed allow-list. Every path here
+ * is a local, reversible, non-financial DISPLAY setting and NONE is a `DENIED_FOR_MODELS` path (the journal
+ * write re-checks that with `policyCheck`). NOTHING here is matched by `DENIED_VALUE_KEYS` / the money-safety
+ * sections; the consumer additionally confirms each with a keypress.
+ */
+export const CONFIG_ACTION_PATHS = {
+    set_theme: '/theme/name',
+    set_price_mode: '/display/priceMode',
+    set_intensity: '/fx/intensity',
+};
 /** Max actions the consumer should apply per rolling window, and the window length. Advisory shared constants. */
 export const ACTION_RATE = { max: 6, windowMs: 10_000 };
 const FILTER_MAX = 120;
@@ -27,6 +72,10 @@ const FILTER_MAX = 120;
 // `!` is included so tag negation (`!flag:mint`, `!launchpad:pump`) — a documented part of the grammar —
 // survives the boundary instead of being rejected as malformed (task-1313 part E).
 const FILTER_SAFE_RE = /^[\w\s<>=:.%$,+!\-|()]*$/;
+// task-1413 value shapes. The consumer re-validates against config schema (`validateConfig`) too.
+const THEME_NAME_RE = /^[a-z][a-z0-9-]{0,39}$/; // mirrors schema.ts NAME
+const PRICE_MODES = ['price', 'mcap'];
+const INTENSITIES = ['off', 'normal', 'fever'];
 function isObj(x) {
     return typeof x === 'object' && x !== null && !Array.isArray(x);
 }
@@ -94,14 +143,92 @@ export function validateAnalystAction(raw, allow) {
                 out.highlight = raw.highlight;
                 bits.push(`highlight ${short(raw.highlight)}`);
             }
+            if (raw.preset !== undefined && raw.preset !== null && raw.preset !== '') {
+                if (typeof raw.preset !== 'string' || !allow.feeds.includes(raw.preset)) {
+                    return { ok: false, error: `show_in_screener: preset must be one of ${allow.feeds.join(', ') || '(none)'}` };
+                }
+                out.preset = raw.preset;
+                bits.push(`preset ${out.preset}`);
+            }
             if (!bits.length)
-                return { ok: false, error: 'show_in_screener: nothing to do (give filter, sort, or highlight)' };
+                return { ok: false, error: 'show_in_screener: nothing to do (give filter, sort, preset, or highlight)' };
             return { ok: true, action: out, label: `showed the screener (${bits.join(', ')})` };
         }
+        case 'switch_screen': {
+            const screens = allow.screens ?? [];
+            if (typeof raw.screen !== 'string' || !screens.includes(raw.screen)) {
+                return { ok: false, error: `switch_screen: screen must be one of ${screens.join(', ') || '(none)'}` };
+            }
+            return { ok: true, action: { type, screen: raw.screen }, label: `switched to the ${raw.screen} screen` };
+        }
+        case 'switch_workspace': {
+            const workspaces = allow.workspaces ?? [];
+            if (typeof raw.name !== 'string' || !workspaces.includes(raw.name)) {
+                return { ok: false, error: `switch_workspace: name must be one of ${workspaces.join(', ') || '(none)'}` };
+            }
+            return { ok: true, action: { type, name: raw.name }, label: `opened the "${raw.name}" workspace` };
+        }
+        case 'chart_popup': {
+            if (typeof raw.open !== 'boolean')
+                return { ok: false, error: 'chart_popup: open must be true or false' };
+            return { ok: true, action: { type, open: raw.open }, label: raw.open ? 'opened the chart popup' : 'closed the chart popup' };
+        }
+        case 'toggle_calm': {
+            if (typeof raw.on !== 'boolean')
+                return { ok: false, error: 'toggle_calm: on must be true or false' };
+            return { ok: true, action: { type, on: raw.on }, label: raw.on ? 'turned on calm mode' : 'turned off calm mode' };
+        }
+        case 'set_scan': {
+            if (typeof raw.on !== 'boolean')
+                return { ok: false, error: 'set_scan: on must be true or false' };
+            return { ok: true, action: { type, on: raw.on }, label: raw.on ? 'turned scan mode on' : 'turned scan mode off' };
+        }
+        case 'export_view': {
+            return { ok: true, action: { type }, label: 'exported the current view' };
+        }
+        case 'set_theme': {
+            if (typeof raw.name !== 'string' || !THEME_NAME_RE.test(raw.name))
+                return { ok: false, error: 'set_theme: invalid theme name' };
+            const themes = allow.themes ?? [];
+            if (!themes.includes(raw.name))
+                return { ok: false, error: `set_theme: theme must be one of ${themes.join(', ') || '(none)'}` };
+            return { ok: true, action: { type, name: raw.name }, label: `set the theme to ${raw.name}` };
+        }
+        case 'set_price_mode': {
+            if (raw.mode !== 'price' && raw.mode !== 'mcap')
+                return { ok: false, error: `set_price_mode: mode must be one of ${PRICE_MODES.join(', ')}` };
+            return { ok: true, action: { type, mode: raw.mode }, label: `set the price display to ${raw.mode === 'mcap' ? 'market cap' : 'price'}` };
+        }
+        case 'set_intensity': {
+            if (typeof raw.intensity !== 'string' || !INTENSITIES.includes(raw.intensity)) {
+                return { ok: false, error: `set_intensity: intensity must be one of ${INTENSITIES.join(', ')}` };
+            }
+            return { ok: true, action: { type, intensity: raw.intensity }, label: `set the visual intensity to ${raw.intensity}` };
+        }
         default:
             return { ok: false, error: `unknown action type ${type}` };
     }
 }
+/**
+ * Map a validated `config`-tier action to a `{section, key, value}` descriptor of the `config.json`
+ * change it requests. Returns `null` for a `view`-tier action (nothing to persist). Pure and
+ * dependency-free: the consumer builds the actual `PatchOp` (creating the parent section when it is
+ * absent, exactly like the `dexterm display` / `,` voice handlers), runs the config schema validator,
+ * and writes through `applyAndJournal` (actor `analyst`). `section`/`key` are fixed, never taken from
+ * model input — only `value` comes from the (already-validated) action.
+ */
+export function configChangeForAction(action) {
+    const at = (path, value) => {
+        const [, section, key] = path.split('/');
+        return { section, key, value, path };
+    };
+    switch (action.type) {
+        case 'set_theme': return at(CONFIG_ACTION_PATHS.set_theme, action.name);
+        case 'set_price_mode': return at(CONFIG_ACTION_PATHS.set_price_mode, action.mode);
+        case 'set_intensity': return at(CONFIG_ACTION_PATHS.set_intensity, action.intensity);
+        default: return null;
+    }
+}
 /** Serialize a channel line (newline-terminated). */
 export function serializeActionLine(token, seq, action) {
     const line = { v: 1, token, seq, ts: Date.now(), action };

package/dist/packages/data/src/coin-target.js

@@ -0,0 +1,82 @@
+// @dexterm/data — "paste a CA or a coin link anywhere" (task-1401, building on the task-1388 GO-TO parser). Shared by
+// the CLI (go-to prompt, analyst chat, the screener `/` line, --mint) and the MCP server (a link passed as `mint`).
+//
+// parseMintTarget (task-1388) pulls a base58 mint out of a bare address or a dexscreener / pump.fun / solscan URL.
+// parseCoinTarget adds what the other inputs need: WHICH site the link came from (a dexscreener.com/solana/<addr>
+// link usually names the POOL, so it is resolved to its coin before the token screen opens) and the REST of the
+// text, so "is <CA> a rug?" in the analyst chat opens the coin and asks the question about it.
+// Pure and total: never throws, only ever returns a validated base58 string.
+/** A full base58 Solana mint: 32–44 chars, no 0/O/I/l. Same shape `--mint` validates. */
+export const MINT_RE = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+/**
+ * task-1388: turn a pasted/typed go-to target into a mint, or null when there is none. Accepts a bare base58
+ * mint, or a dexscreener / pump.fun / solscan URL (or any text) by pulling the first base58 run of mint length.
+ * Base58 excludes 0, O, I and l, so splitting on every non-base58 character also splits on them and on the URL
+ * punctuation (/, :, ., ?, =, &), leaving each path/query segment as its own token; a real mint is never cut.
+ */
+export function parseMintTarget(raw) {
+    const s = raw.trim();
+    if (!s)
+        return null;
+    if (MINT_RE.test(s))
+        return s;
+    for (const tok of s.split(/[^1-9A-HJ-NP-Za-km-z]+/))
+        if (MINT_RE.test(tok))
+            return tok;
+    return null;
+}
+const HOSTS = [
+    [/(^|\.)dexscreener\.com$/, 'dexscreener'],
+    [/(^|\.)pump\.fun$/, 'pumpfun'],
+    [/(^|\.)solscan\.io$/, 'solscan'],
+    [/(^|\.)birdeye\.so$/, 'birdeye'],
+];
+const URLISH = /^(?:https?:\/\/)?(?:www\.)?([a-z0-9-]+(?:\.[a-z0-9-]+)+)(\/\S*)$/i;
+/**
+ * Find the first coin address in free text: a link with an address in its path (its host decides `via`), else a
+ * bare base58 address word. `rest` is the remaining text. Null when the text names no address.
+ */
+export function parseCoinTarget(raw) {
+    const s = String(raw ?? '').trim().slice(0, 800);
+    if (!s)
+        return null;
+    const words = s.split(/\s+/);
+    const restWithout = (i) => words.filter((_, k) => k !== i).join(' ').trim();
+    for (let i = 0; i < words.length; i++) {
+        const m = URLISH.exec(words[i]);
+        if (!m)
+            continue;
+        const address = parseMintTarget(m[2]);
+        if (!address)
+            continue;
+        const host = m[1].toLowerCase();
+        return { address, via: HOSTS.find(([re]) => re.test(host))?.[1] ?? 'link', rest: restWithout(i) };
+    }
+    for (let i = 0; i < words.length; i++) {
+        // a bare address, allowing surrounding punctuation ("<CA>?", "(CA)", "CA,")
+        const core = words[i].replace(/^[^1-9A-HJ-NP-Za-km-z]+|[^1-9A-HJ-NP-Za-km-z]+$/g, '');
+        if (MINT_RE.test(core))
+            return { address: core, via: 'address', rest: restWithout(i) };
+    }
+    return null;
+}
+/** True when the text left after the address asks nothing ("", "open", "check this", "?"): just open the coin. */
+export function isBareOpen(rest) {
+    return /^(?:(?:open|go|to|show|me|check|look|at|this|that|one|the|ca|token|coin|pls|please|here|it)\b|[\s?.!:,;\-–—])*$/i.test(rest.trim());
+}
+/**
+ * Resolve a target to the coin's mint. A dexscreener link's address is looked up as a pair first (one keyless
+ * request through the limiter); when DexScreener has no such pair, or the lookup fails (offline, a replay without
+ * it), the address is used as the mint. Every other target is already a mint.
+ */
+export async function resolveCoinTarget(t, dl) {
+    if (t.via !== 'dexscreener' || !dl)
+        return { mint: t.address, fromPair: false };
+    try {
+        const coin = await dl.dexscreener.pairCoin(t.address);
+        if (coin && MINT_RE.test(coin))
+            return { mint: coin, fromPair: coin !== t.address };
+    }
+    catch { /* fall through: treat the address as the mint */ }
+    return { mint: t.address, fromPair: false };
+}

package/dist/packages/data/src/fast-lane.js

@@ -159,7 +159,7 @@ export class FastLane {
             return false;
         if (this.tracked.size >= this.cap)
             return false; // over the cap: stay slow, never drop
-        const t = { mint, priceAccount, lastTickAt: null, lastPrice: null, migrated: false };
+        const t = { mint, priceAccount, lastTickAt: null, lastPrice: null, lastCurve: null, lastCurveAt: null, migrated: false };
         this.tracked.set(mint, t);
         this.byAccount.set(priceAccount.curve, mint);
         this.ws?.subscribe(priceAccount.curve);
@@ -227,7 +227,13 @@ export class FastLane {
         if (!tracked)
             return;
         const curve = decodeBondingCurve(base64);
-        if (!curve || curve.priceSol == null)
+        if (!curve)
+            return;
+        // task-1404: keep the decoded curve (reserves / complete) so the live-signals binding can read bonding
+        // progress and migration from the same push, not just the price.
+        tracked.lastCurve = curve;
+        tracked.lastCurveAt = t;
+        if (curve.priceSol == null)
             return;
         if (curve.complete) {
             // Migrated to a DEX pool: the bonding-curve price is stale. Demote to the slow lane honestly;
@@ -280,6 +286,14 @@ export class FastLane {
     price(mint) {
         return this.tracked.get(mint)?.lastPrice ?? null;
     }
+    /**
+     * Last decoded bonding curve for a mint and when it was decoded (task-1404). The live-signals binding reads
+     * bonding progress + `complete` from it. null when the mint is not tracked or no push/seed has decoded yet.
+     */
+    curve(mint) {
+        const t = this.tracked.get(mint);
+        return t && t.lastCurve && t.lastCurveAt != null ? { curve: t.lastCurve, at: t.lastCurveAt } : null;
+    }
     /**
      * Last fast-lane USD price, recomputed from the stored on-chain SOL price and the *current* SOL/USD —
      * so a tick that arrived before SOL/USD was known still shows a USD value once the rate lands. Null

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

@@ -49,11 +49,15 @@ export { parseSignerArgs, buildSignerService } from "./trade/signer/main.js";
 export * from "./larp/links.js";
 export * from "./larp/safe-fetch.js";
 export * from "./larp/evidence.js";
+export * from "./larp/link-baseline.js";
+// task-1401: parse a CA / coin link from any input (go-to, analyst chat, filter line, --mint, MCP refs).
+export * from "./coin-target.js";
 export * from "./analyst-actions.js";
 export * from "./intel/rules.js";
 export * from "./intel/holder-class.js";
 export * from "./intel/helius-history.js";
 export * from "./intel/scan.js";
+export * from "./intel/live-signals.js";
 export * from "./images/index.js";
 // task-1330 (I-03): social / news / trending layer. `Provenance` and `Credibility`-style names are
 // namespaced under `Social*` where they would collide with the core model.

package/dist/packages/data/src/intel/helius-history.js

@@ -1,5 +1,11 @@
 import { rpcBodyCheck } from "../sources/solana-rpc.js";
 export const HISTORY_METHODS = new Set(['getTransactionsForAddress']);
+/**
+ * Max transaction version we declare support for. Legacy and v0 are all Solana ships today, but Helius's
+ * enhanced history has returned a v1 tx in live launch windows (task-1394). We only read static account keys
+ * and per-balance owners, which are version-independent, so cap high rather than re-break on the next version.
+ */
+export const MAX_TX_VERSION = 128;
 export class HeliusHistory {
     http;
     /** May carry an api-key: never print it. */
@@ -25,7 +31,12 @@ export class HeliusHistory {
     async transactions(address, opts) {
         const limit = Math.max(1, Math.min(1000, Math.floor(opts.limit)));
         const params = {
-            transactionDetails: 'full', sortOrder: opts.sortOrder ?? 'asc', limit, encoding: 'jsonParsed', maxSupportedTransactionVersion: 0,
+            // A single versioned tx in the page whose version exceeds this cap fails the WHOLE request with
+            // rpc -32015 ("Transaction version (N) is not supported … maxSupportedTransactionVersion"), which
+            // surfaced as "history failed" on live pump.fun launch windows (task-1394: a v1 tx in the first 100).
+            // The rules only read static accountKeys (signers are always static, never in a lookup table) and the
+            // per-balance owner/mint, so a high cap is safe and forward-compatible across tx versions.
+            transactionDetails: 'full', sortOrder: opts.sortOrder ?? 'asc', limit, encoding: 'jsonParsed', maxSupportedTransactionVersion: MAX_TX_VERSION,
             filters: { status: 'succeeded' },
         };
         if (opts.paginationToken)