dexterm-cli 0.1.1 → 0.1.2

package/dist/packages/cli/src/alerts/index.js

@@ -0,0 +1,10 @@
+// dexterm — alert delivery subsystem (task-1398). See DESIGN.md.
+export * from "./types.js";
+export * from "./format.js";
+export * from "./route.js";
+export * from "./creds.js";
+export * from "./notifier.js";
+export { createToastAdapter } from "./adapters/toast.js";
+export { createDesktopAdapter } from "./adapters/desktop.js";
+export { createTelegramAdapter } from "./adapters/telegram.js";
+export { createDiscordAdapter } from "./adapters/discord.js";

package/dist/packages/cli/src/alerts/notifier.js

@@ -0,0 +1,53 @@
+import { CHANNELS } from "./types.js";
+import { routeChannels } from "./route.js";
+import { redactCreds, readTelegramCreds, readDiscordCreds } from "./creds.js";
+import { createToastAdapter } from "./adapters/toast.js";
+import { createDesktopAdapter } from "./adapters/desktop.js";
+import { createTelegramAdapter } from "./adapters/telegram.js";
+import { createDiscordAdapter } from "./adapters/discord.js";
+export function createNotifier(cfg, adapters) {
+    return {
+        async deliver(d) {
+            const results = [];
+            for (const name of routeChannels(cfg, d)) {
+                const ad = adapters[name];
+                if (!ad) {
+                    results.push({ channel: name, ok: false, skipped: true, reason: 'no adapter' });
+                    continue;
+                }
+                if (!ad.available()) {
+                    results.push({ channel: name, ok: false, skipped: true, reason: `${name} not configured` });
+                    continue;
+                }
+                try {
+                    results.push({ channel: name, ...(await ad.deliver(d)) });
+                }
+                catch (e) {
+                    results.push({ channel: name, ok: false, reason: redactCreds(e.message) });
+                }
+            }
+            return results;
+        },
+        readyChannels(level) {
+            const probe = { kind: 'alert', level: level ?? 'info' };
+            return routeChannels(cfg, probe).filter((n) => adapters[n]?.available());
+        },
+    };
+}
+/** Build a Notifier with the real adapters: toast + desktop + telegram/discord read from ~/.dexterm. */
+export function buildNotifier(home, cfg, deps) {
+    const adapters = {
+        toast: createToastAdapter(deps.toastSink),
+        desktop: createDesktopAdapter(deps.desktop),
+        telegram: createTelegramAdapter({ creds: readTelegramCreds(home), fetch: deps.fetch }),
+        discord: createDiscordAdapter({ creds: readDiscordCreds(home), fetch: deps.fetch }),
+    };
+    return createNotifier(cfg, adapters);
+}
+/** True when config enables at least one PUSH channel (desktop/telegram/discord) — i.e. a Notifier is worth building. */
+export function hasPushChannel(cfg) {
+    const ch = cfg?.channels;
+    if (!ch)
+        return false;
+    return CHANNELS.filter((c) => c !== 'toast').some((c) => ch[c]?.enabled === true);
+}

package/dist/packages/cli/src/alerts/route.js

@@ -0,0 +1,19 @@
+import { CHANNELS } from "./types.js";
+/** The channels a delivery is routed to, given config. Pure; order is CHANNELS order. */
+export function routeChannels(cfg, d) {
+    if (d.kind === 'proposal' && !cfg?.proposals)
+        return [];
+    const channels = cfg?.channels ?? {};
+    const out = [];
+    for (const name of CHANNELS) {
+        const c = channels[name];
+        const enabled = name === 'toast' ? c?.enabled !== false : c?.enabled === true;
+        if (!enabled)
+            continue;
+        const levels = c?.levels;
+        if (levels && levels.length > 0 && !levels.includes(d.level))
+            continue;
+        out.push(name);
+    }
+    return out;
+}

package/dist/packages/cli/src/alerts/types.js

