dexterm-cli 0.1.2 → 0.1.4

package/dist/packages/popup/src/pages/spectator.html

@@ -0,0 +1,25 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="dexterm-ws" content="__WS_TOKEN__">
+<meta name="dexterm-popup" content="__POPUP_ID__">
+<meta name="dexterm-port" content="__PORT__">
+<title>dexterm · watch the agent cook</title>
+<style nonce="__NONCE__">/*__CSS__*/</style>
+</head>
+<body>
+<div id="hud" class="hud">
+  <div id="drag" class="drag"><span class="mark">✦</span><span id="title" class="title">dexterm · WATCH THE AGENT COOK</span><span id="status" class="status">connecting…</span><button id="close" class="close" type="button" aria-label="close">✕</button></div>
+  <div class="stage"><canvas id="rain"></canvas><div class="body">
+    <div id="screen" class="spec-screen"></div>
+    <div id="agents" class="spec-agents"></div>
+    <div class="spec-activity-head">agent activity</div>
+    <div id="activity" class="spec-activity"></div>
+  </div></div>
+  <div id="foot" class="foot"><span id="redact" class="spec-foot-redact">redacted</span><span>read-only · pause / take over / kill</span><span id="fps" class="fps">— fps</span></div>
+</div>
+<script nonce="__NONCE__">/*__COMMON_JS__*/</script>
+<script nonce="__NONCE__">/*__JS__*/</script>
+</body>
+</html>

package/dist/packages/popup/src/pages/spectator.js

