micforge 1.3.0__py3-none-any.whl

micforge/commands/latency_test.py

@@ -0,0 +1,65 @@
+"""CLI command to run end-to-end latency benchmarks and stage breakdowns."""
+from __future__ import annotations
+
+from rich import box
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from ..audio.latency import measure_end_to_end_latency
+from ..config import AppConfig
+from ..ui.theme import console
+
+
+def run_latency_test(
+    app: AppConfig,
+    mic: int | str | None = None,
+    out: int | str | None = None,
+) -> int:
+    """Run interactive or automated latency test and display breakdown."""
+    console.print("\n[bold cyan]⏱️ Running end-to-end audio latency benchmark…[/]\n")
+
+    input_dev = mic or app.input_device
+    output_dev = out or app.output_device or app.monitor_device
+
+    result = measure_end_to_end_latency(
+        input_device=input_dev,
+        output_device=output_dev,
+        sample_rate=app.sample_rate,
+        block_size=app.block_size,
+        jitter_blocks=app.jitter_blocks,
+    )
+
+    # 1. Main Latency Banner
+    lat_style = "bold green" if result.one_way_ms < 60.0 else "bold yellow" if result.one_way_ms < 100.0 else "bold red"
+    summary_text = (
+        f"[{lat_style}]Estimated One-Way Latency: ~{result.one_way_ms:.1f} ms[/]\n"
+        f"[dim]Measured Round-Trip Delay: {result.roundtrip_ms:.1f} ms  │  "
+        f"Confidence: {result.confidence_score * 100:.0f}% ({result.method})[/]"
+    )
+    console.print(Panel(summary_text, title="[bold cyan]⚡ LATENCY BENCHMARK RESULT[/]", border_style="cyan", box=box.ROUNDED))
+
+    # 2. Per-Stage Latency Breakdown Table
+    t = Table(box=box.SIMPLE_HEAD, header_style="bold cyan")
+    t.add_column("Pipeline Stage", width=28)
+    t.add_column("Observed Delay", justify="right", width=16)
+    t.add_column("Description")
+
+    bd = result.breakdown
+    t.add_row("1. Input Hardware Buffer", f"{bd.input_hardware_ms:.1f} ms", f"{app.block_size} samples @ {app.sample_rate} Hz")
+    t.add_row("2. 11-Stage DSP & Neural AI", f"{bd.dsp_pipeline_ms:.1f} ms", "Vectorized biquad SOS + CoFi-Lite inference")
+    t.add_row("3. Ring Buffer Jitter Cushion", f"{bd.jitter_cushion_ms:.1f} ms", f"{app.jitter_blocks} blocks cushion (prevents crackle)")
+    t.add_row("4. Output Hardware Buffer", f"{bd.output_hardware_ms:.1f} ms", f"Virtual cable / headphone DAC render block")
+    t.add_section()
+    t.add_row("[bold]Total Pipeline Estimate[/]", f"[bold]{bd.total_estimated_ms:.1f} ms[/]", "[bold]Direct one-way mouth-to-Discord latency[/]")
+
+    console.print(t)
+
+    # 3. Actionable Guidance
+    console.print("[bold cyan]Actionable Guidance & Tuning:[/\n]")
+    for rec in result.recommendations:
+        console.print(f"  [dim]•[/] {rec}")
+    console.print()
+
+    return 0
+

micforge/commands/live.py