@@ -0,0 +1 @@
+export const CHANNELS = ['toast', 'desktop', 'telegram', 'discord'];

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

@@ -0,0 +1,212 @@
+// dexterm — `dexterm alerts …` (task-1398): configure WHERE rule alerts are delivered. No model, and the
+// only network is an explicit `dexterm alerts test`. Enable flags + the per-channel `levels` filter live in
+// config.json (user-only path); the Telegram bot token / Discord webhook URL are SECRETS and never touch
+// config.json, argv or a log — they come from an env var or stdin and are written to ~/.dexterm/<channel>.json
+// (0600). The command echoes only how many characters were stored, never the value.
+//
+//   dexterm alerts [status] | enable|disable <toast|desktop|telegram|discord> | levels <channel> <list|all>
+//                  | proposals <on|off> | set-telegram --chat <id> | set-discord | unset-telegram|unset-discord | test [channel]
+import { dextermHome, loadConfig, applyAndJournal } from '../../custom/src/index.js';
+import { readTelegramCreds, writeTelegramCreds, readDiscordCreds, writeDiscordCreds, telegramCredsPath, discordCredsPath, credsMode, } from "./alerts/creds.js";
+import { buildNotifier } from "./alerts/notifier.js";
+import { CHANNELS } from "./alerts/types.js";
+import { unlinkSync } from 'node:fs';
+export const ALERTS_USAGE = `usage: dexterm alerts [status]
+       dexterm alerts enable|disable <toast|desktop|telegram|discord>
+       dexterm alerts levels <channel> <up,down,info,warn | all>
+       dexterm alerts proposals <on|off>
+       dexterm alerts set-telegram --chat <id>   (token from $DEXTERM_TELEGRAM_TOKEN or stdin; never on argv)
+       dexterm alerts set-discord                (webhook from $DEXTERM_DISCORD_WEBHOOK or stdin; never on argv)
+       dexterm alerts unset-telegram | unset-discord
+       dexterm alerts test [channel]             (send a sample alert through the enabled channels)
+
+  Credentials are stored in ~/.dexterm/telegram.json / discord.json (0600), never in config.json or a log.
+`;
+const LEVELS = ['up', 'down', 'info', 'warn'];
+const isChannel = (s) => CHANNELS.includes(s);
+/** Read a secret from an env var, else one line of stdin. Never printed. Returns null when neither is available. */
+async function defaultReadSecret(io, envVar) {
+    const fromEnv = io.env[envVar];
+    if (typeof fromEnv === 'string' && fromEnv.trim())
+        return fromEnv.trim();
+    const stdin = io.stdin;
+    if (!stdin || stdin.isTTY) {
+        io.stderr.write(`dexterm alerts: set ${envVar} or pipe the value on stdin (never pass a secret on the command line)\n`);
+        return null;
+    }
+    return new Promise((resolve) => {
+        let buf = '';
+        stdin.setEncoding('utf8');
+        stdin.on('data', (c) => { buf += c; });
+        stdin.on('end', () => resolve(buf.split('\n')[0].trim() || null));
+        stdin.on('error', () => resolve(null));
+    });
+}
+/** Patch config.alerts as a whole (so a missing /alerts section is created, not a missing-parent error). */
+function setAlerts(home, mutate, why) {
+    const loaded = loadConfig(home);
+    const cur = loaded.config.alerts ? structuredClone(loaded.config.alerts) : {};
+    const next = mutate(cur);
+    const op = loaded.config.alerts === undefined ? 'add' : 'replace';
+    const { config } = applyAndJournal(home, [{ op, path: '/alerts', value: next }], { actor: 'user', why });
+    return config;
+}
+function renderStatus(home, cfg, io) {
+    io.stdout.write('alerts — delivery channels\n');
+    const ch = cfg?.channels ?? {};
+    for (const name of CHANNELS) {
+        const c = ch[name];
+        const on = name === 'toast' ? c?.enabled !== false : c?.enabled === true;
+        const levels = c?.levels && c.levels.length ? ` [${c.levels.join(',')}]` : '';
+        let detail = '';
+        if (name === 'telegram') {
+            const creds = readTelegramCreds(home);
+            detail = creds ? ` chat ${creds.chatId}, token set` : ' (no token — set-telegram)';
+        }
+        else if (name === 'discord') {
+            const creds = readDiscordCreds(home);
+            detail = creds ? ' webhook set' : ' (no webhook — set-discord)';
+        }
+        else if (name === 'desktop')
+            detail = process.platform === 'darwin' ? ' (osascript)' : process.platform === 'linux' ? ' (notify-send)' : ' (unsupported OS)';
+        io.stdout.write(`  ${on ? '●' : '○'} ${name.padEnd(9)}${on ? 'on ' : 'off'}${levels}${detail}\n`);
+    }
+    io.stdout.write(`  proposals: ${cfg?.proposals ? 'delivered' : 'in-app only'}\n`);
+    for (const [label, p] of [['telegram.json', telegramCredsPath(home)], ['discord.json', discordCredsPath(home)]]) {
+        const mode = credsMode(p);
+        if (mode !== null && mode !== 0o600)
+            io.stdout.write(`  ⚠ ${label} is mode 0${mode.toString(8)} (should be 0600; chmod 600 it)\n`);
+    }
+}
+export async function alertsCommand(argv, io, deps = {}) {
+    const home = dextermHome(io.env);
+    const cmd = argv[0] ?? 'status';
+    if (cmd === '--help' || cmd === '-h') {
+        io.stdout.write(ALERTS_USAGE);
+        return 0;
+    }
+    try {
+        switch (cmd) {
+            case 'status':
+                renderStatus(home, loadConfig(home).config.alerts, io);
+                return 0;
+            case 'enable':
+            case 'disable': {
+                const name = argv[1];
+                if (!name || !isChannel(name)) {
+                    io.stderr.write(`dexterm alerts: ${cmd} <${CHANNELS.join('|')}>\n`);
+                    return 2;
+                }
+                const on = cmd === 'enable';
+                if (on && name === 'telegram' && !readTelegramCreds(home))
+                    io.stderr.write('note: telegram has no token yet — run `dexterm alerts set-telegram --chat <id>`\n');
+                if (on && name === 'discord' && !readDiscordCreds(home))
+                    io.stderr.write('note: discord has no webhook yet — run `dexterm alerts set-discord`\n');
+                setAlerts(home, (a) => { const ch = { ...(a.channels ?? {}) }; ch[name] = { ...(ch[name] ?? {}), enabled: on }; return { ...a, channels: ch }; }, `${cmd} alerts ${name}`);
+                io.stdout.write(`${name} ${on ? 'enabled' : 'disabled'}\n`);
+                return 0;
+            }
+            case 'levels': {
+                const name = argv[1];
+                const spec = argv[2];
+                if (!name || !isChannel(name) || !spec) {
+                    io.stderr.write('dexterm alerts: levels <channel> <up,down,info,warn | all>\n');
+                    return 2;
+                }
+                let levels;
+                if (spec !== 'all') {
+                    const parts = spec.split(',').map((s) => s.trim()).filter(Boolean);
+                    const bad = parts.filter((p) => !LEVELS.includes(p));
+                    if (bad.length || !parts.length) {
+                        io.stderr.write(`dexterm alerts: bad levels "${spec}" (use ${LEVELS.join(',')} or all)\n`);
+                        return 2;
+                    }
+                    levels = parts;
+                }
+                setAlerts(home, (a) => { const ch = { ...(a.channels ?? {}) }; const c = { ...(ch[name] ?? {}) }; if (levels)
+                    c.levels = levels;
+                else
+                    delete c.levels; ch[name] = c; return { ...a, channels: ch }; }, `alerts levels ${name}`);
+                io.stdout.write(`${name} levels: ${levels ? levels.join(',') : 'all'}\n`);
+                return 0;
+            }
+            case 'proposals': {
+                const v = argv[1];
+                if (v !== 'on' && v !== 'off') {
+                    io.stderr.write('dexterm alerts: proposals <on|off>\n');
+                    return 2;
+                }
+                setAlerts(home, (a) => ({ ...a, proposals: v === 'on' }), `alerts proposals ${v}`);
+                io.stdout.write(`proposal delivery ${v === 'on' ? 'on' : 'off'}\n`);
+                return 0;
+            }
+            case 'set-telegram': {
+                const ci = argv.indexOf('--chat');
+                const chatId = ci >= 0 ? argv[ci + 1] : undefined;
+                if (!chatId) {
+                    io.stderr.write('dexterm alerts: set-telegram --chat <id>\n');
+                    return 2;
+                }
+                const token = await (deps.readSecret ? deps.readSecret('telegram bot token') : defaultReadSecret(io, 'DEXTERM_TELEGRAM_TOKEN'));
+                if (!token)
+                    return 2;
+                writeTelegramCreds(home, { token, chatId });
+                io.stdout.write(`telegram token stored (${token.length} chars) for chat ${chatId} in ~/.dexterm/telegram.json (0600)\n`);
+                return 0;
+            }
+            case 'set-discord': {
+                const webhook = await (deps.readSecret ? deps.readSecret('discord webhook url') : defaultReadSecret(io, 'DEXTERM_DISCORD_WEBHOOK'));
+                if (!webhook)
+                    return 2;
+                writeDiscordCreds(home, { webhook });
+                io.stdout.write(`discord webhook stored (${webhook.length} chars) in ~/.dexterm/discord.json (0600)\n`);
+                return 0;
+            }
+            case 'unset-telegram': {
+                try {
+                    unlinkSync(telegramCredsPath(home));
+                }
+                catch { /* ignore */ }
+                io.stdout.write('telegram credentials removed\n');
+                return 0;
+            }
+            case 'unset-discord': {
+                try {
+                    unlinkSync(discordCredsPath(home));
+                }
+                catch { /* ignore */ }
+                io.stdout.write('discord credentials removed\n');
+                return 0;
+            }
+            case 'test': {
+                const only = argv[1];
+                if (only && !isChannel(only)) {
+                    io.stderr.write(`dexterm alerts: test [<${CHANNELS.join('|')}>]\n`);
+                    return 2;
+                }
+                const cfg = loadConfig(home).config.alerts;
+                const notifier = deps.notifier ?? buildNotifier(home, cfg, { toastSink: (line) => io.stdout.write(`toast: ${line}\n`) });
+                const sample = {
+                    kind: 'alert', level: 'info', title: 'dexterm ⚑ test', body: 'alert delivery test — if you see this, the channel works.',
+                    spoken: 'dexterm test alert', symbol: 'dexterm', mint: '', source: 'user', rule: 'alerts-test', at: Date.now(),
+                };
+                const results = await notifier.deliver(sample);
+                const shown = only ? results.filter((r) => r.channel === only) : results;
+                if (!shown.length) {
+                    io.stdout.write('no channel routed this alert (enable one first)\n');
+                    return 0;
+                }
+                for (const r of shown)
+                    io.stdout.write(`  ${r.ok ? '✓' : r.skipped ? '–' : '✗'} ${r.channel}${r.reason ? `: ${r.reason}` : ''}\n`);
+                return shown.every((r) => r.ok || r.skipped) ? 0 : 1;
+            }
+            default:
+                io.stderr.write(`dexterm alerts: unknown subcommand "${cmd}"\n\n${ALERTS_USAGE}`);
+                return 2;
+        }
+    }
+    catch (e) {
+        io.stderr.write(`dexterm alerts: ${e.message}\n`);
+        return 1;
+    }
+}

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