@@ -0,0 +1,74 @@
+// dexterm popup — spectator page (task-1406, "watch the agent cook"). Renders the SpectatorPopupVM: the
+// screen the agent moved to, the connected agents with an 'agent' badge and status, and an activity feed
+// with timing and data ages. Every string is already REDACTED TUI-side (wallet addresses/keys masked) and
+// is rendered with textContent only — never innerHTML. The ONLY messages this page sends are the
+// allow-listed spectator.pause / resume / takeover / kill events (by agent name); it can never arm, sign,
+// raise a cap or touch a wallet (no such control exists and the server drops anything off the allow-list).
+(() => {
+  'use strict';
+  const DT = window.DT; DT.page = 'spectator';
+  const $ = (id) => document.getElementById(id);
+  const el = (tag, cls, text) => { const e = document.createElement(tag); if (cls) e.className = cls; if (text != null) e.textContent = String(text); return e; };
+  const ago = (t) => { if (!t) return '—'; 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`; };
+  const age = (s) => (s == null ? '' : s < 60 ? `${Math.round(s)}s old` : s < 3600 ? `${Math.floor(s / 60)}m old` : `${Math.floor(s / 3600)}h old`);
+
+  let vm = null;
+
+  function render() {
+    if (!vm) return;
+
+    const scr = $('screen'); scr.textContent = '';
+    const s = vm.screen || {};
+    scr.appendChild(el('span', 'spec-screen-k', `screen: ${s.screen || '—'}`));
+    if (s.selectedMint) scr.appendChild(el('span', 'spec-screen-dim', ` · token ${s.selectedMint}`));
+    if (s.feed) scr.appendChild(el('span', 'spec-screen-dim', ` · feed ${s.feed}`));
+    if (s.filter) scr.appendChild(el('span', 'spec-screen-dim', ` · filter ${s.filter}`));
+    if (s.highlight) scr.appendChild(el('span', 'spec-screen-dim', ` · ★ ${s.highlight}`));
+    if (vm.control === 'user') scr.appendChild(el('span', 'spec-takeover', ' · YOU HAVE TAKEN OVER'));
+
+    const host = $('agents'); host.textContent = '';
+    if (!vm.agents || !vm.agents.length) host.appendChild(el('div', 'spec-dim', 'no agents connected yet'));
+    for (const a of (vm.agents || [])) {
+      const row = el('div', 'spec-agent' + (a.status !== 'active' ? ' off' : ''));
+      row.appendChild(el('span', 'spec-badge', 'agent'));           // the 'agent' badge
+      row.appendChild(el('span', 'spec-name', a.name));             // textContent — redacted/firewalled, safe
+      if (a.tier) row.appendChild(el('span', 'spec-tier tier-' + a.tier, a.tier));
+      row.appendChild(el('span', 'spec-status status-' + a.status, a.status));
+      row.appendChild(el('span', 'spec-dim', ` · ${ago(a.lastAt)}`));
+      const ctl = el('div', 'spec-ctl');
+      const mk = (label, name, danger) => { const b = el('button', 'spec-btn' + (danger ? ' danger' : ''), label); b.type = 'button'; b.addEventListener('click', () => DT.send({ type: 'event', name, payload: { agent: a.name } })); return b; };
+      if (a.status === 'active') { ctl.appendChild(mk('pause', 'spectator.pause')); ctl.appendChild(mk('take over', 'spectator.takeover')); }
+      else ctl.appendChild(mk('resume', 'spectator.resume'));
+      ctl.appendChild(mk('kill', 'spectator.kill', true));          // panic
+      row.appendChild(ctl);
+      host.appendChild(row);
+    }
+
+    const act = $('activity'); act.textContent = '';
+    for (const r of (vm.activity || []).slice().reverse().slice(0, 80)) {
+      const line = el('div', 'spec-act' + (r.ok ? '' : ' bad') + (r.phase === 'nav' ? ' nav' : ''));
+      line.appendChild(el('span', 'spec-act-t', ago(r.t)));
+      line.appendChild(el('span', 'spec-badge sm', 'agent'));
+      line.appendChild(el('span', 'spec-act-agent', r.agent));
+      line.appendChild(el('span', 'spec-act-phase', r.phase));
+      if (r.tool) line.appendChild(el('span', 'spec-act-tool', r.tool));
+      line.appendChild(el('span', 'spec-act-sum', r.summary || ''));  // textContent — redacted upstream
+      if (r.ms != null) line.appendChild(el('span', 'spec-act-ms', `${Math.round(r.ms)}ms`));
+      if (r.dataAgeSec != null) line.appendChild(el('span', 'spec-act-age', age(r.dataAgeSec)));
+      act.appendChild(line);
+    }
+
+    $('redact').textContent = vm.redacted ? 'redacted' : 'local (full)';
+    const live = (vm.agents || []).filter((a) => a.status === 'active').length;
+    DT.status(`${live} cooking`, live ? 'up' : 'muted');
+  }
+
+  DT.onHello(() => { DT.mountRain('rain'); const r = DT.rain(); if (r) { r.setActivity(0.3); r.setMood('rain'); } });
+  DT.onData((payload) => { vm = payload; render(); });
+  DT.onUpdate(() => { /* spectator is pushed as full `data` frames */ });
+  DT.wireChrome();
+  let lastTick = 0;
+  DT.rainEvery = 2; DT.fpsCap = 30;
+  DT.loop((now) => { if (now - lastTick > 1000) { lastTick = now; if (vm) render(); } });
+  DT.connect();
+})();

package/dist/packages/popup/src/selftest.js

@@ -62,6 +62,25 @@ export function fixtureNarrativeVM() {
         limits: 'model output: none (deterministic lexicon v0.1.0). Name-based: X/Telegram-only narratives are missed; 6 copycat symbols.',
     };
 }
+/** A deterministic, network-free spectator view for the popup self-test / demo (task-1406). Not real agents. */
+export function fixtureSpectatorVM() {
+    const now = Date.now();
+    return {
+        title: 'watch the agent cook', now, redacted: true, control: 'agent',
+        screen: { screen: 'token', selectedMint: 'Fixt…AAAA', feed: 'new', filter: null, highlight: null },
+        agents: [
+            { name: 'claude-code', tier: 'propose', status: 'active', lastAt: now - 1200 },
+            { name: 'scanbot', tier: 'observe', status: 'paused', lastAt: now - 8000 },
+        ],
+        activity: [
+            { seq: 1, t: now - 8000, phase: 'connect', agent: 'claude-code', tier: 'propose', tool: null, summary: 'connected · claude-code 2.1', ms: null, dataAgeSec: null, ok: true, refusal: null },
+            { seq: 2, t: now - 5000, phase: 'nav', agent: 'claude-code', tier: 'propose', tool: 'open_token', summary: 'open Fixt…AAAA', ms: 6, dataAgeSec: null, ok: true, refusal: null },
+            { seq: 3, t: now - 4200, phase: 'result', agent: 'claude-code', tier: 'propose', tool: 'rugcheck', summary: 'rugcheck Fixt…', ms: 42, dataAgeSec: 3, ok: true, refusal: null },
+            { seq: 4, t: now - 2000, phase: 'proposal', agent: 'claude-code', tier: 'propose', tool: 'propose_alert', summary: 'alert when mcap crosses 1M', ms: 2, dataAgeSec: null, ok: true, refusal: null },
+            { seq: 5, t: now - 1000, phase: 'refused', agent: 'scanbot', tier: 'observe', tool: 'arm_plan', summary: 'refused: no agent may do that at any tier', ms: null, dataAgeSec: null, ok: false, refusal: 'never' },
+        ],
+    };
+}
 /** Run the self-test and resolve with the measured result. Always cleans up the window host and server. */
 export async function runSelfTest(opts = {}) {
     const seconds = Math.max(2, Math.min(30, opts.seconds ?? 6));

package/dist/packages/popup/src/server.js

@@ -52,6 +52,8 @@ export const POPUP_EVENTS = new Set([
     'event:roster.pause', 'event:roster.resume', 'event:roster.kick',
     // task-1355 order plans: cancel a plan by id (the ONLY write the plans popup can send — never arm/cap/sign)
     'event:plan.cancel',
+    // task-1406 spectator: pause / resume / take over / kill an agent by name (the only writes this popup sends)
+    'event:spectator.pause', 'event:spectator.resume', 'event:spectator.takeover', 'event:spectator.kill',
 ]);
 /**
  * task-1358 r3: the ONLY messages a pack widget's socket may send — the generic set every popup has. A widget socket
@@ -104,6 +106,10 @@ export function validateEventPayload(name, payload) {
         case 'roster.pause':
         case 'roster.resume':
         case 'roster.kick':
+        case 'spectator.pause':
+        case 'spectator.resume':
+        case 'spectator.takeover':
+        case 'spectator.kill':
             return typeof p.agent === 'string' && ROSTER_AGENT_RE.test(p.agent) ? { agent: p.agent } : null;
         case 'plan.cancel':
             return typeof p.id === 'string' && PLAN_ID_RE.test(p.id) ? { id: p.id } : null;
@@ -117,7 +123,7 @@ export function lwcLogoStyleHash(lwcSource) {
     return m ? `'sha256-${createHash('sha256').update(m[1], 'utf8').digest('base64')}'` : null;
 }
 // (r3) 'widget' is the WRAPPER page — ours, nonce-rendered like the rest; the pack html goes in its iframe
-const PAGE_KINDS = ['chart', 'token', 'feeds', 'bubbles', 'roster', 'narrative', 'plans', 'widget'];
+const PAGE_KINDS = ['chart', 'token', 'feeds', 'bubbles', 'roster', 'narrative', 'plans', 'widget', 'spectator'];
 function b64url(buf) { return buf.toString('base64url'); }
 function safeEq(a, b) {
     const ba = Buffer.from(a), bb = Buffer.from(b);

package/dist/packages/tui/src/keymap.js

@@ -206,6 +206,12 @@ export const DEFAULT_KEYMAP = new Keymap([
     // task-1282 JARVIS voice: push-to-talk toggle (hold not possible in a terminal). Lowercase v is free
     // on every screen; the loop auto-enables voice mode on first use and shows a live mic indicator.
     { keys: ['v'], action: 'voice.talk', label: 'voice' },
+    // task-1411: in-voice controls (loop-handled; only act while voice is on). `m` mute, `,` change voice,
+    // `<`/`>` slow down / speed up the spoken reply (saved to config.voice.rate). Per-screen `m` bindings
+    // (kol/bubbles/follows) override this global one on those screens, exactly like `voice.talk`.
+    { keys: ['m'], action: 'voice.mute', label: 'mute voice' },
+    { keys: [','], action: 'voice.cycle', label: 'change voice' },
+    { keys: ['<', '>'], action: 'voice.rate', label: 'slower / faster voice' },
     // task-1311: `i` focuses the chat input on the token / analyst screens (QA B1–B3); the loop only
     // captures keystrokes into the input while it is focused, so the number keys and `q` never type.
     { keys: ['i'], action: 'input.focus', label: 'ask', screen: 'token' },
@@ -217,6 +223,10 @@ export const DEFAULT_KEYMAP = new Keymap([
     { keys: ['$'], action: 'display.priceMode', label: 'price ⇄ mcap' },
     // task-1401: `E` exports the current view (PNG + text report, local only). Free on every screen.
     { keys: ['E'], action: 'export.view', label: 'export PNG + report' },
+    // task-1407: `H` (free capital everywhere) opens the PnL card preview on the screens that have fills to card.
+    { keys: ['H'], action: 'pnl.card', label: 'PnL card (share)', screen: 'token' },
+    { keys: ['H'], action: 'pnl.card', label: 'PnL card (share)', screen: 'positions' },
+    { keys: ['H'], action: 'pnl.card', label: 'PnL card (share)', screen: 'follows' },
     { keys: ['/'], action: 'filter.edit', label: 'filter', screen: 'screener' },
     { keys: ['\\'], action: 'filter.clear', label: 'clear filter', screen: 'screener' },
     { keys: ['s'], action: 'sort.menu', label: 'sort', screen: 'screener' },

package/dist/packages/voice/src/controller.js

@@ -5,7 +5,13 @@
 // listen() is called — so the on-screen indicator and the real mic state can never disagree.
 import { route, isSafe } from "./router.js";
 import { spokenSummary } from "./summary.js";
+import { speakable } from "./speakable.js";
 import { isBannedVoice } from "./tts/voices.js";
+import { DEFAULT_RATE } from "./tts/say.js";
+/** Live rate-nudge bounds and step (task-1411, the < / > keys). Clamped so a voice stays intelligible. */
+export const RATE_MIN = 120;
+export const RATE_MAX = 320;
+export const RATE_STEP = 15;
 export class VoiceController {
     stt;
     tts;
@@ -44,7 +50,7 @@ export class VoiceController {
         this.tts = opts.tts;
         this.muted = opts.muted ?? false;
         this.voice = opts.voice ?? null;
-        this.rate = opts.rate ?? 190;
+        this.rate = opts.rate ?? DEFAULT_RATE;
         this.pitch = opts.pitch;
         this.now = opts.now ?? (() => Date.now());
         this.maxListenMs = opts.maxListenMs ?? 15_000;
@@ -99,6 +105,12 @@ export class VoiceController {
         this.message = this.stt ? null : 'voice-in unavailable on this machine — type questions; replies are still spoken';
         this.setMode('idle');
         void this.loadVoices();
+        // task-1416: pre-load the TTS engine (Piper loads its model into a standby process) so the first
+        // reply starts speaking quickly. A no-op for engines that stream from spawn (`say`).
+        try {
+            this.tts?.warmup?.(this.rate);
+        }
+        catch { /* warm-up is best-effort; never break enabling voice */ }
     }
     disable() {
         if (!this.enabled)
@@ -107,6 +119,10 @@ export class VoiceController {
         this.stopSpeaking();
         this.enabled = false;
         this.pendingLatency = null;
+        try {
+            this.tts?.dispose?.();
+        }
+        catch { /* best-effort cleanup */ }
         this.setMode('off');
     }
     toggle() { this.enabled ? this.disable() : this.enable(); }
@@ -279,6 +295,9 @@ export class VoiceController {
     }
     /** Low-level speak: stops any current reply, then reads `text`. Muted → skip audio but update state. */
     speak(text) {
+        // Speak like a trader (task-1411): no digit-by-digit tiny prices, big numbers in human words,
+        // natural percents. Applied to EVERY spoken line so an ack or an analyst answer never reads raw.
+        text = speakable(text);
         this.lastSay = text;
         if (!this.tts || this.muted) {
             // Still resolve the latency sample (the "spoken word" is just suppressed) so the table is complete.
@@ -386,6 +405,28 @@ export class VoiceController {
     }
     currentVoice() { return this.voice; }
     availableVoices() { return this.voices.slice(); }
+    /** The current speaking rate (words-per-minute-ish), for the status line / help. */
+    currentRate() { return this.rate; }
+    /**
+     * Nudge the speaking rate by `steps` × RATE_STEP (— for slower, + for faster), clamp it, persist it,
+     * and surface it on the status line (task-1411: the < / > keys). Takes effect on the next reply; it
+     * does not restart a line already in flight. A no-op when the rate is already at the clamp.
+     */
+    nudgeRate(steps) {
+        const next = Math.max(RATE_MIN, Math.min(RATE_MAX, this.rate + steps * RATE_STEP));
+        if (next === this.rate) {
+            this.message = `voice rate ${this.rate} wpm (${next <= RATE_MIN ? 'slowest' : 'fastest'})`;
+            this.notify();
+            return;
+        }
+        this.rate = next;
+        this.message = `voice rate ${this.rate} wpm`;
+        try {
+            this.opts.onRateChange?.(this.rate);
+        }
+        catch { /* persistence is best-effort; never break the UI */ }
+        this.notify();
+    }
     /** A compact latency report for the handoff / `--latency` demo. */
     report() {
         const paths = ['instant', 'analyst'];

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

@@ -71,26 +71,43 @@ export function voiceDoctor(deps) {
         }
         return checks;
     }
-    // Speech OUT — macOS say.
+    // Speech OUT — Piper neural (the default when set up, task-1416) → macOS `say` (fallback) → text.
+    const macPiperReady = !!deps.piperPresent && !!deps.piperVoicePresent && !!deps.playerName;
+    if (macPiperReady) {
+        checks.push({
+            name: 'Voice out (Piper)', status: 'pass',
+            detail: `neural British voice is the default — en_GB-alan-medium, plays via ${deps.playerName} (local, no key); fallback: macOS \`say\``,
+        });
+    }
     if (deps.sayAvailable) {
-        checks.push({ name: 'Voice out (say)', status: 'pass', detail: `macOS \`say\` ready · ${deps.voiceCount} voice${deps.voiceCount === 1 ? '' : 's'} (press the voice key, then cycle the voice)` });
-        // Which voice speaks, and why — so a machine can never silently use a novelty/odd system voice (task-1393).
+        const role = macPiperReady ? 'the fallback if Piper is removed' : 'the default — press the voice key, then cycle the voice';
+        checks.push({ name: macPiperReady ? 'Voice out (say, fallback)' : 'Voice out (say)', status: 'pass', detail: `macOS \`say\` ready · ${deps.voiceCount} voice${deps.voiceCount === 1 ? '' : 's'} · ${role}` });
+        // Which `say` voice speaks, and why — so a machine can never silently use a novelty/odd system voice (task-1393).
+        const voiceLabel = macPiperReady ? 'Fallback voice' : 'Default voice';
         if (deps.resolvedVoice) {
-            checks.push({ name: 'Default voice', status: 'pass', detail: `${deps.resolvedVoiceReason ?? deps.resolvedVoice} · , changes it` });
+            checks.push({ name: voiceLabel, status: 'pass', detail: `${deps.resolvedVoiceReason ?? deps.resolvedVoice} · , changes it` });
         }
         else if (deps.resolvedVoice === null) {
             checks.push({
-                name: 'Default voice', status: 'warn',
+                name: voiceLabel, status: 'warn',
                 detail: deps.resolvedVoiceReason ?? 'no safe voice installed — spoken replies are off (text still works)',
                 fix: 'Install a British male voice in System Settings → Accessibility → Spoken Content → System Voice → Manage Voices (Daniel, English (UK)); the Enhanced/Premium download sounds best.',
             });
         }
+        // Offer the higher-quality neural voice when it is not set up yet (never silent; the user decides).
+        if (!macPiperReady) {
+            checks.push({
+                name: 'Neural voice (Piper)', status: 'warn',
+                detail: 'a higher-quality neural British voice is available but not set up; `say` is speaking for now',
+                fix: 'Run `dexterm voice setup` to install it (asks first; a private Python runtime + a ~61 MB checksum-verified model; runs offline after, `dexterm voice uninstall` removes it).',
+            });
+        }
     }