@@ -0,0 +1,321 @@
+"""`run` and `loopback`: the live dashboard."""
+from __future__ import annotations
+
+import os
+import threading
+import time
+
+from rich.live import Live
+
+from ..audio.engine import AudioEngine, SinkSpec
+from ..config import AppConfig
+from ..presets import list_presets
+from ..profile_store import save_profile
+from ..ui.dashboard import LiveContext, render_dashboard
+from ..ui.hotkeys import GlobalHotkeyManager
+from ..ui.keys import KeyReader
+from ..ui.theme import console
+from ..ui.tray import SystemTrayDaemon
+from .common import make_chain, resolve_devices
+
+KEYS = [
+    ("b", "A/B bypass"), ("x", "mute"), ("l", "monitor"), ("p", "preset"),
+    ("m", "model"), ("c", "calibrate"), ("+/-", "denoise"), ("[ ]", "gain"), ("q", "quit"),
+]
+
+
+def run_live(
+    app: AppConfig,
+    *,
+    preset: str | None = None,
+    loopback: bool = False,
+    monitor: bool = False,
+    mic=None,
+    cable=None,
+    monitor_dev=None,
+    model: str | None = None,
+    tray: bool = False,
+    no_tray: bool = False,
+) -> None:
+    preset = preset or app.preset
+    model_override = model or app.denoise_model
+    devs = resolve_devices(
+        app,
+        need_cable=not loopback,
+        want_monitor=loopback or monitor,
+        mic_override=mic,
+        cable_override=cable,
+        monitor_override=monitor_dev,
+    )
+    chain, has_profile = make_chain(app, preset, model_override=model_override)
+
+    sinks: list[SinkSpec] = []
+    if devs.cable:
+        sinks.append(SinkSpec("cable", devs.cable))
+    if devs.monitor:
+        sinks.append(SinkSpec("monitor", devs.monitor, enabled=True))
+    engine = AudioEngine(
+        chain=chain,
+        input_device=devs.mic,
+        sinks=sinks,
+        input_channel=app.input_channel,
+        sample_rate=app.sample_rate,
+        block_size=app.block_size,
+        jitter_blocks=app.jitter_blocks,
+        play_cues=app.hotkeys.play_cues,
+        cue_volume=app.hotkeys.cue_volume,
+        aec_reference_device=app.aec_reference_device,
+    )
+    names = [p.name for p in list_presets()]
+    ctx = LiveContext(
+        title="LOOPBACK TEST" if loopback else "MIC ENHANCER",
+        preset=preset,
+        input_name=devs.mic.name,
+        cable_name=devs.cable.name if devs.cable else None,
+        monitor_name=devs.monitor.name if devs.monitor else None,
+        sample_rate=app.sample_rate,
+        block_size=app.block_size,
+        centers=engine.spectrum_range,
+        has_profile=has_profile,
+        keys=KEYS if not loopback else [k for k in KEYS if k[0] not in ("x", "l")],
+    )
+
+    def flash(msg: str, secs: float = 2.5) -> None:
+        ctx.message, ctx.message_until = msg, time.monotonic() + secs
+
+    exit_event = threading.Event()
+    tray_daemon: SystemTrayDaemon | None = None
+
+    def _on_toggle_mute():
+        is_muted = engine.toggle_mute()
+        if tray_daemon:
+            tray_daemon.update_icon()
+        flash("MIC MUTED" if is_muted else "Mic live")
+
+    def _on_set_mute(val: bool):
+        engine.set_muted(val)
+        if tray_daemon:
+            tray_daemon.update_icon()
+        flash("MIC MUTED" if val else "Mic live")
+
+    def _on_toggle_bypass():
+        is_bp = engine.toggle_bypass()
+        if tray_daemon:
+            tray_daemon.update_icon()
+        flash("BYPASS - raw mic" if is_bp else "PROCESSED")
+
+    def _on_switch_preset(p_name: str):
+        ctx.preset = p_name
+        new_chain, ctx.has_profile = make_chain(app, p_name, model_override=model_override)
+        engine.set_chain(new_chain)
+        flash(f"Preset: {p_name}")
+
+    def _on_switch_model(m_type: str):
+        dn = engine.chain.stage("denoise")
+        from ..dsp.cofilite import CoFiLiteDenoiser
+        from ..dsp.denoise import SpectralDenoiser
+
+        if m_type == "spectral":
+            new_dn = SpectralDenoiser(
+                app.sample_rate,
+                getattr(dn, "strength", 1.0),
+                getattr(dn, "max_reduction_db", 24.0),
+                enabled=getattr(dn, "enabled", True),
+            )
+            engine.chain.stages = [new_dn if s.name == "denoise" else s for s in engine.chain.stages]
+            for s in engine.sinks.values():
+                s.notify_pipeline_change()
+            flash("Swapped denoiser: Spectral Wiener (classical)")
+        else:
+            try:
+                new_dn = CoFiLiteDenoiser(
+                    app.sample_rate,
+                    getattr(dn, "strength", 1.0),
+                    getattr(dn, "max_reduction_db", 24.0),
+                    model_path=model_override,
+                )
+                engine.chain.stages = [new_dn if s.name == "denoise" else s for s in engine.chain.stages]
+                for s in engine.sinks.values():
+                    s.notify_pipeline_change()
+                flash(f"Swapped denoiser: CoFi-Lite ({new_dn.model_name})")
+            except Exception as e:
+                flash(f"CoFi-Lite load error: {e}", 3.0)
+
+    def _on_settings_applied(updated_app: AppConfig) -> None:
+        engine.cues.set_enabled(updated_app.hotkeys.play_cues)
+        engine.cues.set_volume(updated_app.hotkeys.cue_volume)
+        if updated_app.preset != ctx.preset:
+            _on_switch_preset(updated_app.preset)
+        else:
+            _on_switch_preset(ctx.preset)
+        flash("Applied settings from GUI")
+
+    # Initialize global hotkeys
+    hotkeys = GlobalHotkeyManager(
+        app.hotkeys,
+        on_toggle_mute=_on_toggle_mute,
+        on_set_mute=_on_set_mute,
+        on_toggle_bypass=_on_toggle_bypass,
+    )
+    hotkeys.start()
+
+    # Initialize system tray daemon (unless disabled)
+    enable_tray = not no_tray and (tray or app.hotkeys.start_in_tray or os.name == "nt")
+    if enable_tray:
+        tray_daemon = SystemTrayDaemon(
+            app=app,
+            engine=engine,
+            on_exit=exit_event.set,
+            on_switch_preset=_on_switch_preset,
+            on_switch_model=_on_switch_model,
+        )
+        tray_daemon.start()
+
+    # If run in pure tray background mode, run headless
+    if tray and not loopback:
+        console.print("[bold cyan]✔ Micforge is running in background system tray mode.[/]")
+        console.print("  [dim]Right-click the microphone icon in your taskbar for controls, or use your hotkeys.[/]")
+        if tray_daemon:
+            tray_daemon.toggle_console()
+        with engine:
+            try:
+                while not exit_event.is_set():
+                    time.sleep(0.3)
+            except KeyboardInterrupt:
+                pass
+        hotkeys.stop()
+        if tray_daemon:
+            tray_daemon.stop()
+        return
+
+    if loopback:
+        flash("Use headphones, or you will get feedback. Press b to A/B raw vs processed.", 6.0)
+    elif has_profile:
+        flash("Loaded your saved room-noise profile.", 3.0)
+
+    is_cmd = os.name == "nt" and "WT_SESSION" not in os.environ and "TERM_PROGRAM" not in os.environ
+    # 10 FPS on cmd.exe avoids console buffer saturation and eliminates reprint stutter
+    refresh_interval = 0.10 if is_cmd else 0.07
+    last_render = 0.0
+
+    # Collect startup/parsing garbage, freeze runtime objects, and tune GC thresholds
+    import gc
+    try:
+        gc.collect()
+        gc.freeze()
+        gc.set_threshold(100000, 100, 100)
+    except Exception:
+        pass
+
+    try:
+        with engine, KeyReader() as keys, Live(console=console, screen=True, auto_refresh=False) as live:
+            while not exit_event.is_set():
+                now = time.monotonic()
+                cal = engine.pop_calibration()
+                if cal is not None:
+                    if cal.psd is not None:
+                        save_profile(cal.psd, cal.sample_rate, cal.noise_db, cal.gate_threshold_db)
+                    flash(f"Calibrated: room noise {cal.noise_db:.1f} dBFS, gate set to {cal.gate_threshold_db:.1f} dB", 5.0)
+
+                should_refresh = (now - last_render >= refresh_interval) or (cal is not None)
+                if should_refresh:
+                    snap = engine.snapshot()
+                    live.update(render_dashboard(snap, ctx, console.width, now), refresh=True)
+                    last_render = now
+
+                k = keys.poll(0.02)
+                if k is None:
+                    continue
+                k = k.lower() if k.isalpha() else k
+                if k in ("q", "\x03"):
+                    break
+                if k in ("\t", "tab"):
+                    ctx.hud_mode = not ctx.hud_mode
+                    flash("Mode: Gamer HUD" if ctx.hud_mode else "Mode: Studio Inspector")
+                elif k in ("1", "2", "3", "4", "5", "6"):
+                    idx = int(k) - 1
+                    if 0 <= idx < len(names):
+                        _on_switch_preset(names[idx])
+                elif k == "e":
+                    aec = engine.chain.stage("aec")
+                    if aec is not None:
+                        aec.enabled = not getattr(aec, "enabled", True)
+                        flash(f"AEC Echo Cancellation: {'ON' if aec.enabled else 'OFF'}")
+                elif k == "w":
+                    prox = engine.chain.stage("proximity")
+                    if prox is not None:
+                        cur = getattr(prox, "amount", 0.5)
+                        next_amt = 0.35 if cur < 0.2 else 0.55 if cur < 0.45 else 0.75 if cur < 0.65 else 0.0
+                        prox.amount = next_amt
+                        prox.enabled = (next_amt > 0.0)
+                        flash(f"Voice Proximity Body: {int(next_amt * 100)}%" if next_amt > 0 else "Voice Proximity: OFF")
+                elif k == "v":
+                    dv = engine.chain.stage("deverb")
+                    if dv is not None:
+                        cur = getattr(dv, "amount", 0.5)
+                        next_amt = 0.30 if cur < 0.2 else 0.50 if cur < 0.40 else 0.70 if cur < 0.60 else 0.0
+                        dv.amount = next_amt
+                        dv.enabled = (next_amt > 0.0)
+                        flash(f"Room De-Verb: {int(next_amt * 100)}%" if next_amt > 0 else "Room De-Verb: OFF")
+                elif k == "g":
+                    gate = engine.chain.stage("gate")
+                    if gate is not None:
+                        cur = getattr(gate, "threshold_db", -48.0)
+                        next_th = -48.0 if cur <= -50.0 else -44.0 if cur <= -46.0 else -40.0 if cur <= -42.0 else -36.0 if cur <= -38.0 else -52.0
+                        gate.threshold_db = next_th
+                        flash(f"Noise Gate Threshold: {next_th:.0f} dBFS")
+                elif k == "s":
+                    from ..ui.settings_gui import open_settings_window
+                    open_settings_window(app, _on_settings_applied)
+                    flash("Opened MicForge Control Center GUI")
+                elif k in ("h", "?"):
+                    ctx.show_help = not ctx.show_help
+                elif k == "b":
+                    _on_toggle_bypass()
+                elif k == "x" and not loopback:
+                    _on_toggle_mute()
+                elif k == "l" and not loopback:
+                    if not engine.monitor_available:
+                        flash("No monitor device. Restart with --monitor, or run `micforge setup`.", 4.0)
+                    else:
+                        flash("Monitor ON (use headphones!)" if engine.toggle_monitor() else "Monitor off")
+                elif k == "p":
+                    i = names.index(ctx.preset) if ctx.preset in names else -1
+                    _on_switch_preset(names[(i + 1) % len(names)])
+                elif k == "m":
+                    dn = engine.chain.stage("denoise")
+                    from ..dsp.cofilite import CoFiLiteDenoiser
+                    _on_switch_model("spectral" if isinstance(dn, CoFiLiteDenoiser) else "cofilite")
+                elif k == "c":
+                    engine.begin_calibration(3.0)
+                elif k in ("+", "="):
+                    dn = engine.chain.stage("denoise")
+                    if dn is not None:
+                        dn.set_strength(dn.strength + 0.1)  # type: ignore[attr-defined]
+                        dn.enabled = True
+                        flash(f"Denoise strength {dn.strength:.1f}")  # type: ignore[attr-defined]
+                elif k in ("-", "_"):
+                    dn = engine.chain.stage("denoise")
+                    if dn is not None:
+                        dn.set_strength(dn.strength - 0.1)  # type: ignore[attr-defined]
+                        flash(f"Denoise strength {dn.strength:.1f}")  # type: ignore[attr-defined]
+                elif k == "]":
+                    engine.chain.set_input_gain_db(engine.chain.input_gain_db + 1.0)
+                    flash(f"Input gain {engine.chain.input_gain_db:+.0f} dB")
+                elif k == "[":
+                    engine.chain.set_input_gain_db(engine.chain.input_gain_db - 1.0)
+                    flash(f"Input gain {engine.chain.input_gain_db:+.0f} dB")
+
+                # Force immediate UI update after key press
+                snap = engine.snapshot()
+                live.update(render_dashboard(snap, ctx, console.width, time.monotonic()), refresh=True)
+                last_render = time.monotonic()
+    finally:
+        hotkeys.stop()
+        if tray_daemon:
+            tray_daemon.stop()
+
+    if ctx.preset != app.preset:
+        app.preset = ctx.preset
+        app.save()
+        console.print(f"[dim]Saved preset '{ctx.preset}' as default.[/]")