@@ -1,14 +1,26 @@
-import { defaultDbPath } from '../../data/src/index.js';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { defaultDbPath, LINK_RUBRIC_V0, DEFAULT_LINK_RUBRIC } from '../../data/src/index.js';
 import { exportRecorded, openHistoryReadOnly, readLarpJoin } from '../../recorder/src/index.js';
-import { runBacktest, h1Model, larpEval, renderLarpEvalText } from '../../packs/src/index.js';
+import { runBacktest, h1Model, larpEval, renderLarpEvalText, skillBacktest, renderSkillBacktestText, tuneLinkRubric, tuneRugRules, RUG_RULES_V0, RUG_RULES_V1, SKILL_EVAL_SCHEMA, } from '../../packs/src/index.js';
+import { buildSkillEvalSet } from "./skill-eval-build.js";
+/** task-1401: the committed eval set the skill backtest reads by default. */
+export const DEFAULT_SKILL_EVAL = fileURLToPath(new URL('../../packs/eval/skills-eval.json', import.meta.url));
 const HORIZONS = [3600, 7200, 21600, 86400, 259200];
 export const BACKTEST_HELP = `dexterm backtest: score the rug model against recorded outcomes (task-1356). No network, no model.
 
   dexterm backtest [--subject heuristic|pack_verdicts|larp] [--horizon SEC] [--db PATH] [--json]
+  dexterm backtest --subject skills [--eval FILE] [--tune] [--report FILE] [--json]
+  dexterm backtest --build-eval FILE [--db PATH] [--horizon SEC] [--max-lag SEC]
 
   --subject   heuristic (default, the pre-registered H1 rug model), pack_verdicts (recorded pack rug_p), or
               larp (task-1359: recorded LARP-detector verdicts vs the outcome labels; counts only below
               50 matched verdicts, 95% Wilson intervals above; agreement with bad outcomes, not ground truth).
+  skills      task-1401: the default analyst skills' replayable rules over the recorded eval set (the LARP
+              check's links-only baseline, the rug-check verdict rules), per-grade precision/recall on a train
+              and a held-out TEST split. Default eval: packages/packs/eval/skills-eval.json. --tune re-tunes on
+              the train split only and prints before (v0) vs tuned; --report writes the JSON report.
+  --build-eval  build that eval set from a recorder DB (read-only; no network; no URLs or names written).
   --horizon   outcome horizon in seconds: ${HORIZONS.join(', ')} (default 3600 = 1h).
   --json      print the full result object instead of the human table.
   --db        defaults to DEXTERM_DB_PATH, else ~/.local/share/dexterm/dexterm.db.
@@ -25,7 +37,7 @@ function parse(argv) {
             continue;
         const k = a.slice(2);
         const v = argv[i + 1];
-        if (v !== undefined && !v.startsWith('--') && k !== 'json') {
+        if (v !== undefined && !v.startsWith('--') && k !== 'json' && k !== 'tune') {
             opts[k] = v;
             i++;
         }
@@ -86,6 +98,8 @@ export function backtestCommand(argv, io) {
         io.stdout.write(BACKTEST_HELP + '\n');
         return 0;
     }
+    if (opts.subject === 'skills')
+        return skillsCommand(opts, io);
     const path = typeof opts.db === 'string' ? opts.db : (io.env.DEXTERM_DB_PATH || defaultDbPath(io.env));
     if (path === ':memory:') {
         io.stderr.write('dexterm backtest: an in-memory DB has no history\n');
@@ -100,6 +114,13 @@ export function backtestCommand(argv, io) {
             io.stderr.write(`dexterm backtest: no recorded history in ${path} (run the app with the recorder on first)\n`);
             return 2;
         }
+        if (typeof opts['build-eval'] === 'string') {
+            const maxLag = typeof opts['max-lag'] === 'string' ? Number(opts['max-lag']) : undefined;
+            const set = buildSkillEvalSet(db, { horizonSec: typeof opts.horizon === 'string' ? horizon : 259_200, maxLagSec: Number.isFinite(maxLag) ? maxLag : undefined });
+            writeFileSync(opts['build-eval'], JSON.stringify(set, null, 1) + '\n');
+            io.stdout.write(`eval set: ${set.counts.rows} rows (train ${set.counts.train}, bad ${set.counts.bad_train} · test ${set.counts.test}, bad ${set.counts.bad_test}) → ${opts['build-eval']}\nexcluded: ${Object.entries(set.counts.excluded).map(([k, n]) => `${k} ${n}`).join(' · ')}\n`);
+            return 0;
+        }
         if (opts.subject === 'larp') {
             const r = larpEval(readLarpJoin(db, horizon));
             if (opts.json)
@@ -147,3 +168,41 @@ export function backtestCommand(argv, io) {
         catch { /* ignore */ }
     }
 }
+/**
+ * task-1401: `--subject skills`. Before = the v0 rules written from the skill text before any backtest; after =
+ * the shipped tuned rules, or (with --tune) a fresh train-split tune. Reads only the eval JSON.
+ */
+function skillsCommand(opts, io) {
+    const file = typeof opts.eval === 'string' ? opts.eval : DEFAULT_SKILL_EVAL;
+    let set;
+    if (file === DEFAULT_SKILL_EVAL && !existsSync(file)) {
+        // the npm build ships no eval data (packages/packs/eval is repo-only): build one from your own history
+        io.stderr.write('dexterm backtest: the bundled eval set is not part of this install. Build one from your own recorder history:\n  dexterm backtest --build-eval ./skills-eval.json && dexterm backtest --subject skills --eval ./skills-eval.json\n');
+        return 2;
+    }
+    try {
+        set = JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        io.stderr.write(`dexterm backtest: cannot read eval set ${file}: ${e instanceof Error ? e.message : String(e)}\n`);
+        return 2;
+    }
+    if (set.schema !== SKILL_EVAL_SCHEMA || !Array.isArray(set.rows)) {
+        io.stderr.write(`dexterm backtest: ${file} is not a ${SKILL_EVAL_SCHEMA} file\n`);
+        return 2;
+    }
+    let larpAfter = DEFAULT_LINK_RUBRIC, rugAfter = RUG_RULES_V1, tuned = null;
+    if (opts.tune) {
+        const train = set.rows.filter((r) => r.split === 'train');
+        const l = tuneLinkRubric(train);
+        const r = tuneRugRules(train);
+        larpAfter = l.rubric;
+        rugAfter = r.rules;
+        tuned = { larp: { train_mcc: l.train_mcc, candidates: l.candidates }, rug: { train_mcc: r.train_mcc, candidates: r.candidates } };
+    }
+    const report = skillBacktest(set, { larpBefore: LINK_RUBRIC_V0, larpAfter, rugBefore: RUG_RULES_V0, rugAfter, tuned });
+    if (typeof opts.report === 'string')
+        writeFileSync(opts.report, JSON.stringify(report, null, 1) + '\n');
+    io.stdout.write(opts.json ? JSON.stringify(report, null, 2) + '\n' : renderSkillBacktestText(report));
+    return 0;
+}

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

@@ -0,0 +1,2 @@
+// task-1401: the coin-target parser lives in @dexterm/data (shared with the MCP server); re-exported for the CLI.
+export { parseMintTarget, parseCoinTarget, resolveCoinTarget, isBareOpen, MINT_RE } from '../../data/src/index.js';

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

@@ -14,7 +14,8 @@ import { shellBinaryPath } from '../../popup/src/index.js';
 import { detectColorDepth, protocolFromEnv } from '../../tui/src/index.js';
 import { resolveRpcUrl, defaultDbPath } from '../../data/src/index.js';
 import { XTokenStore } from '../../data/src/index.js';
-import { SayTts, voiceDoctor, WHISPER_MODEL } from '../../voice/src/index.js';
+import { SayTts, voiceDoctor, resolveVoice, WHISPER_MODEL, resolvePiperBin, pickPlayer, PIPER_MODEL } from '../../voice/src/index.js';
+import { loadConfig, dextermHome } from '../../custom/src/index.js';
 import { kbStore, skillStore } from "./kb-skill-cmd.js";
 /** The minimum Node that runs dexterm (type-stripping of the .ts entry needs 22.18). */
 export const MIN_NODE = [22, 18, 0];
@@ -29,16 +30,29 @@ function onPath(bin) {
  * Default voice probe. Deliberately cheap and non-blocking: it never compiles the Swift helper (that
  * is left to the first real `v` press), so resolvedStt is inferred from swiftc / whisper presence.
  */
-export async function defaultVoiceProbe(platform = process.platform) {
+export async function defaultVoiceProbe(platform = process.platform, configuredVoice) {
     const say = new SayTts();
     const sayAvailable = platform === 'darwin' ? await say.available() : false;
-    const voices = sayAvailable ? await say.listVoices() : [];
+    const voices = sayAvailable ? await say.listVoicesDetailed() : [];
     const swiftcPresent = platform === 'darwin' && onPath('swiftc');
     const whisperBinPresent = onPath('whisper-cli');
     const whisperModelPresent = existsSync(WHISPER_MODEL);
-    const micToolPresent = onPath('sox') || onPath('rec') || onPath('ffmpeg');
+    const micToolPresent = onPath('sox') || onPath('rec') || onPath('ffmpeg') || onPath('arecord');
+    // Apple Speech is macOS-only; everywhere else whisper.cpp is the default voice-in (task-1393 Part 2).
     const resolvedStt = swiftcPresent ? 'apple' : (whisperBinPresent && whisperModelPresent && micToolPresent) ? 'whisper' : null;
-    return { platform, sayAvailable, voiceCount: voices.length, swiftcPresent, whisperBinPresent, whisperModelPresent, micToolPresent, resolvedStt };
+    // espeak-ng is the baseline portable speech-out engine off macOS.
+    const espeakPresent = platform !== 'darwin' && (onPath('espeak-ng') || onPath('espeak'));
+    // Piper is the preferred neural speech-out engine off macOS (task-1408): binary + voice model + a player.
+    const piperPresent = platform !== 'darwin' && resolvePiperBin() !== null;
+    const piperVoicePresent = platform !== 'darwin' && existsSync(PIPER_MODEL);
+    const playerName = platform !== 'darwin' ? pickPlayer() : null;
+    // task-1393: show which voice will actually speak, and why — never a silent system/novelty voice.
+    const r = sayAvailable ? resolveVoice({ configured: configuredVoice, installed: voices }) : { voice: null, reason: '' };
+    return {
+        platform, sayAvailable, voiceCount: voices.length, swiftcPresent, whisperBinPresent, whisperModelPresent, micToolPresent, resolvedStt,
+        espeakPresent, piperPresent, piperVoicePresent, playerName,
+        resolvedVoice: sayAvailable ? r.voice : undefined, resolvedVoiceReason: r.reason,
+    };
 }
 /** The keyless data sources the live app depends on, with a cheap reachability URL for each. */
 export const DATA_SOURCES = [
@@ -142,7 +156,7 @@ export function defaultDeps(env = process.env, isTTY = process.stdout.isTTY ===
             const cargo = spawnSync('cargo', ['--version'], { stdio: 'ignore', timeout: 3000 }).status === 0;
             return { path, built: existsSync(path), cargo };
         },
-        voiceProbe: () => defaultVoiceProbe(process.platform),
+        voiceProbe: () => defaultVoiceProbe(process.platform, loadConfig(dextermHome(env)).config.voice?.name ?? null),
         content: () => ({ kb: kbStore(env).get(), skills: skillStore(env).get() }),
     };
 }