-    else {
+    else if (!macPiperReady) {
         checks.push({
-            name: 'Voice out (say)', status: 'warn',
+            name: 'Voice out', status: 'warn',
             detail: 'macOS `say` not found; spoken replies are off, the analyst still answers in text',
-            fix: '`say` ships with macOS — if it is missing, reinstall the Command Line Tools (`xcode-select --install`).',
+            fix: '`say` ships with macOS — if it is missing, reinstall the Command Line Tools (`xcode-select --install`). Or set up the neural voice: `dexterm voice setup`.',
         });
     }
     // Speech IN — Apple Speech (preferred) or whisper (fallback).

package/dist/packages/voice/src/engines.js

@@ -62,8 +62,15 @@ export async function selectTts(choice = process.env.DEXTERM_VOICE_TTS || 'auto'
         const e = new EspeakTts(espeakVoiceFor(configuredVoice) ?? undefined);
         return (await e.available()) ? e : null;
     }
-    // On macOS, prefer `say`. Off macOS, `say` does not exist — use the portable engines below.
+    // On macOS, prefer Piper alan (neural) when the managed runtime is installed (task-1416:
+    // `dexterm voice setup` → venv + model + afplay), else the built-in `say`. Off macOS, `say` does not
+    // exist — use the portable engines below. An explicit `choice==='say'` always skips Piper.
     if (choice === 'say' || (choice === 'auto' && process.platform === 'darwin')) {
+        if (choice === 'auto') {
+            const piperMac = new PiperTts();
+            if (await piperMac.available())
+                return piperMac;
+        }
         const probe = new SayTts();
         if (choice === 'auto' && !(await probe.available()))
             return null;

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

@@ -6,13 +6,15 @@
 export * from "./types.js";
 export { route, isSafe } from "./router.js";
 export { spokenSummary, splitSentences } from "./summary.js";
+export { speakable, humanizeNumber } from "./speakable.js";
 export { VoiceController } from "./controller.js";
 export { selectStt, selectTts, resolveSayVoice } from "./engines.js";
 export { voiceDoctor } from "./doctor.js";
 export { resolveVoice, isBannedVoice, normalizeVoiceName, parseSayVoices, sanitizeSpeech, BANNED_VOICE_NAMES, BRITISH_MALE_PREFERENCE, MAX_SPEAK_CHARS, VOICE_STYLE_DEFAULTS, voiceStyleDefaults, } from "./tts/voices.js";
 export { SayTts, DEFAULT_RATE } from "./tts/say.js";
 export { EspeakTts, DEFAULT_ESPEAK_VOICE, resolveEspeakBin, espeakVoiceFor } from "./tts/espeak.js";
-export { PiperTts, DEFAULT_PIPER_VOICE, PIPER_MODEL, PIPER_PLAYERS, resolvePiperBin, pickPlayer } from "./tts/piper.js";
+export { PiperTts, DEFAULT_PIPER_VOICE, PIPER_MODEL, PIPER_PLAYERS, resolvePiperBin, resolvePiperRuntime, managedVenvPython, pickPlayer, } from "./tts/piper.js";
+export { setupPiperRuntime, uninstallPiperRuntime, piperRuntimeStatus, piperRuntimePaths, readRuntimeRecord, detectPython, parsePythonVersion, pythonVersionOk, pythonFixLine, PIPER_PYPI_VERSION, MIN_PYTHON, DEFAULT_PYTHON_CANDIDATES, } from "./tts/piper-setup.js";
 export { FakeTts } from "./tts/fake.js";
 export { WhisperStt, WHISPER_MODEL, WHISPER_MODEL_DIR, pickRecorder } from "./stt/whisper.js";
 export { modelRegistry, downloadModel, modelStatus, specSizeMB, } from "./download.js";

package/dist/packages/voice/src/speakable.js

@@ -0,0 +1,111 @@
+// Make a line "speakable" like a trader, not digit by digit (task-1411). A tester heard Jarvis read a raw
+// per-token price ("zero point zero zero zero zero zero two nine") and big raw numbers, which sounds
+// crazy. This normaliser runs on EVERY spoken line (controller.speak) and applies these rules, in order:
+//
+//   1. Tiny per-token prices are NEVER read digit by digit. A sub-cent decimal ($0.0000029), the app's
+//      own subscript rendering ($0.0₅29), or any value below a cent becomes the coin's MARKET CAP when
+//      the line (or the caller) knows it, else the phrase "a tiny price". We NEVER invent a number.
+//      A sub-cent value that is an AMOUNT of something (e.g. "0.005 SOL", "0.0025 SOL fee") is left
+//      alone — it is a quantity, not a per-token price.
+//   2. Big raw numbers become human words: 340000 → "340 thousand", 1200000 → "1.2 million",
+//      4500000000 → "4.5 billion". Word boundaries keep digits inside an address untouched, and a bare
+//      4-digit YEAR (1900–2099) is left as-is so "launched in 2024" never reads "launched in 2 thousand".
+//   3. Percentages read naturally: "12%" → "12 percent".
+//
+// Pure and dependency-free so every rule is unit-tested without spawning a voice.
+const SUBSCRIPT = '₀₁₂₃₄₅₆₇₈₉'; // ₀..₉
+// Units that follow a small decimal and mark it as an AMOUNT, not a per-token price (so "0.005 SOL" is
+// a quantity we read normally). Case-insensitive, whole word.
+const AMOUNT_UNIT = /^\s*(sol|eth|btc|usdc|usdt|tokens?|coins?)\b/i;
+/** Round to one decimal and drop a trailing ".0" so "1.0 million" reads "1 million". */
+function trimNum(n) {
+    const r = Math.round(n * 10) / 10;
+    return (Number.isInteger(r) ? String(r) : r.toFixed(1));
+}
+/** A raw number (>= 1000) as human words: "340 thousand", "1.2 million", "4.5 billion". */
+export function humanizeNumber(n) {
+    const abs = Math.abs(n);
+    if (abs >= 1e9)
+        return `${trimNum(n / 1e9)} billion`;
+    if (abs >= 1e6)
+        return `${trimNum(n / 1e6)} million`;
+    if (abs >= 1e3)
+        return `${trimNum(n / 1e3)} thousand`;
+    return trimNum(n);
+}
+/** A number is a 4-digit calendar year (1900–2099): spoken as-is, never "2 thousand twenty four". */
+function isYear(v) {
+    return Number.isInteger(v) && v >= 1900 && v <= 2099;
+}
+/**
+ * Read a market cap out of the analyst line, e.g. "market cap $340K", "mcap of 1.2M", "cap: 340000",
+ * returned as a human phrase ("340 thousand"). The brief: a tiny price is replaced WITH THE COIN'S
+ * MARKET CAP WHEN THE ANALYST TEXT INCLUDES IT. Returns null when the line names no market cap.
+ */
+function marketCapFromText(text) {
+    const m = /\b(?:market\s*cap|mcap|m\.?c\.?|cap)\b[^$\d]{0,8}\$?([\d,]+(?:\.\d+)?)\s*([KkMmBb])?\b/.exec(text);
+    if (!m)
+        return null;
+    let v = parseFloat(m[1].replace(/,/g, ''));
+    if (!Number.isFinite(v))
+        return null;
+    const suf = m[2];
+    if (suf)
+        v *= /[Kk]/.test(suf) ? 1e3 : /[Mm]/.test(suf) ? 1e6 : 1e9;
+    if (v < 1000)
+        return null; // "cap 2 holders" etc. is not a market cap
+    return humanizeNumber(v);
+}
+/**
+ * Normalise a spoken line. `opts.marketCap`, when given, is the human market-cap phrase substituted for
+ * a tiny per-token price; otherwise speakable reads a market cap out of the line, and failing that uses
+ * "a tiny price" (never a made-up number).
+ */
+export function speakable(text, opts = {}) {
+    let s = String(text ?? '');
+    const mcap = (opts.marketCap && opts.marketCap.trim()) || marketCapFromText(s);
+    const tiny = mcap ? `a market cap of ${String(mcap).trim()}` : 'a tiny price';
+    // 1a. Subscript price forms the app renders, e.g. "$0.0₅29" / "0.0₄1686" — never read the digits.
+    s = s.replace(new RegExp(`\\$?\\d*\\.?\\d*[${SUBSCRIPT}]+[${SUBSCRIPT}0-9]*`, 'g'), tiny);
+    // 1b. Sub-cent decimal prices, e.g. "$0.0000029", "0.00004". A value below a cent is a per-token price,
+    //     not an amount; the leading-zeros case (>=2 zeros after the point) is always a price — UNLESS it
+    //     is immediately followed by a unit word (SOL/ETH/tokens…), in which case it is an AMOUNT: leave it.
+    s = s.replace(/\$?\d*\.\d+/g, (m, idx, full) => {
+        const v = parseFloat(m.replace(/[$,]/g, ''));
+        if (!Number.isFinite(v))
+            return m;
+        const after = full.slice(idx + m.length);
+        if (AMOUNT_UNIT.test(after))
+            return m; // "0.005 SOL" is a quantity, not a per-token price
+        if (/\.0{2,}/.test(m) || (v > 0 && v < 0.01))
+            return tiny;
+        return m;
+    });
+    // 2. Percentages read as words before the big-number pass (so "12%" isn't seen as a bare number).
+    s = s.replace(/(\d+(?:\.\d+)?)\s*%/g, '$1 percent');
+    // 2b. Abbreviated magnitudes the app and analysts use: "$340K" / "2.1M" / "4.5B" → words. Lowercase
+    //     "m" is intentionally EXCLUDED: "15m" / "6h" are a token's AGE (minutes), not millions.
+    s = s.replace(/\$?(\d+(?:\.\d+)?)\s*([KkMBb])\b/g, (_m, num, suf) => {
+        const word = /[Kk]/.test(suf) ? 'thousand' : suf === 'M' ? 'million' : 'billion';
+        return `${num} ${word}`;
+    });
+    // 3. Big raw numbers -> human words. `\b` keeps runs of digits inside an address/word untouched, and a
+    //    number already followed by a scale word (k/m/b/thousand/…) or "percent" is left alone, as is a
+    //    bare 4-digit year.
+    s = s.replace(/\$?\b\d{1,3}(?:,\d{3})+(?:\.\d+)?\b|\$?\b\d{4,}(?:\.\d+)?\b/g, (m, ...rest) => {
+        const full = rest[rest.length - 1]; // the whole input string
+        const idx = rest[rest.length - 2];
+        const after = full.slice(idx + m.length).trimStart().toLowerCase();
+        if (/^(k|m|b|bn|thousand|million|billion|percent|%)\b/.test(after))
+            return m;
+        const v = parseFloat(m.replace(/[$,]/g, ''));
+        if (!Number.isFinite(v) || Math.abs(v) < 1000)
+            return m;
+        // A bare 4-digit year ("launched in 2024") stays a year; a dollar-prefixed or comma-grouped number
+        // ("$2024", "2,024") is a real amount and is humanised.
+        if (isYear(v) && !/[$,]/.test(m))
+            return m;
+        return humanizeNumber(v);
+    });
+    return s;
+}

package/dist/packages/voice/src/stt/whisper.js

@@ -39,9 +39,11 @@ export function pickRecorder() {
 }
 /** Synchronous PATH check without spawning (cheap; used by available() and pickRecorder). */
 function which(bin) {
-    const paths = (process.env.PATH ?? '').split(':');
+    // Windows (task-1423): `;`-separated PATH and `.exe` binaries, same rule as piper.ts's which()
+    const win = process.platform === 'win32';
+    const paths = (process.env.PATH ?? '').split(win ? ';' : ':');
     for (const p of paths) {
-        if (p && existsSync(join(p, bin)))
+        if (p && (existsSync(join(p, bin)) || (win && existsSync(join(p, `${bin}.exe`)))))
             return true;
     }
     return false;