micforge/commands/preset_cmd.py

@@ -0,0 +1,142 @@
+"""Command-line preset management for MicForge."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from rich import box
+from rich.table import Table
+
+from ..config import AppConfig, ChainConfig
+from ..errors import ConfigError
+from ..presets import (
+    BUILTIN,
+    clone_preset,
+    delete_preset,
+    export_preset,
+    get_preset,
+    import_preset,
+    list_presets,
+    save_preset,
+    user_preset_dir,
+)
+from ..ui.theme import console
+
+
+def _format_summary(cfg: ChainConfig) -> str:
+    """Format short summary of enabled stages in a preset."""
+    parts = []
+    if cfg.aec.enabled:
+        parts.append("AEC")
+    if cfg.denoise.enabled:
+        parts.append(f"Denoise({int(cfg.denoise.strength * 100)}%)")
+    if cfg.deverb.enabled:
+        parts.append(f"DeVerb({int(cfg.deverb.amount * 100)}%)")
+    if cfg.proximity.enabled:
+        parts.append(f"Body({int(cfg.proximity.amount * 100)}%)")
+    if cfg.gate.enabled:
+        parts.append(f"Gate({int(cfg.gate.threshold_db)}dB)")
+    if cfg.eq_enabled and cfg.eq:
+        parts.append(f"EQ({len(cfg.eq)}b)")
+    if cfg.compressor.enabled:
+        parts.append("Comp")
+    return ", ".join(parts) if parts else "Bypass"
+
+
+def run_preset_list(app: AppConfig) -> None:
+    """List all available built-in and custom user presets."""
+    presets = list_presets()
+    t = Table(box=box.ROUNDED, header_style="bold cyan")
+    t.add_column("Status", justify="center", width=8)
+    t.add_column("Preset Name", style="bold white")
+    t.add_column("Type", justify="center")
+    t.add_column("DSP Stages Active", style="dim")
+    t.add_column("Description")
+
+    active_name = app.preset
+
+    for p in presets:
+        is_active = (p.name == active_name)
+        status_badge = "[bold green]● Active[/]" if is_active else "[dim]○[/]"
+        type_badge = "[green]Built-in[/]" if p.builtin else "[cyan]Custom[/]"
+
+        try:
+            cfg = get_preset(p.name)
+            summary = _format_summary(cfg)
+        except Exception:
+            summary = "Error reading"
+
+        t.add_row(status_badge, p.name, type_badge, summary, p.description)
+
+    console.print(t)
+    console.print(f"[dim]Presets directory: {user_preset_dir()}[/]")
+    console.print("[dim]Use `micforge preset save <name>` or `micforge live -p <name>`[/]")
+
+
+def run_preset_show(name: str) -> None:
+    """Show detailed JSON configuration for a preset."""
+    try:
+        cfg = get_preset(name)
+    except ConfigError as exc:
+        console.print(f"[bold red]✖ {exc}[/]")
+        return
+
+    console.print(f"[bold cyan]Preset:[/] [bold green]{name}[/]")
+    console.print_json(json.dumps(cfg.to_dict()))
+
+
+def run_preset_save(
+    app: AppConfig,
+    name: str,
+    from_preset: str | None = None,
+    description: str = "",
+    force: bool = False,
+) -> None:
+    """Save a preset (derived from current active config or an existing preset)."""
+    base_name = from_preset or app.preset
+    cfg = get_preset(base_name)
+    desc = description or f"Custom preset based on {base_name}"
+
+    path = save_preset(name, cfg, overwrite=force, description=desc)
+    console.print(f"[bold green]✔ Saved custom preset:[/] [bold white]{name}[/]")
+    console.print(f"  [dim]Location:[/] {path}")
+    console.print(f"  [dim]Run it with:[/] [cyan]micforge live -p {name}[/]")
+
+
+def run_preset_copy(source: str, target: str, force: bool = False) -> None:
+    """Copy an existing preset to a new custom preset."""
+    clone_preset(source, target, overwrite=force)
+    console.print(f"[bold green]✔ Duplicated preset:[/] [cyan]{source}[/] → [bold white]{target}[/]")
+    console.print(f"  [dim]Run it with:[/] [cyan]micforge live -p {target}[/]")
+
+
+def run_preset_delete(name: str, force: bool = False) -> None:
+    """Delete a custom user preset."""
+    if name in BUILTIN:
+        console.print(f"[bold red]✖ Cannot delete built-in preset '{name}'. Built-ins are permanent.[/]")
+        return
+
+    if not force:
+        # Prompt for confirmation in console
+        from rich.prompt import Confirm
+        if not Confirm.ask(f"Are you sure you want to permanently delete custom preset '{name}'?"):
+            console.print("[dim]Cancelled.[/]")
+            return
+
+    delete_preset(name)
+    console.print(f"[bold green]✔ Deleted preset:[/] [white]{name}[/]")
+
+
+def run_preset_export(name: str, target_path: str | None = None) -> None:
+    """Export a preset to a portable JSON file."""
+    dest = Path(target_path) if target_path else Path(f"{name}_preset.json")
+    out = export_preset(name, dest)
+    console.print(f"[bold green]✔ Exported preset '{name}' to:[/] [cyan]{out}[/]")
+
+
+def run_preset_import(source_path: str, name: str | None = None, force: bool = False) -> None:
+    """Import a preset JSON file."""
+    preset_name = import_preset(source_path, name=name, overwrite=force)
+    console.print(f"[bold green]✔ Successfully imported preset:[/] [bold white]{preset_name}[/]")
+    console.print(f"  [dim]Run it with:[/] [cyan]micforge live -p {preset_name}[/]")
+

micforge/commands/test_mic.py

@@ -0,0 +1,98 @@
+"""`test`: record -> process -> compare -> play back raw vs processed."""
+from __future__ import annotations
+
+import os
+import time
+
+import numpy as np
+from rich.live import Live
+from rich.prompt import Prompt
+from rich.text import Text
+
+from ..analysis.stats import analyze, band_levels_db, diagnose
+from ..audio.devices import find_device, list_devices
+from ..audio.fileio import write_wav
+from ..audio.recorder import Recorder, play
+from ..config import AppConfig, config_dir
+from ..dsp.chain import build_chain, process_offline
+from ..errors import MicforgeError
+from ..presets import get_preset
+from ..profile_store import load_profile
+from ..ui.report import full_report
+from ..ui.theme import console
+from ..ui.widgets import fmt_db, level_bar
+
+SILENCE_S = 2.0
+
+
+def record_clip(app: AppConfig, mic, seconds: float) -> np.ndarray:
+    pool = list_devices(all_apis=True)
+    dev = find_device(mic if mic is not None else app.input_device, "input", pool)
+    rec = Recorder(dev, app.sample_rate, app.input_channel, app.block_size)
+    console.print(f"[dim]Mic: {dev.name}[/]")
+    rec.start()
+    is_cmd = os.name == "nt" and "WT_SESSION" not in os.environ and "TERM_PROGRAM" not in os.environ
+    fps = 10 if is_cmd else 20
+    try:
+        with Live(console=console, refresh_per_second=fps, transient=True) as live:
+            while rec.seconds < seconds:
+                lv = rec.level
+                phase = ("[yellow]Stay SILENT[/] (measuring room noise)" if rec.seconds < SILENCE_S
+                         else "[bold green]Now SPEAK[/] naturally, like on a call")
+                t = Text.from_markup(f"{phase}   {rec.seconds:4.1f}/{seconds:.0f}s\n")
+                t.append_text(level_bar(lv.peak_db, lv.hold_db, max(20, console.width - 20)))
+                t.append(f" {fmt_db(lv.peak_db)} dB")
+                live.update(t)
+                time.sleep(0.04)
+    finally:
+        x = rec.stop()
+    return x
+
+
+def run_test(app: AppConfig, *, preset: str | None = None, seconds: float = 8.0, mic=None, out=None) -> None:
+    preset = preset or app.preset
+    pool = list_devices(all_apis=True)
+    speaker = find_device(out if out is not None else app.monitor_device, "output", pool)
+
+    raw = record_clip(app, mic, seconds)
+    if raw.shape[0] < app.sample_rate:
+        raise MicforgeError("Recording failed (no audio captured).")
+    sr = app.sample_rate
+
+    # Learn this room's noise from the silent lead-in, so the test reflects what calibration would give.
+    cfg = get_preset(preset)
+    chain = build_chain(cfg, sr, model_override=app.denoise_model)
+    dn = chain.stage("denoise")
+    try:
+        dn.learn(raw[: int(SILENCE_S * sr)])  # type: ignore[union-attr]
+    except ValueError:
+        prof = load_profile(sr)
+        if prof:
+            dn.set_profile(prof[0])  # type: ignore[union-attr]
+    proc = process_offline(chain, raw, app.block_size)
+
+    before, after = analyze(raw, sr), analyze(proc, sr)
+    console.print(full_report(before, after, band_levels_db(raw, sr), band_levels_db(proc, sr), diagnose(after)))
+
+    clips = {"1": ("raw", raw), "2": (f"processed ({preset})", proc)}
+    console.print("\n[dim]Playback via[/] " + speaker.name)
+    while True:
+        choice = Prompt.ask(
+            "\n[bold cyan]1[/] raw  [bold cyan]2[/] processed  [bold cyan]3[/] A/B  [bold cyan]s[/] save wavs  [bold cyan]q[/] done",
+            choices=["1", "2", "3", "s", "q"], default="3", console=console,
+        )
+        if choice == "q":
+            break
+        if choice == "s":
+            d = config_dir() / "recordings"
+            stamp = time.strftime("%Y%m%d-%H%M%S")
+            write_wav(d / f"{stamp}-raw.wav", raw, sr)
+            write_wav(d / f"{stamp}-{preset}.wav", proc, sr)
+            console.print(f"[green]Saved to {d}[/]")
+            continue
+        order = ["1", "2"] if choice == "3" else [choice]
+        for k in order:
+            label, data = clips[k]
+            console.print(f"  ▶ {label}")
+            play(data, sr, speaker)
+            time.sleep(0.25)