compact-agent 1.5.0 → 1.7.0

package/dist/index.js

@@ -20,7 +20,7 @@ import { buildCommitPrompt, buildPRPrompt, printDiff, printLog } from './git-wor
 import { buildReviewPrompt, buildTDDPrompt, buildSecurityReviewPrompt, runAudit, printAuditReport, buildPlanPrompt, buildE2EPrompt, buildBuildFixPrompt, buildEvalPrompt } from './evaluation.js';
 import { printRules } from './rules.js';
 import { buildOrchestrationPrompt } from './orchestration.js';
-import { printBanner as printThemedBanner, printSplash, theme, sym } from './theme.js';
+import { printBanner as printThemedBanner, theme, sym, formatDuration, installScreenReaderDispatch, uninstallScreenReaderDispatch } from './theme.js';
 import { saveExport } from './export.js';
 // New feature modules
 import { buildVerifyPrompt, saveCheckpoint, listCheckpoints } from './verification.js';
@@ -55,6 +55,10 @@ import { installEcc, getEccCommandPrompt, loadEccState, eccResourcesAvailable, }
 import { buildWalkthroughPrompt } from './walkthrough.js';
 // Stitch (Google's AI UI/UX design tool) — /stitch, /stitch-config, /stitch-tools
 import { buildStitchPrompt, buildStitchToolsPrompt, saveStitchConfig, printStitchStatus, stitchConfigured } from './stitch.js';
