dexterm-cli 0.1.2 → 0.1.3

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

@@ -0,0 +1,104 @@
+// `dexterm spectate …` — watch an agent drive dexterm (task-1406, "watch the agent cook").
+//
+//   dexterm spectate --replay FILE [--json]   replay a saved session file (demos + bug reports): fold the
+//                                             recorded agent actions into the screen model + activity panel
+//   dexterm spectate --info [--json]          show the live spectator stream endpoint (loopback + token)
+//                                             from ~/.dexterm/spectator.json, if a session is streaming
+//
+// Replay is deterministic and offline. The live stream itself is started by `dexterm agent serve --spectate`;
+// it is read-only, loopback-only and token-gated, and redacts wallet addresses/keys (see SPECTATOR.md).
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { FollowController, loadSpectatorRecording } from '../../agents/src/index.js';
+function flag(rest, name) { const i = rest.indexOf(name); return i >= 0 ? rest[i + 1] : undefined; }
+function has(rest, name) { return rest.includes(name); }
+const USAGE = `dexterm spectate <command>
+  --replay FILE [--json]   replay a saved session (fold agent actions into the screen + activity panel)
+  --info [--json]          show the live stream endpoint from ~/.dexterm/spectator.json (if streaming)
+read-only · redacts wallet addresses/keys · the live stream is started by \`dexterm agent serve --spectate\``;
+function ago(t) { const s = Math.max(0, Math.round((Date.now() - t) / 1000)); return s < 60 ? `${s}s` : s < 3600 ? `${Math.floor(s / 60)}m` : `${Math.floor(s / 3600)}h`; }
+function age(s) { if (s == null)
+    return ''; return s < 60 ? ` · ${Math.round(s)}s old` : s < 3600 ? ` · ${Math.floor(s / 60)}m old` : ` · ${Math.floor(s / 3600)}h old`; }
+function renderView(view, meta, out) {
+    const s = view.screen;
+    out('SCREEN');
+    const bits = [`screen ${s.screen}`];
+    if (s.selectedMint)
+        bits.push(`token ${s.selectedMint}`);
+    if (s.feed)
+        bits.push(`feed ${s.feed}`);
+    if (s.filter)
+        bits.push(`filter ${s.filter}`);
+    if (s.highlight)
+        bits.push(`★ ${s.highlight}`);
+    if (s.watchlist.length)
+        bits.push(`watchlist ${s.watchlist.length}`);
+    out(`  ${bits.join(' · ')}`);
+    if (view.control === 'user')
+        out('  YOU HAVE TAKEN OVER (agent frozen)');
+    out('');
+    out('AGENTS');
+    if (!view.agents.length)
+        out('  (none)');
+    for (const a of view.agents)
+        out(`  [agent] ${a.name}  ${a.tier ?? '—'}  ${a.status}  · ${ago(a.lastAt)}`);
+    out('');
+    out(`ACTIVITY (${view.activity.length}${meta.redacted ? ' · redacted' : ' · full'})`);
+    for (const ev of view.activity) {
+        const ms = ev.ms != null ? ` ${Math.round(ev.ms)}ms` : '';
+        out(`  ${ago(ev.t).padStart(4)}  [agent] ${ev.agent}  ${ev.phase.padEnd(8)} ${(ev.tool ?? '').padEnd(16)} ${ev.summary ?? ''}${ms}${age(ev.dataAgeSec)}`);
+    }
+}
+export async function runSpectate(rest, io) {
+    const out = (s) => io.stdout.write(s + '\n');
+    const errOut = (s) => io.stderr.write(s + '\n');
+    const replayFile = flag(rest, '--replay');
+    if (replayFile) {
+        let recording;
+        try {
+            recording = loadSpectatorRecording(replayFile);
+        }
+        catch (e) {
+            errOut(`dexterm spectate: cannot read ${replayFile}: ${e.message}`);
+            return 1;
+        }
+        const follow = new FollowController({ activityCap: 500 });
+        for (const ev of recording.events)
+            follow.apply(ev);
+        if (has(rest, '--json')) {
+            out(JSON.stringify({ meta: recording.meta, view: follow.view() }));
+            return 0;
+        }
+        out(`replaying ${recording.events.length} event(s) from ${replayFile}${recording.meta.redacted ? ' (redacted)' : ''}`);
+        out('');
+        renderView(follow.view(), recording.meta, out);
+        return 0;
+    }
+    if (has(rest, '--info')) {
+        const home = io.env.DEXTERM_HOME || join(io.env.HOME || '', '.dexterm');
+        const path = join(home, 'spectator.json');
+        let info;
+        try {
+            info = JSON.parse(readFileSync(path, 'utf8'));
+        }
+        catch {
+            errOut('no live spectator stream (start one with `dexterm agent serve --spectate`).');
+            return 1;
+        }
+        if (has(rest, '--json')) {
+            out(JSON.stringify(info));
+            return 0;
+        }
+        out(`live spectator stream on ws://127.0.0.1:${info.port} (loopback only).`);
+        out(`token is in ${path} (mode 0600) — pass it in the viewer's hello; never on a command line.`);
+        out('the stream is read-only and redacts wallet addresses/keys.');
+        return 0;
+    }
+    if (rest.length && !rest[0].startsWith('--')) {
+        errOut(`dexterm spectate: unknown subcommand ${JSON.stringify(rest[0])}`);
+        errOut(USAGE);
+        return 2;
+    }
+    out(USAGE);
+    return rest.length ? 2 : 0;
+}

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

@@ -120,7 +120,7 @@ export function plansRows(state) {
         return [];
     return state.plansUi?.tab === 'mandates' ? svc.listMandates() : svc.listPlans();
 }
-export function newFollowsUi() { return { selected: 0, input: null, notice: null, mirror: null, autoModal: null }; }
+export function newFollowsUi() { return { selected: 0, input: null, notice: null, mirror: null, autoModal: null, detail: null }; }
 /**
  * Tier 3: the auto-mirror service for this run, attached to the copy binding on first use. It sits on the plan
  * service (the signer trust domain) and the copy binding's market resolver; its journal is ~/.dexterm/copy.journal.

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

@@ -1,3 +1,3 @@
 // The one place the app's version lives (task-1397). --version, the help banner and `dexterm update` read it;
 // cli.test.ts keeps it equal to packages/cli/package.json (release.yml refuses a tag that differs).
-export const VERSION = '0.1.2';
+export const VERSION = '0.1.3';

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

@@ -1,25 +1,47 @@
-// `dexterm voice …` (task-1408): inspect the voice engines on this machine and download the two
-// optional voice models — whisper.cpp base.en (speech-in) and the Piper en_GB-alan-medium voice
-// (neural speech-out). Downloads are OFF by default: this is the ONLY place dexterm fetches a model,
-// it asks before it does, and it verifies the download against a pinned checksum from the official
-// source. Nothing here runs the signer, touches keys, or changes trading behaviour.
+// `dexterm voice …` (task-1408, task-1416): inspect the voice engines on this machine, download the two
+// optional voice models — whisper.cpp base.en (speech-in) and the Piper en_GB-alan-medium voice (neural
+// speech-out) — and SET UP the managed neural voice on macOS. Network use is OFF by default: this is the
+// only place dexterm fetches a model or installs a runtime, it asks before it does, and it verifies the
+// voice model against a pinned checksum from the official source. Nothing here runs the signer, touches
+// keys, or changes trading behaviour.
 //
-// No new dependencies: the confirm prompt is node:readline, the download uses global fetch, and the
-// checksum/stream logic lives in @dexterm/voice (unit-tested with an injected fetch).
+// No new dependencies: the confirm prompt is node:readline, downloads use global fetch, `voice setup`
+// shells out to the system python/pip, and the checksum/stream/venv logic lives in @dexterm/voice.
 import { createInterface } from 'node:readline';
+import { spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { modelRegistry, downloadModel, modelStatus, resolvePiperBin, pickPlayer, PIPER_MODEL, DEFAULT_PIPER_VOICE } from '../../voice/src/index.js';
+import { modelRegistry, downloadModel, modelStatus, resolvePiperBin, pickPlayer, PIPER_MODEL, DEFAULT_PIPER_VOICE, setupPiperRuntime, uninstallPiperRuntime, piperRuntimeStatus, } from '../../voice/src/index.js';
 import { dextermHome } from '../../custom/src/index.js';
 export const VOICE_USAGE = [
     'usage:',
     '  dexterm voice [status]                 show the voice engines + which models are installed',
+    '  dexterm voice setup [--yes]            set up the neural voice (Piper) on this machine (asks first)',
+    '  dexterm voice uninstall [--purge-model] remove the managed neural-voice runtime',
     '  dexterm voice download <model> [--yes] download a voice model (asks first; checksum-verified)',
     '',
     '  models: whisper        whisper.cpp base.en  (speech-to-text, off macOS this is the default)',
-    '          piper-voice    Piper en_GB-alan-medium (neural speech-out, preferred over espeak-ng)',
+    '          piper-voice    Piper en_GB-alan-medium (neural speech-out, the default speaking voice)',
     '          all            both of the above',
 ].join('\n');
+/** Run a command, capture its output, and resolve a RunResult (never rejects). Used by `voice setup`. */
+function runCmd(cmd, args) {
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        }
+        catch (e) {
+            resolve({ code: 127, stdout: '', stderr: e.message });
+            return;
+        }
+        let stdout = '', stderr = '';
+        child.stdout?.on('data', (d) => { stdout += d; });
+        child.stderr?.on('data', (d) => { stderr += d; });
+        child.on('error', (e) => resolve({ code: 127, stdout, stderr: stderr || e.message }));
+        child.on('close', (code) => resolve({ code, stdout, stderr }));
+    });
+}
 function onPath(bin, env) {
     const sep = process.platform === 'win32' ? ';' : ':';
     for (const p of (env.PATH ?? '').split(sep)) {
@@ -42,7 +64,18 @@ async function printStatus(io) {
     const reg = modelRegistry(home);
     const lines = ['dexterm voice', ''];
     if (process.platform === 'darwin') {
-        lines.push('  speech-out  macOS `say` (built-in) · see `dexterm doctor` for the resolved voice');
+        const rt = await piperRuntimeStatus(home);
+        const player = pickPlayer();
+        const piperReady = rt.installed && player !== null;
+        if (piperReady) {
+            lines.push(`  speech-out  Piper ready (${DEFAULT_PIPER_VOICE}, neural, plays via ${player}) · fallback: macOS \`say\``);
+        }
+        else if (rt.pythonPresent || rt.modelInstalled) {
+            lines.push(`  speech-out  Piper partly set up (${rt.pythonPresent ? 'runtime ok' : 'no runtime'}, ${rt.modelInstalled ? 'model ok' : 'no model'}) — finish with \`dexterm voice setup\` · now using macOS \`say\``);
+        }
+        else {
+            lines.push('  speech-out  macOS `say` (built-in) · neural voice: run `dexterm voice setup` · see `dexterm doctor` for the resolved voice');
+        }
         lines.push('  speech-in   Apple Speech (swiftc) preferred, else whisper.cpp');
     }
     else {
@@ -95,13 +128,55 @@ async function runDownload(io, which, yes) {
     }
     return anyFailed ? 1 : 0;
 }
+/** `dexterm voice setup`: build the managed neural-voice runtime (venv + model) on this machine. */
+async function runSetup(io, yes) {
+    const home = dextermHome(io.env);
+    if (!yes && !io.stdin.isTTY) {
+        io.stderr.write('dexterm voice setup: no interactive terminal to confirm; re-run with --yes to approve the setup.\n');
+        return 2;
+    }
+    // Let the user point setup at a specific interpreter (e.g. a pyenv/homebrew python) via DEXTERM_PYTHON.
+    const candidates = io.env.DEXTERM_PYTHON ? [io.env.DEXTERM_PYTHON] : undefined;
+    const res = await setupPiperRuntime({
+        home,
+        run: runCmd,
+        confirm: (prompt) => (yes ? Promise.resolve(true) : askYesNo(io, `\n${prompt}`)),
+        log: (s) => io.stdout.write(s + '\n'),
+        pythonCandidates: candidates,
+    });
+    if (res.status === 'ok' || res.status === 'already')
+        return 0;
+    if (res.status === 'cancelled')
+        return 1;
+    // no-python / failed: print the exact fix line.
+    io.stderr.write(`dexterm voice setup: ${res.status === 'no-python' ? 'no suitable Python 3 found' : 'setup failed'}.\n`);
+    if (res.fix)
+        io.stderr.write(`  fix: ${res.fix}\n`);
+    return 1;
+}
+/** `dexterm voice uninstall`: remove the managed neural-voice runtime. */
+async function runUninstall(io, purgeModel) {
+    const home = dextermHome(io.env);
+    const res = await uninstallPiperRuntime(home, { purgeModel });
+    if (res.status === 'absent') {
+        io.stdout.write('No managed neural-voice runtime to remove.\n');
+        return 0;
+    }
+    io.stdout.write(`Removed the managed neural-voice runtime${purgeModel ? ' and voice model' : ' (voice model kept — remove with --purge-model)'}.\n`);
+    return 0;
+}
 /** `dexterm voice …`. Returns the process exit code. */
 export async function voiceCommand(argv, io) {
     const yes = argv.includes('--yes') || argv.includes('-y');
-    const rest = argv.filter((a) => a !== '--yes' && a !== '-y');
+    const purgeModel = argv.includes('--purge-model');
+    const rest = argv.filter((a) => a !== '--yes' && a !== '-y' && a !== '--purge-model');
     const sub = rest[0];
     if (sub === undefined || sub === 'status')
         return printStatus(io);
+    if (sub === 'setup')
+        return runSetup(io, yes);
+    if (sub === 'uninstall' || sub === 'remove')
+        return runUninstall(io, purgeModel);
     if (sub === 'download') {
         const which = rest[1];
         if (!which) {

package/dist/packages/cli/src/voice-hud.js

@@ -28,7 +28,7 @@ export function renderVoiceHud(c, v, t) {
     else {
         // idle but enabled: a quiet "ready" badge with the key hints.
         x = c.text(x, y, ' ◎ voice ', { fg: t.borderFocus, bg, b: true });
-        x = c.text(x, y, `v talk · m ${v.muted ? 'unmute' : 'mute'} · , voice${voiceName}`, { fg: t.muted, bg });
+        x = c.text(x, y, `v talk · m ${v.muted ? 'unmute' : 'mute'} · , voice · < > rate${voiceName}`, { fg: t.muted, bg });
     }
     if (mute && v.mode !== 'off')
         x = c.text(x, y, mute, { fg: t.warn, bg, b: true });

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

@@ -4,11 +4,12 @@ export const FIELDS = {
     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, 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/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/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

@@ -57,6 +57,7 @@ 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.