+// Voice / accessibility — built-in dictation (Whisper) + readout (ElevenLabs)
+import { printVoiceStatus, isVoiceEnabled, getTtsConfig, getSttConfig, getAccessibilityConfig, speak, dictateOnce, } from './voice.js';
+import { isFfmpegAvailable, audioCue, startRecording } from './audio.js';
+import { applyScreenReader, summarize } from './accessibility.js';
 /**
  * Unified prompt resolver — prefers the bundled ECC prompt for a given
  * intent and falls back to the built-in builder when ECC isn't installed.
@@ -253,6 +257,18 @@ export function handleSlashCommand(input, config, messages, session, mode) {
             // database-migration, add-language-rules) auto-inject when you describe
             // matching work — no slash command needed. Status line below confirms
             // it's enabled.
+            console.log(h('\n  ── Voice & accessibility ──'));
+            console.log(d('  ') + c('/voice') + d('            — show voice config & status (off by default)'));
+            console.log(d('  ') + c('/voice on|off') + d('     — master switch for dictation + readout'));
+            console.log(d('  ') + c('/voice config') + d('     — quick setup walkthrough'));
+            console.log(d('  ') + c('/voice key stt <key>') + d(' — OpenAI key for Whisper dictation'));
+            console.log(d('  ') + c('/voice key tts <key>') + d(' — ElevenLabs key for assistant readout'));
+            console.log(d('  ') + c('/voice test') + d('       — play a short test utterance'));
+            console.log(d('  ') + c('/voice echo|skip-code|speed') + d(' — fine-tune behavior'));
+            console.log(d('  ') + c('/dictate [s]') + d('      — one-shot record + transcribe (default 30s)'));
+            console.log(d('  ') + c('/accessibility') + d('    — toggle screen-reader mode, audio cues, destructive-confirm'));
+            console.log(d('  Playback hotkeys (right block): INS dictate · HOME pause · PGUP replay · DEL skip · END speed+ · PGDN speed–'));
+            console.log(d('  Status hotkeys (F-row): F1 what now · F2 where am I · F3 read full · F4 read summary'));
             console.log(h('\n  ── Stitch (Google AI UI/UX design) ──'));
             console.log(d('  Use ') + c('/mode design') + d(' or ') + c('/design <task>') + d(' for UI work — the agent uses Stitch automatically.'));
             console.log(d('  ') + c('/stitch') + d('              — show config status'));
@@ -334,6 +350,15 @@ export function handleSlashCommand(input, config, messages, session, mode) {
                 mode.current = args;
                 const m = MODES[mode.current];
                 console.log(chalk.green(`  Mode: ${m.label} — ${m.description}`));
+                // Accessibility: speak the mode-switch when configured. Doesn't
+                // block — fire-and-forget. Errors swallowed (voice should never
+                // break the REPL).
+                if (isVoiceEnabled(config) && getAccessibilityConfig(config).announceModeSwitches) {
+                    const tts = getTtsConfig(config);
+                    if (tts.apiKey) {
+                        speak(`Mode switched to ${m.label}`, config, { voiceId: tts.assistantVoiceId }).catch(() => { });
+                    }
+                }
             }
             else if (args) {
                 console.log(chalk.yellow(`  Unknown mode: ${args}`));
@@ -1074,6 +1099,206 @@ export function handleSlashCommand(input, config, messages, session, mode) {
             console.log(chalk.dim('  Restart the REPL for the tool to appear in /tools.'));
             return { handled: true };
         }
+        // ── Voice / accessibility ────────────────────────
+        // /voice                    — show current voice config + status
+        // /voice on | off           — master switch
+        // /voice config             — interactive setup (asks for keys)
+        // /voice test               — synth a short test utterance to verify TTS
+        // /voice key stt <KEY>      — set OpenAI key for Whisper STT only
+        // /voice key tts <KEY>      — set ElevenLabs key for TTS only
+        // /voice echo on | off      — toggle TTS-echo of user input
+        // /voice skip-code on|off   — toggle stripping code blocks from TTS
+        // /voice speed <n>          — set 0.5..2.0
+        case '/voice': {
+            const parts = args.trim().split(/\s+/).filter(Boolean);
+            const sub = (parts[0] || '').toLowerCase();
+            if (!sub) {
+                printVoiceStatus(config);
+                return { handled: true };
+            }
+            if (sub === 'on' || sub === 'off') {
+                config.voice = config.voice || {};
+                config.voice.enabled = sub === 'on';
+                saveConfig(config);
+                console.log(chalk.green(`  Voice: ${sub === 'on' ? 'ON' : 'OFF'}`));
+                if (sub === 'on') {
+                    if (!getTtsConfig(config).apiKey) {
+                        console.log(chalk.yellow('  ⚠ No ElevenLabs key set. Run /voice key tts <KEY> to enable readout.'));
+                    }
+                    if (!getSttConfig(config).apiKey) {
+                        console.log(chalk.yellow('  ⚠ No OpenAI key for Whisper. Run /voice key stt <KEY> to enable dictation.'));
+                    }
+                    isFfmpegAvailable().then((ok) => {
+                        if (!ok)
+                            console.log(chalk.yellow('  ⚠ ffmpeg not found on PATH. Install ffmpeg: https://ffmpeg.org/'));
+                    });
+                }
+                return { handled: true };
+            }
+            if (sub === 'config') {
+                // Lightweight interactive setup deferred to the prompt — user can
+                // also just use `/voice key stt ...` and `/voice key tts ...`.
+                console.log(chalk.cyan('\n  /voice config — quick setup'));
+                console.log(chalk.dim('    1. Get an OpenAI key for Whisper STT: https://platform.openai.com/api-keys'));
+                console.log(chalk.dim('    2. Get an ElevenLabs key for TTS:    https://elevenlabs.io/app/settings/api-keys'));
+                console.log(chalk.dim('    3. Run:  /voice key stt <openai-key>'));
+                console.log(chalk.dim('             /voice key tts <elevenlabs-key>'));
+                console.log(chalk.dim('             /voice on'));
+                console.log(chalk.dim('    4. Press F1 to dictate, hear assistant readout automatically.'));
+                console.log();
+                return { handled: true };
+            }
+            if (sub === 'key') {
+                const target = (parts[1] || '').toLowerCase();
+                const key = parts.slice(2).join(' ').trim();
+                if ((target !== 'stt' && target !== 'tts') || !key) {
+                    console.log(chalk.yellow('  Usage: /voice key stt <openai-key>  |  /voice key tts <elevenlabs-key>'));
+                    return { handled: true };
+                }
+                config.voice = config.voice || {};
+                if (target === 'stt') {
+                    config.voice.stt = { ...(config.voice.stt || {}), apiKey: key };
+                    console.log(chalk.green(`  STT key saved (***${key.slice(-4)}).`));
+                }
+                else {
+                    config.voice.tts = { ...(config.voice.tts || {}), apiKey: key };
+                    console.log(chalk.green(`  TTS key saved (***${key.slice(-4)}).`));
+                }
+                saveConfig(config);
+                return { handled: true };
+            }
+            if (sub === 'test') {
+                const tts = getTtsConfig(config);
+                if (!tts.apiKey) {
+                    console.log(chalk.yellow('  No TTS key. Run /voice key tts <elevenlabs-key> first.'));
+                    return { handled: true };
+                }
+                console.log(chalk.dim('  Synthesizing test utterance…'));
+                speak('Voice readout is working. This is the assistant voice.', config, { voiceId: tts.assistantVoiceId })
+                    .then((ok) => console.log(ok ? chalk.green('  ✓ Played.') : chalk.yellow('  ✗ Playback failed — check ffmpeg.')));
+                return { handled: true };
+            }
+            if (sub === 'echo') {
+                const v = (parts[1] || '').toLowerCase();
+                if (v !== 'on' && v !== 'off') {
+                    console.log(chalk.yellow('  Usage: /voice echo on|off'));
+                    return { handled: true };
+                }
+                config.voice = config.voice || {};
+                config.voice.tts = { ...(config.voice.tts || {}), echoUser: v === 'on' };
+                saveConfig(config);
+                console.log(chalk.green(`  User-echo: ${v.toUpperCase()}`));
+                return { handled: true };
+            }
+            if (sub === 'skip-code') {
+                const v = (parts[1] || '').toLowerCase();
+                if (v !== 'on' && v !== 'off') {
+                    console.log(chalk.yellow('  Usage: /voice skip-code on|off'));
+                    return { handled: true };
+                }
+                config.voice = config.voice || {};
+                config.voice.tts = { ...(config.voice.tts || {}), skipCode: v === 'on' };
+                saveConfig(config);
+                console.log(chalk.green(`  Skip-code: ${v.toUpperCase()}`));
+                return { handled: true };
+            }
+            if (sub === 'speed') {
+                const n = parseFloat(parts[1] || '');
+                if (isNaN(n) || n < 0.25 || n > 4.0) {
+                    console.log(chalk.yellow('  Usage: /voice speed <0.25..4.0>'));
+                    return { handled: true };
+                }
+                config.voice = config.voice || {};
+                config.voice.tts = { ...(config.voice.tts || {}), speed: n };
+                saveConfig(config);
+                console.log(chalk.green(`  TTS speed: ${n}x`));
+                return { handled: true };
+            }
+            console.log(chalk.yellow(`  Unknown /voice subcommand: ${sub}`));
+            console.log(chalk.dim('  Try: on, off, config, test, key, echo, skip-code, speed'));
+            return { handled: true };
+        }
+        // /dictate — one-shot push-to-talk WITHOUT the F1 hotkey, useful when a
+        // user is testing the pipeline or running under a terminal that strips
+        // function keys. Records up to 30s, transcribes, injects as next prompt.
+        case '/dictate': {
+            const maxSec = parseInt(args, 10) || 30;
+            console.log(chalk.dim(`  /dictate — recording up to ${maxSec}s…`));
+            // Return as an async-injected prompt; we resolve the recording
+            // synchronously here for simplicity (REPL is blocking anyway).
+            return { handled: true, injectPrompt: '__DICTATE__' + maxSec };
+        }
+        // /accessibility — show or toggle the accessibility sub-block
+        //   /accessibility                  — print status
+        //   /accessibility screen-reader on|off
+        //   /accessibility cues on|off
+        //   /accessibility announce-errors on|off
+        //   /accessibility announce-modes  on|off
+        //   /accessibility confirm-destructive on|off
+        //   /accessibility long-resp <words>
+        case '/accessibility':
+        case '/a11y': {
+            const parts = args.trim().split(/\s+/).filter(Boolean);
+            const sub = (parts[0] || '').toLowerCase();
+            const v = (parts[1] || '').toLowerCase();
+            if (!sub) {
+                printVoiceStatus(config);
+                return { handled: true };
+            }
+            const setBool = (field, label) => {
+                if (v !== 'on' && v !== 'off') {
+                    console.log(chalk.yellow(`  Usage: /accessibility ${sub} on|off`));
+                    return;
+                }
+                config.voice = config.voice || {};
+                config.voice.accessibility = { ...(config.voice.accessibility || {}), [field]: v === 'on' };
+                saveConfig(config);
+                // Screen-reader mode is special: install/uninstall the stdout filter
+                // immediately so the toggle takes effect for the very next log line.
+                if (field === 'screenReader') {
+                    if (v === 'on')
+                        installScreenReaderDispatch(applyScreenReader);
+                    else
+                        uninstallScreenReaderDispatch();
+                }
+                console.log(chalk.green(`  ${label}: ${v.toUpperCase()}`));
+            };
+            if (sub === 'screen-reader' || sub === 'screenreader' || sub === 'sr') {
+                setBool('screenReader', 'Screen-reader mode');
+                return { handled: true };
+            }
+            if (sub === 'cues' || sub === 'audio-cues') {
+                setBool('audioCues', 'Audio cues');
+                return { handled: true };
+            }
+            if (sub === 'announce-errors' || sub === 'errors') {
+                setBool('announceErrors', 'Announce errors');
+                return { handled: true };
+            }
+            if (sub === 'announce-modes' || sub === 'modes') {
+                setBool('announceModeSwitches', 'Announce mode switches');
+                return { handled: true };
+            }
+            if (sub === 'confirm-destructive' || sub === 'destructive') {
+                setBool('askBeforeDestructive', 'Ask before destructive');
+                return { handled: true };
+            }
+            if (sub === 'long-resp' || sub === 'threshold') {
+                const n = parseInt(parts[1] || '', 10);
+                if (!n || n < 50) {
+                    console.log(chalk.yellow('  Usage: /accessibility long-resp <words≥50>'));
+                    return { handled: true };
+                }
+                config.voice = config.voice || {};
+                config.voice.accessibility = { ...(config.voice.accessibility || {}), longResponseThreshold: n };
+                saveConfig(config);
+                console.log(chalk.green(`  Long-response threshold: ${n} words`));
+                return { handled: true };
+            }
+            console.log(chalk.yellow(`  Unknown /accessibility subcommand: ${sub}`));
+            console.log(chalk.dim('  Try: screen-reader, cues, announce-errors, announce-modes, confirm-destructive, long-resp'));
+            return { handled: true };
+        }
         // ── ECC (everything-claude-code) — no slash commands ───
         // ECC is bundled, free, auto-installed on first launch, and used
         // automatically: built-in commands (/tdd /review /security-review /plan
@@ -1128,6 +1353,12 @@ async function main() {
     else {
         config = loadConfig();
     }
+    // Install the screen-reader output filter if the user's config has it on.
+    // Done as early as possible so every subsequent console.log (banner, hooks,
+    // ECC install report, etc.) gets the filter applied uniformly.
+    if (config.voice?.accessibility?.screenReader) {
+        installScreenReaderDispatch(applyScreenReader);
+    }
     // Create session
     const mode = { current: 'dev' };
     const session = createSession(process.cwd(), config.model, config.provider, mode.current);
@@ -1141,8 +1372,8 @@ async function main() {
     // Show startup display based on theme setting
     const themeMode = config.theme || 'full';
     if (themeMode === 'full') {
-        // Full mode: splash + banner
-        printSplash();
+        // Full mode: banner. ASCII splash removed per user request — both `full`
+        // and `compact` themes now render the same banner block.
         printThemedBanner(config.provider, config.model, mode.current, config.permissionMode, session.id, ALL_TOOLS.map((t) => t.name));
     }
     else if (themeMode === 'compact') {
@@ -1155,12 +1386,234 @@ async function main() {
         console.log('');
     }
     let autoRoute = false;
+    // ── F-key hotkey listener ────────────────────────────────
+    // Voice / accessibility hotkeys.
+    //
+    // The six right-side block keys handle PLAYBACK + DICTATION. They're
+    // mapped here (and not to F-keys) because the right-side block is
+    // tactile-locatable without sight — INS/HOME/PGUP form a tight triangle
+    // above the arrow keys with raised nibs on many keyboards, and DEL/END/
+    // PGDN sit directly below them. F-keys are repurposed for STATUS read-
+    // outs because they're row-aligned (countable by touch).
+    //
+    //   Playback / dictation block (right side):
+    //     INS    push-to-talk dictation (toggle: first press starts, second stops)
+    //     HOME   pause current TTS playback
+    //     PGUP   replay last spoken chunk
+    //     DEL    skip the current chunk
+    //     END    speed up TTS  (× 1.25, capped at 2.0)
+    //     PGDN   slow down TTS (× 0.8,  floored at 0.5)
+    //
+    //   Status announcements (F-row, for "what's happening?" while waiting):
+    //     F1     current activity + elapsed   ("calling claude-sonnet-4, 8s")
+    //     F2     where am I — model/provider/mode/permissions
+    //     F3     re-speak full last response (bypasses summary)
+    //     F4     re-speak summary of last response
+    //
+    // All keys are no-ops when voice is off, so installing the listener
+    // unconditionally is safe and lets the user enable voice mid-session
+    // without restarting.
+    let dictateController = null;
+    let dictateActive = false;
+    // Track aborts + last-spoken text so query.ts can hand them off here.
+    globalThis.__voicePlaybackCtl = null;
+    globalThis.__voiceLastChunk = null;
+    globalThis.__voiceLastFullResponse = null;
+    // emitKeypressEvents lives on the callback-flavor 'node:readline' module
+    // (the promises variant doesn't expose it). Some platforms / terminals
+    // don't deliver the right escape sequences for INS/HOME/etc — failure
+    // here is a silent no-op; users can fall back to /dictate.
+    try {
+        const readlineCb = await import('node:readline');
+        const { describeStatus, describeLocation } = await import('./status.js');
+        readlineCb.emitKeypressEvents(stdin);
+        // Set of keys we intercept. Anything not in this set falls through to
+        // readline so normal typing isn't affected.
+        const INTERCEPT = new Set([
+            'insert', 'home', 'pageup', 'delete', 'end', 'pagedown', // playback
+            'f1', 'f2', 'f3', 'f4', // status
+        ]);
+        stdin.on('keypress', (_str, key) => {
+            if (!key)
+                return;
+            const name = String(key.name || '').toLowerCase();
+            if (!INTERCEPT.has(name))
+                return;
+            if (!isVoiceEnabled(config))
+                return;
+            const a = getAccessibilityConfig(config);
+            const tts = getTtsConfig(config);
+            // ── INS: push-to-talk dictation toggle ──────────────
+            if (name === 'insert') {
+                if (dictateActive) {
+                    dictateActive = false;
+                    const ctl = dictateController;
+                    dictateController = null;
+                    if (!ctl)
+                        return;
+                    (async () => {
+                        if (a.audioCues)
+                            await audioCue('recording-stop');
+                        const buf = await ctl.stop();
+                        if (!buf) {
+                            console.log(chalk.dim('  [INS] no audio captured.'));
+                            return;
+                        }
+                        if (a.audioCues)
+                            await audioCue('processing');
+                        const { transcribeAudio } = await import('./voice.js');
+                        const { setStatus } = await import('./status.js');
+                        setStatus({ state: 'transcribing' });
+                        const transcript = await transcribeAudio(buf, config, 'wav');
+                        setStatus({ state: 'idle' });
+                        if (!transcript) {
+                            console.log(chalk.dim('  [INS] transcription failed.'));
+                            if (a.audioCues)
+                                await audioCue('error');
+                            return;
+                        }
+                        if (a.audioCues)
+                            await audioCue('done');
+                        const stt = getSttConfig(config);
+                        stdin.write(transcript);
+                        if (stt.autoSubmit)
+                            stdin.write('\n');
+                    })();
+                }
+                else {
+                    (async () => {
+                        if (!(await isFfmpegAvailable())) {
+                            console.log(chalk.yellow('  [INS] ffmpeg not on PATH. Install ffmpeg to dictate.'));
+                            return;
+                        }
+                        const ctl = await startRecording(60);
+                        if (!ctl) {
+                            console.log(chalk.yellow('  [INS] could not start mic capture.'));
+                            return;
+                        }
+                        dictateController = ctl;
+                        dictateActive = true;
+                        const { setStatus } = await import('./status.js');
+                        setStatus({ state: 'recording' });
+                        if (a.audioCues)
+                            await audioCue('recording-start');
+                        console.log(chalk.dim('  [INS] recording — press INS again to stop.'));
+                    })();
+                }
+                return;
+            }
+            // ── HOME: pause TTS ─────────────────────────────────
+            if (name === 'home') {
+                const g = globalThis;
+                if (g.__voicePlaybackCtl && !g.__voicePlaybackCtl.signal.aborted) {
+                    g.__voicePlaybackCtl.abort();
+                    console.log(chalk.dim('  [HOME] TTS paused.'));
+                }
+                return;
+            }
+            // ── PGUP: replay last chunk ─────────────────────────
+            if (name === 'pageup') {
+                const g = globalThis;
+                const chunk = g.__voiceLastChunk;
+                if (!chunk) {
+                    console.log(chalk.dim('  [PGUP] nothing to replay.'));
+                    return;
+                }
+                if (!tts.apiKey)
+                    return;
+                (async () => { await speak(chunk, config, { voiceId: tts.assistantVoiceId }); })();
+                return;
+            }
+            // ── DEL: skip current chunk ─────────────────────────
+            if (name === 'delete') {
+                const g = globalThis;
+                if (g.__voicePlaybackCtl)
+                    g.__voicePlaybackCtl.abort();
+                console.log(chalk.dim('  [DEL] TTS skipped.'));
+                return;
+            }
+            // ── END / PGDN: TTS speed ±  ───────────────────────
+            if (name === 'end' || name === 'pagedown') {
+                config.voice = config.voice || {};
+                const ttsCfg = config.voice.tts = { ...(config.voice.tts || {}) };
+                const cur = ttsCfg.speed ?? 1.0;
+                const next = name === 'end' ? Math.min(2.0, cur * 1.25) : Math.max(0.5, cur * 0.8);
+                ttsCfg.speed = Math.round(next * 100) / 100;
+                saveConfig(config);
+                console.log(chalk.dim(`  [${name === 'end' ? 'END' : 'PGDN'}] TTS speed: ${ttsCfg.speed}x`));
+                return;
+            }
+            // ── F1: "what's happening?" — current activity + elapsed ───
+            if (name === 'f1') {
+                const msg = describeStatus();
+                console.log(chalk.dim(`  [F1] ${msg}`));
+                if (tts.apiKey) {
+                    speak(msg, config, { voiceId: tts.assistantVoiceId }).catch(() => { });
+                }
+                return;
+            }
+            // ── F2: "where am I?" — model/provider/mode/permissions ────
+            if (name === 'f2') {
+                const msg = describeLocation();
+                console.log(chalk.dim(`  [F2] ${msg}`));
+                if (tts.apiKey) {
+                    speak(msg, config, { voiceId: tts.assistantVoiceId }).catch(() => { });
+                }
+                return;
+            }
+            // ── F3: re-speak FULL last response ────────────────
+            if (name === 'f3') {
+                const g = globalThis;
+                const text = g.__voiceLastFullResponse;
+                if (!text) {
+                    console.log(chalk.dim('  [F3] nothing to read.'));
+                    return;
+                }
+                if (!tts.apiKey)
+                    return;
+                (async () => {
+                    const { speakAssistantResponse } = await import('./voice.js');
+                    const ctl = new AbortController();
+                    globalThis.__voicePlaybackCtl = ctl;
+                    await speakAssistantResponse(text, config, ctl.signal);
+                })();
+                return;
+            }
+            // ── F4: re-speak SUMMARY of last response ──────────
+            if (name === 'f4') {
+                const g = globalThis;
+                const text = g.__voiceLastFullResponse;
+                if (!text) {
+                    console.log(chalk.dim('  [F4] nothing to summarize.'));
+                    return;
+                }
+                if (!tts.apiKey)
+                    return;
+                const summary = summarize(text, a.longResponseThreshold);
+                (async () => {
+                    const ctl = new AbortController();
+                    globalThis.__voicePlaybackCtl = ctl;
+                    await speak(summary, config, { voiceId: tts.assistantVoiceId, signal: ctl.signal });
+                })();
+                return;
+            }
+        });
+    }
+    catch {
+        // No keypress support — accessibility users can still use /dictate.
+    }
+    // Session-start anchor — used by the [Nm Ns] tag prepended to every prompt
+    // so the user can see at a glance how long the REPL has been open. Combined
+    // with the per-chain timer printed after each model response (see runQuery),
+    // gives both "how long am I here" and "how long was that last response."
+    const sessionStartMs = new Date(session.createdAt).getTime();
     // Main REPL loop
     while (true) {
         let input;
         try {
+            const sessionTag = theme.dim(`[${formatDuration(Date.now() - sessionStartMs)}] `);
             const modeTag = mode.current !== 'dev' ? theme.dim(`[${mode.current}] `) : '';
-            input = await rl.question(modeTag + theme.prompt(`${sym.prompt} `));
+            input = await rl.question(sessionTag + modeTag + theme.prompt(`${sym.prompt} `));
         }
         catch {
             break;
@@ -1205,7 +1658,22 @@ async function main() {
             }
             // Some commands inject a prompt into the conversation (e.g. /commit, /review, /tdd)
             if (result.injectPrompt) {
-                messages.push({ role: 'user', content: result.injectPrompt });
+                // Special-case the /dictate flow: synthesize the prompt from the mic
+                // before pushing it as a user message. We use the sentinel
+                // "__DICTATE__<seconds>" so the slash handler stays purely sync.
+                if (result.injectPrompt.startsWith('__DICTATE__')) {
+                    const maxSec = parseInt(result.injectPrompt.slice('__DICTATE__'.length), 10) || 30;
+                    const transcript = await dictateOnce(config, maxSec);
+                    if (!transcript) {
+                        console.log(chalk.dim('  [dictate] no transcript captured.'));
+                        continue;
+                    }
+                    console.log(theme.dim('  [dictate] ') + chalk.white(transcript));
+                    messages.push({ role: 'user', content: transcript });
+                }
+                else {
+                    messages.push({ role: 'user', content: result.injectPrompt });
+                }
                 await runQuery({ config, messages, cwd: process.cwd(), rl, sessionId: session.id, mode: mode.current });
                 await autoSave(session, messages);
                 continue;