diff --git a/.gitignore b/.gitignore
index 48f411d..9020097 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,11 +3,6 @@
 .swiftpm/
 xcuserdata/
 DerivedData/
-# Your voice recordings and run output stay local.
-Eval/clips/*.wav
-Eval/clips/*.m4a
-Eval/results/
-
 # Personal signing settings (Team ID)
 App/Signing.local.xcconfig
 
diff --git a/CLAUDE.md b/CLAUDE.md
index 2945f49..40047db 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -4,5 +4,6 @@ Push-to-talk dictation: hold a key, speak, and cleaned-up text is pasted at the
 
 - **Murmur is the Rust workspace in `rust/`**, for macOS (the menu-bar app) and Linux (the Hyprland daemon). The crates and the interfaces between them are in [rust/CONTRACTS.md](rust/CONTRACTS.md); change it together with its callers. `cd rust && cargo test --workspace` runs the tests; CI (`.github/workflows/rust.yml`) also runs `cargo fmt --check` and `cargo clippy --workspace --all-targets -- -D warnings` on macOS and Linux.
 - **Linux (Hyprland/Omarchy):** if you're running on Linux, start with [rust/linux/README.md](rust/linux/README.md): setup, system packages, `rust/linux/install.sh`, the API key, Hyprland bindings, and a testing checklist.
-- **Swift, being retired:** the original macOS app (`App/`, `Core/`) and the eval (`Eval/`, macOS only) stay until the eval and the release scripts are ported. Don't add features there.
-- The cleanup prompt drives most of the quality. It lives in `rust/crates/murmur-core/src/prompt.rs` and, byte for byte, in `Core/Sources/MurmurKit/CleanupPrompt.swift`; a Rust test fails if they differ, so edit both. Check changes with the eval.
+- **Eval:** `murmur-eval` (`rust/crates/murmur-eval`) scores speech-to-text and the cleanup prompt against recordings in `rust/eval/clips/`; see "Eval harness" in the README.
+- **Swift, being retired:** the original macOS app (`App/`, `Core/`) stays until it's deleted. Don't add features there.
+- The cleanup prompt drives most of the quality. It lives in `rust/crates/murmur-core/src/prompt.rs` and, byte for byte, in `Core/Sources/MurmurKit/CleanupPrompt.swift`; a Rust test fails if they differ, so edit both. Check changes with `murmur-eval run` (and `--prompt <file>` for a draft).
diff --git a/Core/Sources/MurmurKit/CleanupPrompt.swift b/Core/Sources/MurmurKit/CleanupPrompt.swift
index 4af1031..0176a14 100644
--- a/Core/Sources/MurmurKit/CleanupPrompt.swift
+++ b/Core/Sources/MurmurKit/CleanupPrompt.swift
@@ -1,7 +1,7 @@
 import Foundation
 
 /// System prompt for the cleanup pass. Murmur's quality lives here, so treat edits like code changes and
-/// check them against the eval (`MurmurEval run`). `MurmurEval --prompt <file>` tries a draft without a rebuild.
+/// check them against the eval (`murmur-eval run`, in rust/). `murmur-eval --prompt <file>` tries a draft without a rebuild.
 public enum CleanupPrompt {
     /// What the model returns when there's nothing to type (see the Output section below).
     public static let emptyMarker = "<empty/>"
diff --git a/Eval/Package.resolved b/Eval/Package.resolved
deleted file mode 100644
index cfd8e9e..0000000
--- a/Eval/Package.resolved
+++ /dev/null
@@ -1,15 +0,0 @@
-{
-  "originHash" : "cd4dfd3df94ce26bc8aef1d393cb9ef95bad3227a1cafd44a76d6827ec7b9602",
-  "pins" : [
-    {
-      "identity" : "fluidaudio",
-      "kind" : "remoteSourceControl",
-      "location" : "https://github.com/FluidInference/FluidAudio.git",
-      "state" : {
-        "revision" : "503b4bd1bbf7220882de39fe8ae6716aae4132da",
-        "version" : "0.17.7"
-      }
-    }
-  ],
-  "version" : 3
-}
diff --git a/Eval/Package.swift b/Eval/Package.swift
deleted file mode 100644
index 872c63c..0000000
--- a/Eval/Package.swift
+++ /dev/null
@@ -1,25 +0,0 @@
-// swift-tools-version: 6.2
-import PackageDescription
-
-let package = Package(
-    name: "MurmurEval",
-    platforms: [.macOS(.v26)],
-    dependencies: [
-        .package(path: "../Core"),
-        .package(url: "https://github.com/FluidInference/FluidAudio.git", from: "0.17.7"),
-    ],
-    targets: [
-        .executableTarget(
-            name: "MurmurEval",
-            dependencies: [
-                .product(name: "MurmurCore", package: "Core"),
-                .product(name: "FluidAudio", package: "FluidAudio"),
-            ],
-            linkerSettings: [
-                // Embed an Info.plist so macOS shows the mic / speech permission prompts for this CLI.
-                .unsafeFlags(["-Xlinker", "-sectcreate", "-Xlinker", "__TEXT", "-Xlinker", "__info_plist",
-                              "-Xlinker", "Support/Info.plist"]),
-            ]
-        ),
-    ]
-)
diff --git a/Eval/Sources/MurmurEval/Clip.swift b/Eval/Sources/MurmurEval/Clip.swift
deleted file mode 100644
index 13a3e34..0000000
--- a/Eval/Sources/MurmurEval/Clip.swift
+++ /dev/null
@@ -1,52 +0,0 @@
-import Foundation
-import MurmurCore
-
-/// Where the eval keeps its inputs and outputs. Resolved from this source file's location so the
-/// CLI works no matter which directory `swift run` is invoked from.
-enum Paths {
-    static let evalRoot = URL(fileURLWithPath: #filePath)
-        .deletingLastPathComponent()  // MurmurEval
-        .deletingLastPathComponent()  // Sources
-        .deletingLastPathComponent()  // Eval
-    static let clips = evalRoot.appending(path: "clips")
-    static let results = evalRoot.appending(path: "results")
-}
-
-/// Sidecar metadata stored next to each recording as `<name>.json`.
-struct ClipMeta: Codable {
-    /// Exactly what was said, word for word. Used to score raw STT accuracy (WER).
-    var reference: String?
-    /// The text you would want typed. Used to eyeball (and later grade) the cleanup output.
-    var intended: String?
-    var context: TargetContext = .plain
-}
-
-struct Clip {
-    let name: String
-    let audio: URL
-    var meta: ClipMeta
-
-    static let audioExtensions: Set<String> = ["wav", "m4a", "caf", "aiff", "mp3"]
-
-    /// Every audio file in `clips/`, paired with its sidecar if one exists.
-    static func loadAll(from dir: URL = Paths.clips) throws -> [Clip] {
-        let files = try FileManager.default.contentsOfDirectory(at: dir, includingPropertiesForKeys: nil)
-        return try files
-            .filter { audioExtensions.contains($0.pathExtension.lowercased()) }
-            .sorted { $0.lastPathComponent < $1.lastPathComponent }
-            .map { audio in
-                let name = audio.deletingPathExtension().lastPathComponent
-                let sidecar = dir.appending(path: "\(name).json")
-                let meta = FileManager.default.fileExists(atPath: sidecar.path)
-                    ? try JSONDecoder().decode(ClipMeta.self, from: Data(contentsOf: sidecar))
-                    : ClipMeta()
-                return Clip(name: name, audio: audio, meta: meta)
-            }
-    }
-
-    static func saveMeta(_ meta: ClipMeta, name: String, in dir: URL = Paths.clips) throws {
-        let encoder = JSONEncoder()
-        encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
-        try encoder.encode(meta).write(to: dir.appending(path: "\(name).json"))
-    }
-}
diff --git a/Eval/Sources/MurmurEval/Recorder.swift b/Eval/Sources/MurmurEval/Recorder.swift
deleted file mode 100644
index 42a6ce9..0000000
--- a/Eval/Sources/MurmurEval/Recorder.swift
+++ /dev/null
@@ -1,41 +0,0 @@
-import AVFoundation
-import Foundation
-
-/// Records the default input device to a WAV file until the user presses Return.
-/// This is a stand-in for the app's push-to-talk capture: same engine, no hotkey yet.
-enum Recorder {
-    static func record(to url: URL) async throws -> TimeInterval {
-        guard await AVAudioApplication.requestRecordPermission() else {
-            throw EvalError("Microphone access was denied. Allow it for your terminal app in System Settings › Privacy & Security › Microphone.")
-        }
-
-        let engine = AVAudioEngine()
-        let input = engine.inputNode
-        let format = input.outputFormat(forBus: 0)
-        let file = try AVAudioFile(forWriting: url, settings: format.settings)
-
-        input.installTap(onBus: 0, bufferSize: 4096, format: format) { buffer, _ in
-            try? file.write(from: buffer)
-        }
-        try engine.start()
-        let started = Date()
-
-        print("● Recording… press Return to stop.")
-        await withCheckedContinuation { (done: CheckedContinuation<Void, Never>) in
-            Thread.detachNewThread {
-                _ = readLine()
-                done.resume()
-            }
-        }
-
-        input.removeTap(onBus: 0)
-        engine.stop()
-        return Date().timeIntervalSince(started)
-    }
-}
-
-/// Duration of any audio file AVFoundation can read.
-func audioDuration(_ url: URL) -> TimeInterval {
-    guard let file = try? AVAudioFile(forReading: url) else { return 0 }
-    return Double(file.length) / file.processingFormat.sampleRate
-}
diff --git a/Eval/Sources/MurmurEval/Report.swift b/Eval/Sources/MurmurEval/Report.swift
deleted file mode 100644
index 5101b0b..0000000
--- a/Eval/Sources/MurmurEval/Report.swift
+++ /dev/null
@@ -1,122 +0,0 @@
-import Foundation
-import MurmurCore
-
-struct EngineResult: Codable {
-    let engine: String
-    let raw: String
-    let sttSeconds: Double
-    let wer: Double?
-    var cleaned: String?
-    var cleanupSeconds: Double?
-    var error: String?
-}
-
-struct ClipResult: Codable {
-    let clip: String
-    let context: TargetContext
-    let audioSeconds: Double
-    let reference: String?
-    let intended: String?
-    var engines: [EngineResult]
-}
-
-// MARK: - Word error rate
-
-/// Lowercase, drop punctuation (keeping apostrophes inside words), split on whitespace.
-func normalizedWords(_ text: String) -> [String] {
-    let kept = text.lowercased().unicodeScalars.map { scalar -> Character in
-        CharacterSet.alphanumerics.contains(scalar) || scalar == "'" ? Character(scalar) : " "
-    }
-    return String(kept).split(separator: " ").map { $0.trimmingCharacters(in: CharacterSet(charactersIn: "'")) }
-        .filter { !$0.isEmpty }
-}
-
-/// (substitutions + deletions + insertions) / reference length, via word-level edit distance.
-func wordErrorRate(hypothesis: String, reference: String) -> Double {
-    let ref = normalizedWords(reference)
-    let hyp = normalizedWords(hypothesis)
-    guard !ref.isEmpty else { return hyp.isEmpty ? 0 : 1 }
-    var previous = Array(0...hyp.count)
-    for i in 1...ref.count {
-        var current = [i] + Array(repeating: 0, count: hyp.count)
-        for j in stride(from: 1, through: hyp.count, by: 1) {
-            let cost = ref[i - 1] == hyp[j - 1] ? 0 : 1
-            current[j] = min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + cost)
-        }
-        previous = current
-    }
-    return Double(previous[hyp.count]) / Double(ref.count)
-}
-
-// MARK: - Output
-
-enum Report {
-    /// Writes `results/<timestamp>.md` (for reading) and `.json` (for diffing runs later).
-    static func write(_ results: [ClipResult], engines: [String]) throws -> URL {
-        try FileManager.default.createDirectory(at: Paths.results, withIntermediateDirectories: true)
-        let stamp = ISO8601DateFormatter().string(from: Date()).replacingOccurrences(of: ":", with: "-")
-        let base = Paths.results.appending(path: stamp)
-
-        let encoder = JSONEncoder()
-        encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
-        try encoder.encode(results).write(to: base.appendingPathExtension("json"))
-
-        let markdown = render(results, engines: engines)
-        let mdURL = base.appendingPathExtension("md")
-        try markdown.write(to: mdURL, atomically: true, encoding: .utf8)
-        return mdURL
-    }
-
-    static func summaryTable(_ results: [ClipResult], engines: [String]) -> String {
-        var lines = ["| Engine | Mean WER | Mean STT latency | Mean cleanup latency |",
-                     "|---|---|---|---|"]
-        for engine in engines {
-            let rows = results.flatMap(\.engines).filter { $0.engine == engine && $0.error == nil }
-            let wers = rows.compactMap(\.wer)
-            let stt = rows.map(\.sttSeconds)
-            let cleanup = rows.compactMap(\.cleanupSeconds)
-            lines.append("| \(engine) | \(wers.isEmpty ? "–" : pct(mean(wers))) | \(stt.isEmpty ? "–" : ms(mean(stt))) | \(cleanup.isEmpty ? "–" : ms(mean(cleanup))) |")
-        }
-        return lines.joined(separator: "\n")
-    }
-
-    private static func render(_ results: [ClipResult], engines: [String]) -> String {
-        var out = "# Murmur eval: \(Date().formatted(date: .abbreviated, time: .shortened))\n\n"
-        out += "WER is measured on the **raw** STT output against each clip's verbatim `reference`.\n\n"
-        out += summaryTable(results, engines: engines) + "\n"
-
-        for clip in results {
-            out += "\n---\n\n## \(clip.clip)\n\n"
-            out += "`\(clip.context.rawValue)` · \(String(format: "%.1f", clip.audioSeconds))s audio\n\n"
-            if let reference = clip.reference { out += "**Reference (verbatim):** \(reference)\n\n" }
-            if let intended = clip.intended { out += "**Intended:**\n\n\(quote(intended))\n\n" }
-            for engine in clip.engines {
-                out += "### \(engine.engine)\n\n"
-                if let error = engine.error {
-                    out += "> ⚠️ \(error)\n\n"
-                    continue
-                }
-                let wer = engine.wer.map { " · WER \(pct($0))" } ?? ""
-                out += "Raw, \(ms(engine.sttSeconds))\(wer):\n\n\(quote(engine.raw))\n\n"
-                if let cleaned = engine.cleaned {
-                    out += "Cleaned, \(ms(engine.cleanupSeconds ?? 0)):\n\n\(quote(cleaned))\n\n"
-                }
-            }
-        }
-        return out
-    }
-
-    private static func quote(_ text: String) -> String {
-        text.isEmpty ? "> _(empty)_" : text.split(separator: "\n", omittingEmptySubsequences: false)
-            .map { "> \($0)" }.joined(separator: "\n")
-    }
-}
-
-func mean(_ values: [Double]) -> Double { values.reduce(0, +) / Double(max(values.count, 1)) }
-func pct(_ value: Double) -> String { String(format: "%.1f%%", value * 100) }
-func ms(_ seconds: Double) -> String { String(format: "%.0f ms", seconds * 1000) }
-
-struct EvalError: Error, CustomStringConvertible {
-    let description: String
-    init(_ description: String) { self.description = description }
-}
diff --git a/Eval/Sources/MurmurEval/STTEngines.swift b/Eval/Sources/MurmurEval/STTEngines.swift
deleted file mode 100644
index 4e3a69e..0000000
--- a/Eval/Sources/MurmurEval/STTEngines.swift
+++ /dev/null
@@ -1,21 +0,0 @@
-import MurmurCore
-
-/// Engines the eval can compare, by command-line name.
-enum Engines {
-    static let all: [String: @Sendable () -> any STTEngine] = [
-        "parakeet": { ParakeetEngine(id: "parakeet", version: .v3) },
-        "parakeet-v2": { ParakeetEngine(id: "parakeet-v2", version: .v2) },
-        "parakeet-ultra": { ParakeetEngine(id: "parakeet-ultra", version: .ultra) },
-        "apple": { AppleSpeechEngine() },
-    ]
-    static let defaults = ["parakeet", "apple"]
-
-    static func make(_ ids: [String]) throws -> [any STTEngine] {
-        try ids.map { id in
-            guard let factory = all[id] else {
-                throw EvalError("Unknown engine '\(id)'. Available: \(all.keys.sorted().joined(separator: ", "))")
-            }
-            return factory()
-        }
-    }
-}
diff --git a/Eval/Sources/MurmurEval/main.swift b/Eval/Sources/MurmurEval/main.swift
deleted file mode 100644
index 53b520b..0000000
--- a/Eval/Sources/MurmurEval/main.swift
+++ /dev/null
@@ -1,263 +0,0 @@
-import Foundation
-import FluidAudio
-import MurmurCore
-
-let usage = """
-murmur-eval: compare speech-to-text engines and the Claude cleanup pass on your own voice.
-
-USAGE
-  swift run MurmurEval record <name> [--context plain|chat|email|notes|code]
-      Record a clip from the mic into clips/<name>.wav, then type what you said.
-
-  swift run MurmurEval run [--engines parakeet,apple] [--no-cleanup] [--thinking] [--cleaner claude|ollama:<model>] [--prompt draft.md]
-      Transcribe every clip in clips/ with each engine, clean each transcript with Claude,
-      and write a report to results/.
-
-  swift run MurmurEval clean "<raw transcript>" [--context notes]
-      Run only the cleanup pass on a string. Add --prompt draft.md to try a prompt edit before
-      moving it into Core/Sources/MurmurKit/CleanupPrompt.swift.
-
-  swift run MurmurEval bench [--cleaner claude|ollama:<model>] [--runs 3]
-      Time a cleaner on built-in test dictations and show its output.
-
-  swift run MurmurEval vad <audio files…>
-      Show how much voiced audio each file has, and whether Murmur would transcribe it.
-
-  swift run MurmurEval devices
-      List audio input devices (* = system default).
-
-Engines: \(Engines.all.keys.sorted().joined(separator: ", ")) (default: \(Engines.defaults.joined(separator: ",")))
-All commands use your Murmur dictionary (or --dictionary <file> / none). Cleanup defaults to claude-haiku-5-5. The key comes from ANTHROPIC_API_KEY or the Keychain item com.plyhdrn.murmur.
-"""
-
-/// Minimal flag parsing: `--key value`, `--flag`, and positionals.
-struct Args {
-    var positionals: [String] = []
-    var options: [String: String] = [:]
-    var flags: Set<String> = []
-
-    init(_ raw: [String], valued: Set<String>) {
-        var it = raw.makeIterator()
-        while let arg = it.next() {
-            if arg.hasPrefix("--") {
-                let key = String(arg.dropFirst(2))
-                if valued.contains(key), let value = it.next() { options[key] = value } else { flags.insert(key) }
-            } else {
-                positionals.append(arg)
-            }
-        }
-    }
-
-    func context() throws -> TargetContext {
-        guard let raw = options["context"] else { return .plain }
-        guard let context = TargetContext(rawValue: raw) else {
-            throw EvalError("Unknown context '\(raw)'. Use one of: \(TargetContext.allCases.map(\.rawValue).joined(separator: ", "))")
-        }
-        return context
-    }
-}
-
-/// The personal dictionary the app uses (`~/Library/Application Support/Murmur/dictionary.json`),
-/// another file with `--dictionary <path>`, or none with `--dictionary none`, so evals run with
-/// your real words and replacements.
-func loadDictionary(_ args: Args) throws -> PersonalDictionary {
-    if args.options["dictionary"] == "none" { return PersonalDictionary() }
-    let url = args.options["dictionary"].map { URL(fileURLWithPath: $0) } ?? PersonalDictionary.defaultURL
-    return try PersonalDictionary.load(from: url)
-}
-
-/// Builds the cleanup pass from flags: `--cleaner claude|ollama:<model>` (default claude),
-/// `--thinking` / `--effort` for Claude, and `--prompt <file>` to try a draft system prompt
-/// without rebuilding. Returns nil when Claude is chosen but no API key is available.
-func makeCleaner(_ args: Args) throws -> (any TextCleaner)? {
-    let system = try args.options["prompt"].map { try String(contentsOfFile: $0, encoding: .utf8) }
-        ?? CleanupPrompt.system
-    let vocabulary = try loadDictionary(args).vocabulary
-    let choice = args.options["cleaner"] ?? "claude"
-
-    if choice.hasPrefix("ollama:") {
-        return OllamaCleaner(model: String(choice.dropFirst("ollama:".count)), systemPrompt: system, vocabulary: vocabulary)
-    }
-    guard choice == "claude" else { throw EvalError("Unknown cleaner '\(choice)'. Use claude or ollama:<model>.") }
-
-    guard let key = APIKey.load() else { return nil }
-    var options = ClaudeCleaner.Options()
-    options.thinking = args.flags.contains("thinking")
-    options.structuredReply = !args.flags.contains("plain-reply")
-    if let effort = args.options["effort"] { options.effort = effort }
-    return ClaudeCleaner(apiKey: key, systemPrompt: system, vocabulary: vocabulary, options: options)
-}
-
-func prompt(_ question: String) -> String? {
-    print(question, terminator: " ")
-    let answer = readLine()?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
-    return answer.isEmpty ? nil : answer
-}
-
-func timed<T>(_ work: () async throws -> T) async rethrows -> (T, Double) {
-    let start = ContinuousClock.now
-    let value = try await work()
-    let elapsed = ContinuousClock.now - start
-    return (value, Double(elapsed.components.seconds) + Double(elapsed.components.attoseconds) / 1e18)
-}
-
-// MARK: - Commands
-
-func record(_ args: Args) async throws {
-    guard let name = args.positionals.first else { throw EvalError("record needs a clip name") }
-    let context = try args.context()
-    try FileManager.default.createDirectory(at: Paths.clips, withIntermediateDirectories: true)
-    let url = Paths.clips.appending(path: "\(name).wav")
-
-    let seconds = try await Recorder.record(to: url)
-    print("Saved \(url.lastPathComponent) (\(String(format: "%.1f", seconds))s)\n")
-
-    var meta = ClipMeta(context: context)
-    meta.reference = prompt("Type exactly what you said, word for word (Return to skip):")
-    meta.intended = prompt("Type what you'd want it to come out as (Return to skip):")
-    try Clip.saveMeta(meta, name: name)
-    print("Saved \(name).json")
-}
-
-func run(_ args: Args) async throws {
-    let engineIDs = args.options["engines"]?.split(separator: ",").map(String.init) ?? Engines.defaults
-    let engines = try Engines.make(engineIDs)
-    let clips = try Clip.loadAll()
-    let dictionary = try loadDictionary(args)
-    guard !clips.isEmpty else { throw EvalError("No clips in \(Paths.clips.path). Record one with `record <name>`.") }
-
-    var cleaner: (any TextCleaner)?
-    if !args.flags.contains("no-cleanup") {
-        cleaner = try makeCleaner(args)
-        try await cleaner?.prepare()
-        if cleaner == nil { print("⚠️  No Anthropic API key found (env or Keychain), so the cleanup pass is skipped.\n") }
-    }
-
-    for engine in engines {
-        print("Preparing \(engine.id)…")
-        try await engine.prepare()
-        // Warm-up so the first clip's latency doesn't include Neural Engine model compilation.
-        _ = try? await engine.transcribe(file: clips[0].audio)
-    }
-
-    var results: [ClipResult] = []
-    for clip in clips {
-        print("\n▸ \(clip.name)")
-        var clipResult = ClipResult(clip: clip.name, context: clip.meta.context,
-                                    audioSeconds: audioDuration(clip.audio),
-                                    reference: clip.meta.reference, intended: clip.meta.intended, engines: [])
-        for engine in engines {
-            do {
-                let (raw, sttSeconds) = try await timed { try await engine.transcribe(file: clip.audio) }
-                let wer = clip.meta.reference.map { wordErrorRate(hypothesis: raw, reference: $0) }
-                var result = EngineResult(engine: engine.id, raw: raw, sttSeconds: sttSeconds, wer: wer)
-                print("  \(engine.id) [\(ms(sttSeconds))\(wer.map { ", WER \(pct($0))" } ?? "")]: \(raw)")
-
-                if let cleaner {
-                    do {
-                        let (cleaned, cleanupSeconds) = try await timed {
-                            try await cleaner.clean(dictionary.applyReplacements(to: raw), context: clip.meta.context)
-                        }
-                        result.cleaned = cleaned
-                        result.cleanupSeconds = cleanupSeconds
-                        print("    ↳ cleaned [\(ms(cleanupSeconds))]: \(cleaned.replacingOccurrences(of: "\n", with: " ⏎ "))")
-                    } catch {
-                        result.error = "Cleanup failed: \(error)"
-                        print("    ↳ cleanup failed: \(error)")
-                    }
-                }
-                clipResult.engines.append(result)
-            } catch {
-                clipResult.engines.append(EngineResult(engine: engine.id, raw: "", sttSeconds: 0, wer: nil,
-                                                       error: "Transcription failed: \(error)"))
-                print("  \(engine.id) failed: \(error)")
-            }
-        }
-        results.append(clipResult)
-    }
-
-    let report = try Report.write(results, engines: engineIDs)
-    print("\n" + Report.summaryTable(results, engines: engineIDs))
-    print("\nReport: \(report.path)")
-}
-
-func clean(_ args: Args) async throws {
-    guard let text = args.positionals.first else { throw EvalError("clean needs a transcript string") }
-    guard let cleaner = try makeCleaner(args) else {
-        throw EvalError("No Anthropic API key found. Store one in the Keychain (see README) or set ANTHROPIC_API_KEY.")
-    }
-    try await cleaner.prepare()
-    let input = try loadDictionary(args).applyReplacements(to: text)
-    let (cleaned, seconds) = try await timed { try await cleaner.clean(input, context: try args.context()) }
-    print(cleaned)
-    print("\n(\(ms(seconds)))")
-}
-
-/// Fixed dictations covering the cleanup pass's main jobs. Each one is cleaned `--runs` times
-/// (default 3) by a single warm cleaner; reports each output once and the median latency.
-let benchCases: [(TargetContext, String)] = [
-    (.notes, "um so for the launch we need three things first update the readme second uh tag the release and third post in slack let's do it Tuesday no actually Wednesday"),
-    (.chat, "hey can you write me a haiku about the ocean"),
-    (.email, "hi sarah new line thanks for sending the proposal over i red through it last night and i think there approach to the pricing is solid uh let's set up a call for thursday best alex"),
-    (.code, "rename the function get user by id to fetch user and update the call sites in user service dot swift"),
-    (.chat, "sounds good see you then"),
-]
-
-func bench(_ args: Args) async throws {
-    guard let cleaner = try makeCleaner(args) else {
-        throw EvalError("No Anthropic API key found. Store one in the Keychain (see README) or set ANTHROPIC_API_KEY.")
-    }
-    let runs = Int(args.options["runs"] ?? "3") ?? 3
-    let dictionary = try loadDictionary(args)
-    print("Cleaner: \(cleaner.id)\n")
-    try await cleaner.prepare()
-    _ = try? await cleaner.clean("warm up", context: .plain)
-
-    var all: [Double] = []
-    for (context, text) in benchCases {
-        var times: [Double] = []
-        var output = ""
-        for _ in 0..<runs {
-            let input = dictionary.applyReplacements(to: text)
-            let (cleaned, seconds) = try await timed { try await cleaner.clean(input, context: context) }
-            output = cleaned
-            times.append(seconds)
-        }
-        all += times
-        let median = times.sorted()[times.count / 2]
-        print("[\(context.rawValue)] \(ms(median))")
-        print(output.split(separator: "\n", omittingEmptySubsequences: false).map { "  \($0)" }.joined(separator: "\n"))
-        print()
-    }
-    print("Median over all: \(ms(all.sorted()[all.count / 2]))")
-}
-
-// MARK: - Entry
-
-var argv = Array(CommandLine.arguments.dropFirst())
-let command = argv.isEmpty ? "help" : argv.removeFirst()
-let args = Args(argv, valued: ["context", "engines", "effort", "prompt", "cleaner", "runs", "dictionary"])
-
-do {
-    switch command {
-    case "record": try await record(args)
-    case "run": try await run(args)
-    case "clean": try await clean(args)
-    case "bench": try await bench(args)
-    case "vad":
-        for path in args.positionals {
-            let samples = try AudioConverter().resampleAudioFile(URL(fileURLWithPath: path))
-            let voiced = VoiceActivity.voicedDuration(samples)
-            print("\(URL(fileURLWithPath: path).lastPathComponent): \(String(format: "%.2f", voiced))s voiced of \(String(format: "%.2f", Double(samples.count) / sttSampleRate))s → \(VoiceActivity.containsSpeech(samples) ? "speech" : "skip")")
-        }
-    case "devices":
-        let defaultUID = AudioDevices.defaultInput()?.uid
-        for device in AudioDevices.inputs() {
-            print("\(device.uid == defaultUID ? "*" : " ") \(device.name)  [\(device.uid)]")
-        }
-    default: print(usage)
-    }
-} catch {
-    FileHandle.standardError.write(Data("error: \(error)\n".utf8))
-    exit(1)
-}
diff --git a/Eval/Support/Info.plist b/Eval/Support/Info.plist
deleted file mode 100644
index f6729e3..0000000
--- a/Eval/Support/Info.plist
+++ /dev/null
@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>CFBundleIdentifier</key>
-    <string>com.plyhdrn.murmur.eval</string>
-    <key>CFBundleName</key>
-    <string>MurmurEval</string>
-    <key>NSMicrophoneUsageDescription</key>
-    <string>Murmur records dictation clips for the evaluation harness.</string>
-    <key>NSSpeechRecognitionUsageDescription</key>
-    <string>Murmur transcribes clips with Apple's on-device speech model.</string>
-</dict>
-</plist>
diff --git a/README.md b/README.md
index 82f66bc..ade8013 100644
--- a/README.md
+++ b/README.md
@@ -21,8 +21,8 @@ Most of the quality comes from the cleanup pass. It fixes misheard words, drops
 |---|---|
 | [`rust/`](rust) | **Murmur.** One Rust workspace for both platforms: the macOS menu-bar app and the Linux daemon share the dictation engine, cleanup prompt, Dictionary and speech model. Crates are described in [`rust/README.md`](rust/README.md) and [`rust/CONTRACTS.md`](rust/CONTRACTS.md). |
 | [`rust/linux/`](rust/linux) | Linux setup: the install script, Hyprland bindings and the Omarchy pill and bar menu. Start with [`rust/linux/README.md`](rust/linux/README.md). |
-| [`App/`](App), [`Core/`](Core) | The original Swift macOS app and its `MurmurKit`/`MurmurCore` packages. Kept until the eval and the release scripts move to Rust; `Core/Sources/MurmurKit/CleanupPrompt.swift` is still the prompt's reference copy (see [The Swift app](#the-swift-app)). |
-| [`Eval/`](Eval) | Swift CLI harness that scores speech engines and the cleanup prompt against recordings of your voice. macOS only. |
+| [`rust/eval/`](rust/eval) | Recordings of your voice for the [eval](#eval-harness), and its reports. Both stay local. |
+| [`App/`](App), [`Core/`](Core) | The original Swift macOS app and its `MurmurKit`/`MurmurCore` packages, being retired. `Core/Sources/MurmurKit/CleanupPrompt.swift` is a copy of the cleanup prompt that a Rust test keeps in step (see [The Swift app](#the-swift-app)). |
 
 Murmur is open source and isn't distributed as a prebuilt app: you build it on the machine that runs it.
 
@@ -93,37 +93,38 @@ On Linux, it's read from the Secret Service keyring; [`rust/linux/README.md`](ru
 
 ## Eval harness
 
-Still Swift, so it runs the Swift engines (Parakeet on the Neural Engine through FluidAudio, and Apple's speech) rather than the Rust app's sherpa-onnx build; the cleanup prompt is byte-for-byte the same, so prompt results carry over. Requires macOS 26 and Xcode 26. The first run downloads the Parakeet models (~500 MB) and Apple's speech assets. It uses the same [API key](#api-key).
+`murmur-eval` scores speech-to-text and the cleanup prompt against recordings of your voice, with the same speech model, prompt and Dictionary as the app. It runs on macOS and Linux, and uses the same [API key](#api-key). The first run downloads the speech model if the app hasn't already.
 
 ```bash
-cd Eval
-swift build
+cd rust
+cargo build --release -p murmur-eval
+E=target/release/murmur-eval
 
 # Record clips. After each one, type what you said verbatim (for WER) and what you'd want typed.
-.build/debug/MurmurEval record standup --context chat
-.build/debug/MurmurEval record todo-list --context notes
+$E record standup --context chat
+$E record todo-list --context notes
 
-# Transcribe every clip with each engine, clean each transcript, and write a report to results/.
-.build/debug/MurmurEval run
-.build/debug/MurmurEval run --engines parakeet,parakeet-ultra,apple
+# Transcribe every clip, clean each transcript, and write a report to eval/results/.
+$E run
+$E run --models ~/models/parakeet-a,~/models/parakeet-b   # compare sherpa-onnx model folders
 
 # Time a cleaner on built-in test dictations: claude (default) or ollama:<model>.
-.build/debug/MurmurEval bench --cleaner ollama:qwen3.5:9b
+$E bench --cleaner ollama:qwen3.5:9b
 
 # Try the cleanup pass without audio. Add --prompt draft.md to test a prompt edit.
-.build/debug/MurmurEval clean "um so first update the readme second tag the release" --context notes
+$E clean "um so first update the readme second tag the release" --context notes
 ```
 
-Run the binary directly rather than `swift run`, so macOS attributes the mic prompt to your terminal.
+`$E help` lists every command and option. On macOS the microphone prompt is for your terminal app, which records on its behalf.
 
-- **Clips** live in `Eval/clips/` as `<name>.wav` plus a `<name>.json` sidecar (`reference`, `intended`, `context`). Any `.wav`/`.m4a` you drop in works too. Audio is gitignored.
+- **Clips** live in `rust/eval/clips/` as `<name>.wav` plus a `<name>.json` sidecar (`reference`, `intended`, `context`). Any WAV file you drop in works too. Audio and reports are gitignored.
 - **Contexts**: `plain`, `chat`, `email`, `notes`, `code`. They set how the cleanup pass formats output.
 - **Dictionary**: every command uses the app's dictionary (`dictionary.json`) so results match real use. Pass `--dictionary <file>` to try another, or `--dictionary none` for none.
-- **Cleanup prompt**: edit `Core/Sources/MurmurKit/CleanupPrompt.swift` and `rust/crates/murmur-core/src/prompt.rs` together; a Rust test fails if they differ. Try a draft first with `--prompt draft.md`.
+- **Cleanup prompt**: `rust/crates/murmur-core/src/prompt.rs`. Try a draft first with `--prompt draft.md`. Until the Swift app is deleted, a test keeps `Core/Sources/MurmurKit/CleanupPrompt.swift` byte-for-byte the same, so edit both.
 
 ## The Swift app
 
-The original macOS app, in `App/` and `Core/`, kept until the eval is ported. It needs Xcode 26 and XcodeGen, and signs with the same [self-signed certificate](#signing):
+The original macOS app, in `App/` and `Core/`, being retired. It needs Xcode 26 and XcodeGen, and signs with the same [self-signed certificate](#signing):
 
 ```bash
 brew install xcodegen   # once
diff --git a/ROADMAP.md b/ROADMAP.md
index 734b526..65ac386 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -6,7 +6,7 @@ Ideas for what's next, roughly in priority order. Nothing here is committed to;
 
 - [ ] **"Fix…" on recent dictations.** From the menu's recent dictations, correct a word and save it straight to the Dictionary as a replacement. The closest thing to learning from your edits.
 - [ ] **Hear your Words right the first time.** Bias Parakeet toward the Dictionary's Words with FluidAudio's vocabulary boosting (`configureVocabularyBoosting`), so the speech recognizer itself gets names right instead of the cleanup step fixing them afterwards. Likely needs an extra model download; measure with the eval before and after.
-- [ ] **Try other local cleanup models.** `qwen3.5:9b` sometimes drops "yeah" in "yeah, okay" and invents headings in notes. Compare newer small models with `MurmurEval bench --cleaner ollama:<model>`.
+- [ ] **Try other local cleanup models.** `qwen3.5:9b` sometimes drops "yeah" in "yeah, okay" and invents headings in notes. Compare newer small models with `murmur-eval bench --cleaner ollama:<model>`.
 
 ## Speed
 
@@ -23,7 +23,6 @@ Murmur is build-it-yourself: no prebuilt releases, Developer ID or notarization.
 
 ## Retire the Swift app
 
-- [ ] **Port the eval to Rust.** `murmur eval record/run/bench/clean` against the sherpa-onnx Parakeet the app actually runs, then delete `Eval/`.
 - [ ] **Make `prompt.rs` the only copy of the cleanup prompt.** Drop the test that compares it with `CleanupPrompt.swift`.
 - [ ] **Install the Rust app on macOS.** A script that runs `rust/scripts/bundle-macos.sh` and copies the app to `~/Applications`, like `scripts/install.sh` does for the Swift app, so it runs from a stable path rather than `rust/target/`.
 - [ ] **Take over the bundle ID.** Once the Swift app is gone, move from `com.plyhdrn.murmur-rs` to `com.plyhdrn.murmur`.
diff --git a/rust/.gitignore b/rust/.gitignore
index ea8c4bf..aef244e 100644
--- a/rust/.gitignore
+++ b/rust/.gitignore
@@ -1 +1,4 @@
 /target
+# Eval recordings and reports stay local.
+/eval/clips/*.wav
+/eval/results/
diff --git a/rust/CONTRACTS.md b/rust/CONTRACTS.md
index 1fe159a..20bc24c 100644
--- a/rust/CONTRACTS.md
+++ b/rust/CONTRACTS.md
@@ -255,3 +255,10 @@ pub fn cleaner(mode: CleanupMode, ollama_model: &str, vocabulary: Vec<String>)
   the main thread, which broadcasts `queue`, `state`, `level` and `notice` lines to watchers;
   a notice nobody watched goes to `notify()`. `config.json`'s `model` and `threads` become
   `Options`.
+
+## murmur-eval (a binary, on every OS)
+
+Uses only the APIs above: `load_model` with `Options` for each model folder it compares,
+`Transcriber::transcribe`, `Recorder` and `load_wav` for clips, `load_dictionary`, and
+`ClaudeCleaner`/`OllamaCleaner` with their public `system_prompt` and `options` set from its
+flags (`--prompt`, `--thinking`, `--effort`, `--plain-reply`). Nothing depends on it.
diff --git a/rust/Cargo.lock b/rust/Cargo.lock
index b90d3d3..8f103b9 100644
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -1892,6 +1892,20 @@ dependencies = [
  "murmur-stt",
 ]
 
+[[package]]
+name = "murmur-eval"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "hound",
+ "murmur-audio",
+ "murmur-core",
+ "murmur-engine",
+ "murmur-stt",
+ "serde",
+ "serde_json",
+]
+
 [[package]]
 name = "murmur-platform"
 version = "0.1.0"
diff --git a/rust/README.md b/rust/README.md
index 506662e..6f33ebf 100644
--- a/rust/README.md
+++ b/rust/README.md
@@ -1,8 +1,8 @@
 # Murmur
 
 Murmur, the push-to-talk dictation app: one codebase for macOS and Linux, with Windows to come.
-It replaces the Swift app in `../App`, which stays only until the eval and the release scripts
-are ported (see the [roadmap](../ROADMAP.md#retire-the-swift-app)). The crates and the interfaces
+It replaces the Swift app in `../App`, which is being retired (see the
+[roadmap](../ROADMAP.md#retire-the-swift-app)). The crates and the interfaces
 between them are described in [CONTRACTS.md](CONTRACTS.md); user-facing setup is in the
 [top-level README](../README.md).
 
@@ -15,6 +15,7 @@ between them are described in [CONTRACTS.md](CONTRACTS.md); user-facing setup is
 | `murmur-control` | The Linux daemon's control socket and its line protocol (Unix only) |
 | `murmur-engine` | The dictation loop both front ends share: recording, the queue, transcribe → Dictionary → cleanup → paste, model loading, warm-ups, notices |
 | `murmur` | The binary. macOS: the tray app (menu, recording pill, Dictionary window, launch at login). Linux: the CLI and daemon |
+| `murmur-eval` | The eval: records clips, scores the transcript (WER) and cleanup against them, and times cleaners. macOS and Linux; see "Eval harness" in the [top-level README](../README.md#eval-harness) |
 
 ## macOS
 
@@ -55,4 +56,4 @@ CI runs all three on macOS and Linux. `scripts/linux-docker-test.sh` runs them i
 
 ## Not yet
 
-Windows, and the eval (still the Swift one in `../Eval`).
+Windows.
diff --git a/rust/crates/murmur-eval/Cargo.toml b/rust/crates/murmur-eval/Cargo.toml
new file mode 100644
index 0000000..2384e1f
--- /dev/null
+++ b/rust/crates/murmur-eval/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "murmur-eval"
+edition.workspace = true
+version.workspace = true
+license.workspace = true
+
+[dependencies]
+anyhow.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+murmur-core.workspace = true
+murmur-stt.workspace = true
+murmur-audio.workspace = true
+murmur-engine.workspace = true
+# Writing recorded clips.
+hound = "3.5.1"
diff --git a/rust/crates/murmur-eval/build.rs b/rust/crates/murmur-eval/build.rs
new file mode 100644
index 0000000..5912ddc
--- /dev/null
+++ b/rust/crates/murmur-eval/build.rs
@@ -0,0 +1,7 @@
+// On macOS sherpa-onnx is linked as shared libraries, which its build script copies next to the
+// binary in target/; its own rpath flags only apply to its crate, so set one here.
+fn main() {
+    if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("macos") {
+        println!("cargo:rustc-link-arg-bins=-Wl,-rpath,@executable_path");
+    }
+}
diff --git a/rust/crates/murmur-eval/src/clip.rs b/rust/crates/murmur-eval/src/clip.rs
new file mode 100644
index 0000000..f00d8ff
--- /dev/null
+++ b/rust/crates/murmur-eval/src/clip.rs
@@ -0,0 +1,88 @@
+//! The clips the eval scores: `<name>.wav` recordings in `eval/clips/`, each with an optional
+//! `<name>.json` sidecar saying what was said and what should have been typed.
+
+use std::path::{Path, PathBuf};
+
+use anyhow::Context;
+use murmur_core::TargetContext;
+use serde::{Deserialize, Serialize};
+
+/// `rust/eval/`, found from this crate's location so the eval works from any directory.
+pub fn eval_dir() -> PathBuf {
+    let crates = Path::new(env!("CARGO_MANIFEST_DIR")).parent().unwrap_or(Path::new("."));
+    crates.parent().unwrap_or(crates).join("eval")
+}
+
+pub fn clips_dir() -> PathBuf {
+    eval_dir().join("clips")
+}
+
+pub fn results_dir() -> PathBuf {
+    eval_dir().join("results")
+}
+
+/// The sidecar, `<name>.json`. Same fields as the Swift eval's, so its clips work unchanged.
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
+pub struct ClipMeta {
+    /// Exactly what was said, word for word. Scores the raw transcript (WER).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub reference: Option<String>,
+    /// The text you'd want typed. For reading against the cleanup output.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub intended: Option<String>,
+    #[serde(default)]
+    pub context: TargetContext,
+}
+
+pub struct Clip {
+    pub name: String,
+    pub audio: PathBuf,
+    pub meta: ClipMeta,
+}
+
+/// Every `.wav` in `dir`, by name, each with its sidecar if there is one.
+pub fn load_all(dir: &Path) -> anyhow::Result<Vec<Clip>> {
+    let entries = std::fs::read_dir(dir).with_context(|| format!("couldn't read {}", dir.display()))?;
+    let mut audio: Vec<PathBuf> = entries
+        .filter_map(|e| e.ok().map(|e| e.path()))
+        .filter(|p| p.extension().is_some_and(|ext| ext.eq_ignore_ascii_case("wav")))
+        .collect();
+    audio.sort();
+    audio
+        .into_iter()
+        .map(|audio| {
+            let name = audio.file_stem().unwrap_or_default().to_string_lossy().into_owned();
+            let sidecar = dir.join(format!("{name}.json"));
+            let meta = if sidecar.exists() {
+                serde_json::from_slice(&std::fs::read(&sidecar)?)
+                    .with_context(|| format!("{} isn't a clip sidecar", sidecar.display()))?
+            } else {
+                ClipMeta::default()
+            };
+            Ok(Clip { name, audio, meta })
+        })
+        .collect()
+}
+
+pub fn save_meta(meta: &ClipMeta, name: &str, dir: &Path) -> anyhow::Result<()> {
+    let path = dir.join(format!("{name}.json"));
+    std::fs::write(&path, serde_json::to_vec_pretty(meta)?)
+        .with_context(|| format!("couldn't write {}", path.display()))
+}
+
+/// Writes 16 kHz mono samples as a 32-bit float WAV.
+pub fn save_wav(samples: &[f32], path: &Path) -> anyhow::Result<()> {
+    let spec = hound::WavSpec {
+        channels: 1,
+        sample_rate: murmur_core::SAMPLE_RATE,
+        bits_per_sample: 32,
+        sample_format: hound::SampleFormat::Float,
+    };
+    let mut writer =
+        hound::WavWriter::create(path, spec).with_context(|| format!("couldn't write {}", path.display()))?;
+    for &sample in samples {
+        writer.write_sample(sample)?;
+    }
+    writer.finalize()?;
+    Ok(())
+}
diff --git a/rust/crates/murmur-eval/src/main.rs b/rust/crates/murmur-eval/src/main.rs
new file mode 100644
index 0000000..bb3ba41
--- /dev/null
+++ b/rust/crates/murmur-eval/src/main.rs
@@ -0,0 +1,471 @@
+//! `murmur-eval`: scores speech-to-text and the cleanup pass against recordings of your voice,
+//! with the same engine, prompt and Dictionary the app uses. Clips live in `rust/eval/clips/`
+//! and reports go to `rust/eval/results/`.
+
+mod clip;
+mod report;
+
+use std::collections::{HashMap, HashSet};
+use std::io::{BufRead, Write};
+use std::path::{Path, PathBuf};
+use std::process::ExitCode;
+use std::time::{Duration, Instant};
+
+use anyhow::{Context, bail};
+use murmur_core::{ClaudeCleaner, Dictionary, OllamaCleaner, TargetContext, TextCleaner};
+use murmur_stt::Transcriber;
+
+use clip::{Clip, ClipMeta, clips_dir};
+use report::{ClipResult, EngineResult, ms, pct, word_error_rate};
+
+const USAGE: &str = "\
+murmur-eval: score speech-to-text and the cleanup pass on your own voice.
+
+USAGE
+  murmur-eval record <name> [--context plain|chat|email|notes|code] [--mic <name>]
+      Record from the microphone into eval/clips/<name>.wav until you press Return, then type
+      what you said.
+
+  murmur-eval run [--models <dir>,<dir>] [--threads <n>] [--no-cleanup] [cleaner options]
+      Transcribe every clip, clean each transcript, and write a report to eval/results/.
+
+  murmur-eval clean \"<raw transcript>\" [--context notes] [cleaner options]
+      Run only the cleanup pass on a string.
+
+  murmur-eval bench [--runs 3] [cleaner options]
+      Time a cleaner on built-in test dictations and show its output.
+
+  murmur-eval vad <file.wav>…
+      Show how much voiced audio each file has, and whether Murmur would transcribe it.
+
+  murmur-eval devices
+      List microphones (* = system default).
+
+CLEANER OPTIONS
+  --cleaner claude|ollama:<model>   default claude (claude-haiku-5-5)
+  --prompt <file>                   a draft system prompt instead of the built-in one
+  --thinking, --effort <level>, --plain-reply   Claude request options
+
+MODELS
+  --models takes sherpa-onnx model folders; the default is the one the app uses, downloaded on
+  first use. Each folder is an engine in the report, named after the folder.
+
+Every command uses your Murmur Dictionary; --dictionary <file> picks another, --dictionary none
+uses none. The API key comes from ANTHROPIC_API_KEY or the key store, as in the app.
+";
+
+/// `--key value` options, `--flag`s and positionals.
+struct Args {
+    positionals: Vec<String>,
+    options: HashMap<String, String>,
+    flags: HashSet<String>,
+}
+
+/// The options that take a value; any other `--name` is a flag.
+const VALUED: [&str; 9] = [
+    "context",
+    "mic",
+    "models",
+    "threads",
+    "cleaner",
+    "prompt",
+    "effort",
+    "runs",
+    "dictionary",
+];
+
+impl Args {
+    fn parse(raw: impl IntoIterator<Item = String>) -> anyhow::Result<Self> {
+        let mut args = Self {
+            positionals: Vec::new(),
+            options: HashMap::new(),
+            flags: HashSet::new(),
+        };
+        let mut iter = raw.into_iter();
+        while let Some(arg) = iter.next() {
+            let Some(key) = arg.strip_prefix("--") else {
+                args.positionals.push(arg);
+                continue;
+            };
+            if VALUED.contains(&key) {
+                let Some(value) = iter.next() else {
+                    bail!("--{key} needs a value")
+                };
+                args.options.insert(key.to_string(), value);
+            } else {
+                args.flags.insert(key.to_string());
+            }
+        }
+        Ok(args)
+    }
+
+    fn option(&self, key: &str) -> Option<&str> {
+        self.options.get(key).map(String::as_str)
+    }
+
+    fn flag(&self, key: &str) -> bool {
+        self.flags.contains(key)
+    }
+
+    fn context(&self) -> anyhow::Result<TargetContext> {
+        let Some(raw) = self.option("context") else {
+            return Ok(TargetContext::Plain);
+        };
+        TargetContext::parse(raw).with_context(|| {
+            let all: Vec<&str> = TargetContext::ALL.iter().map(|c| c.as_str()).collect();
+            format!("unknown context {raw:?}; use one of: {}", all.join(", "))
+        })
+    }
+
+    fn number(&self, key: &str) -> anyhow::Result<Option<usize>> {
+        self.option(key)
+            .map(|n| n.parse().with_context(|| format!("--{key} {n} isn't a number")))
+            .transpose()
+    }
+
+    /// The app's Dictionary, another file, or none, so results match real use.
+    fn dictionary(&self) -> anyhow::Result<Dictionary> {
+        match self.option("dictionary") {
+            Some("none") => Ok(Dictionary::default()),
+            Some(path) => Dictionary::load(Path::new(path)).with_context(|| format!("couldn't read {path}")),
+            None => Ok(murmur_engine::load_dictionary()),
+        }
+    }
+
+    /// The cleanup pass the options ask for. `None` when it's Claude and there's no API key.
+    fn cleaner(&self, dictionary: &Dictionary) -> anyhow::Result<Option<Box<dyn TextCleaner>>> {
+        let system = match self.option("prompt") {
+            Some(path) => Some(std::fs::read_to_string(path).with_context(|| format!("couldn't read {path}"))?),
+            None => None,
+        };
+        let vocabulary = dictionary.vocabulary();
+        let choice = self.option("cleaner").unwrap_or("claude");
+
+        if let Some(model) = choice.strip_prefix("ollama:") {
+            let mut cleaner = OllamaCleaner::new(model.to_string(), vocabulary);
+            if let Some(system) = system {
+                cleaner.system_prompt = system;
+            }
+            return Ok(Some(Box::new(cleaner)));
+        }
+        if choice != "claude" {
+            bail!("unknown cleaner {choice:?}; use claude or ollama:<model>");
+        }
+        let Some(key) = murmur_core::api_key::load() else {
+            return Ok(None);
+        };
+        let mut cleaner = ClaudeCleaner::new(key, vocabulary);
+        if let Some(system) = system {
+            cleaner.system_prompt = system;
+        }
+        cleaner.options.thinking = self.flag("thinking");
+        cleaner.options.structured_reply = !self.flag("plain-reply");
+        if let Some(effort) = self.option("effort") {
+            cleaner.options.effort = effort.to_string();
+        }
+        Ok(Some(Box::new(cleaner)))
+    }
+
+    /// Like `cleaner`, but a missing API key is an error.
+    fn required_cleaner(&self, dictionary: &Dictionary) -> anyhow::Result<Box<dyn TextCleaner>> {
+        self.cleaner(dictionary)?
+            .context("no Anthropic API key; set ANTHROPIC_API_KEY or store one in the key store (see the README)")
+    }
+}
+
+fn main() -> ExitCode {
+    let mut argv = std::env::args().skip(1);
+    let command = argv.next().unwrap_or_else(|| "help".into());
+    let result = Args::parse(argv).and_then(|args| match command.as_str() {
+        "record" => record(&args),
+        "run" => run(&args),
+        "clean" => clean(&args),
+        "bench" => bench(&args),
+        "vad" => vad(&args),
+        "devices" => {
+            devices();
+            Ok(())
+        }
+        "help" | "--help" | "-h" => {
+            print!("{USAGE}");
+            Ok(())
+        }
+        other => bail!("unknown command {other:?}; run murmur-eval help"),
+    });
+    match result {
+        Ok(()) => ExitCode::SUCCESS,
+        Err(e) => {
+            eprintln!("error: {e:#}");
+            ExitCode::FAILURE
+        }
+    }
+}
+
+// MARK: - Commands
+
+fn record(args: &Args) -> anyhow::Result<()> {
+    let Some(name) = args.positionals.first() else {
+        bail!("record needs a clip name")
+    };
+    let context = args.context()?;
+    let dir = clips_dir();
+    std::fs::create_dir_all(&dir).with_context(|| format!("couldn't create {}", dir.display()))?;
+    let path = dir.join(format!("{name}.wav"));
+
+    let recorder = murmur_audio::Recorder::start(args.option("mic"), |_| {})?;
+    let start = Instant::now();
+    println!("● Recording… press Return to stop.");
+    read_line();
+    let samples = recorder.stop();
+    clip::save_wav(&samples, &path)?;
+    println!(
+        "Saved {} ({:.1}s, {:.1}s voiced)\n",
+        path.display(),
+        start.elapsed().as_secs_f64(),
+        murmur_core::voice::voiced_duration(&samples)
+    );
+
+    let meta = ClipMeta {
+        reference: ask("Type exactly what you said, word for word (Return to skip):"),
+        intended: ask("Type what you'd want it to come out as (Return to skip):"),
+        context,
+    };
+    clip::save_meta(&meta, name, &dir)?;
+    println!("Saved {name}.json");
+    Ok(())
+}
+
+/// A speech model to compare, named after its folder.
+struct Engine {
+    id: String,
+    transcriber: Transcriber,
+}
+
+fn run(args: &Args) -> anyhow::Result<()> {
+    let clips = clip::load_all(&clips_dir())?;
+    if clips.is_empty() {
+        bail!(
+            "no clips in {}; record one with `murmur-eval record <name>`",
+            clips_dir().display()
+        );
+    }
+    let dictionary = args.dictionary()?;
+    let cleaner = if args.flag("no-cleanup") {
+        None
+    } else {
+        let cleaner = args.cleaner(&dictionary)?;
+        match &cleaner {
+            Some(cleaner) => cleaner.prepare().context("preparing the cleaner")?,
+            None => println!("⚠️  No Anthropic API key found, so the cleanup pass is skipped.\n"),
+        }
+        cleaner
+    };
+
+    let threads = args.number("threads")?;
+    let model_dirs: Vec<Option<PathBuf>> = match args.option("models") {
+        None => vec![None],
+        Some(list) => list.split(',').map(|dir| Some(PathBuf::from(dir))).collect(),
+    };
+    let mut engines = Vec::new();
+    for model_dir in model_dirs {
+        let options = murmur_engine::Options { model_dir, threads };
+        let dir = murmur_engine::default_model_dir(&options);
+        let id = dir.file_name().unwrap_or_default().to_string_lossy().into_owned();
+        println!("Loading {id}…");
+        // Loading also warms the model up, so the first clip's time is a fair one.
+        let transcriber = murmur_engine::load_model(&options, |status| eprintln!("  {status}"))?;
+        engines.push(Engine { id, transcriber });
+    }
+    let engine_ids: Vec<String> = engines.iter().map(|e| e.id.clone()).collect();
+
+    let mut results = Vec::new();
+    for clip in &clips {
+        println!("\n▸ {}", clip.name);
+        results.push(run_clip(clip, &engines, &dictionary, cleaner.as_deref()));
+    }
+
+    let path = report::write(&results, &engine_ids)?;
+    println!("\n{}", report::summary_table(&results, &engine_ids));
+    println!("\nReport: {}", path.display());
+    Ok(())
+}
+
+fn run_clip(clip: &Clip, engines: &[Engine], dictionary: &Dictionary, cleaner: Option<&dyn TextCleaner>) -> ClipResult {
+    let samples = murmur_audio::load_wav(&clip.audio);
+    let mut result = ClipResult {
+        clip: clip.name.clone(),
+        context: clip.meta.context,
+        audio_seconds: samples
+            .as_ref()
+            .map_or(0.0, |s| s.len() as f64 / f64::from(murmur_core::SAMPLE_RATE)),
+        reference: clip.meta.reference.clone(),
+        intended: clip.meta.intended.clone(),
+        engines: Vec::new(),
+    };
+    for engine in engines {
+        let samples = match &samples {
+            Ok(samples) => samples,
+            Err(e) => {
+                println!("  {} failed: {e:#}", engine.id);
+                result
+                    .engines
+                    .push(failed(&engine.id, format!("Reading the clip failed: {e:#}")));
+                continue;
+            }
+        };
+        let start = Instant::now();
+        let raw = match engine.transcriber.transcribe(samples) {
+            Ok(raw) => raw,
+            Err(e) => {
+                println!("  {} failed: {e:#}", engine.id);
+                result
+                    .engines
+                    .push(failed(&engine.id, format!("Transcription failed: {e:#}")));
+                continue;
+            }
+        };
+        let stt_seconds = start.elapsed().as_secs_f64();
+        let wer = clip.meta.reference.as_deref().map(|r| word_error_rate(&raw, r));
+        let wer_note = wer.map(|w| format!(", WER {}", pct(w))).unwrap_or_default();
+        println!("  {} [{}{wer_note}]: {raw}", engine.id, ms(stt_seconds));
+
+        let mut engine_result = EngineResult {
+            engine: engine.id.clone(),
+            raw: raw.clone(),
+            stt_seconds,
+            wer,
+            ..Default::default()
+        };
+        if let Some(cleaner) = cleaner {
+            let start = Instant::now();
+            match cleaner.clean(&dictionary.apply_replacements(&raw), clip.meta.context) {
+                Ok(cleaned) => {
+                    let seconds = start.elapsed().as_secs_f64();
+                    println!("    ↳ cleaned [{}]: {}", ms(seconds), cleaned.replace('\n', " ⏎ "));
+                    engine_result.cleaned = Some(cleaned);
+                    engine_result.cleanup_seconds = Some(seconds);
+                }
+                Err(e) => {
+                    println!("    ↳ cleanup failed: {e:#}");
+                    engine_result.error = Some(format!("Cleanup failed: {e:#}"));
+                }
+            }
+        }
+        result.engines.push(engine_result);
+    }
+    result
+}
+
+fn failed(engine: &str, error: String) -> EngineResult {
+    EngineResult {
+        engine: engine.to_string(),
+        error: Some(error),
+        ..Default::default()
+    }
+}
+
+fn clean(args: &Args) -> anyhow::Result<()> {
+    let Some(text) = args.positionals.first() else {
+        bail!("clean needs a transcript string")
+    };
+    let context = args.context()?;
+    let dictionary = args.dictionary()?;
+    let cleaner = args.required_cleaner(&dictionary)?;
+    cleaner.prepare().context("preparing the cleaner")?;
+    let start = Instant::now();
+    let cleaned = cleaner.clean(&dictionary.apply_replacements(text), context)?;
+    println!("{cleaned}");
+    println!("\n({})", ms(start.elapsed().as_secs_f64()));
+    Ok(())
+}
+
+/// Cleans each of `murmur_core::bench::CASES` `--runs` times with one warm cleaner. Consecutive
+/// cases use different styles, so with Ollama the first run of each pays for reading that
+/// style's prompt and the rest show the cached speed; both are reported.
+fn bench(args: &Args) -> anyhow::Result<()> {
+    let runs = args.number("runs")?.unwrap_or(3).max(1);
+    let dictionary = args.dictionary()?;
+    let cleaner = args.required_cleaner(&dictionary)?;
+    println!("Cleaner: {}", cleaner.id());
+    let start = Instant::now();
+    cleaner.prepare().context("preparing the cleaner")?;
+    cleaner.clean("warm up", TargetContext::Plain)?;
+    println!("Load and warm-up: {:.1} s\n", start.elapsed().as_secs_f64());
+
+    let mut firsts = Vec::new();
+    let mut repeats = Vec::new();
+    for (context, text) in murmur_core::bench::CASES {
+        let mut times = Vec::new();
+        let mut output = String::new();
+        for _ in 0..runs {
+            let start = Instant::now();
+            output = cleaner.clean(&dictionary.apply_replacements(text), context)?;
+            times.push(start.elapsed());
+        }
+        firsts.push(times[0]);
+        repeats.extend_from_slice(&times[1..]);
+        let mut line = format!("[{}] {:.2} s", context.as_str(), times[0].as_secs_f64());
+        if times.len() > 1 {
+            line += &format!(", then {:.2} s", median(&times[1..]).as_secs_f64());
+        }
+        println!("{line}");
+        for row in output.split('\n') {
+            println!("  {row}");
+        }
+        println!();
+    }
+    let mut summary = format!("Median: {:.2} s after a style change", median(&firsts).as_secs_f64());
+    if !repeats.is_empty() {
+        summary += &format!(", {:.2} s repeated", median(&repeats).as_secs_f64());
+    }
+    println!("{summary}");
+    Ok(())
+}
+
+fn vad(args: &Args) -> anyhow::Result<()> {
+    if args.positionals.is_empty() {
+        bail!("vad needs one or more WAV files");
+    }
+    for path in &args.positionals {
+        let samples = murmur_audio::load_wav(Path::new(path))?;
+        let voiced = murmur_core::voice::voiced_duration(&samples);
+        let total = samples.len() as f64 / f64::from(murmur_core::SAMPLE_RATE);
+        let verdict = if murmur_core::voice::contains_speech(&samples) {
+            "speech"
+        } else {
+            "skip"
+        };
+        println!("{path}: {voiced:.2}s voiced of {total:.2}s → {verdict}");
+    }
+    Ok(())
+}
+
+fn devices() {
+    let default = murmur_audio::default_input_device();
+    for name in murmur_audio::input_devices() {
+        let mark = if Some(&name) == default.as_ref() { "*" } else { " " };
+        println!("{mark} {name}");
+    }
+}
+
+// MARK: - Helpers
+
+/// The middle value (the upper one of an even count).
+fn median(values: &[Duration]) -> Duration {
+    let mut sorted = values.to_vec();
+    sorted.sort();
+    sorted[sorted.len() / 2]
+}
+
+fn read_line() -> String {
+    let mut line = String::new();
+    let _ = std::io::stdin().lock().read_line(&mut line);
+    line.trim().to_string()
+}
+
+/// Asks `question` and returns the answer, or `None` if it was left empty.
+fn ask(question: &str) -> Option<String> {
+    print!("{question} ");
+    let _ = std::io::stdout().flush();
+    Some(read_line()).filter(|answer| !answer.is_empty())
+}
diff --git a/rust/crates/murmur-eval/src/report.rs b/rust/crates/murmur-eval/src/report.rs
new file mode 100644
index 0000000..ed7f543
--- /dev/null
+++ b/rust/crates/murmur-eval/src/report.rs
@@ -0,0 +1,242 @@
+//! Scoring and the report: word error rate on the raw transcript, and `results/<time>.md` (to
+//! read) plus `.json` (to diff between runs).
+
+use std::path::PathBuf;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use anyhow::Context;
+use murmur_core::TargetContext;
+use serde::Serialize;
+
+use crate::clip::results_dir;
+
+/// One engine's go at one clip. Field names match the Swift eval's JSON.
+#[derive(Debug, Default, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EngineResult {
+    pub engine: String,
+    pub raw: String,
+    pub stt_seconds: f64,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub wer: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cleaned: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cleanup_seconds: Option<f64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ClipResult {
+    pub clip: String,
+    pub context: TargetContext,
+    pub audio_seconds: f64,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub reference: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub intended: Option<String>,
+    pub engines: Vec<EngineResult>,
+}
+
+// MARK: - Word error rate
+
+/// Lowercased words with punctuation dropped, keeping apostrophes inside words ("don't").
+fn normalized_words(text: &str) -> Vec<String> {
+    let kept: String = text
+        .to_lowercase()
+        .chars()
+        .map(|c| if c.is_alphanumeric() || c == '\'' { c } else { ' ' })
+        .collect();
+    kept.split_whitespace()
+        .map(|w| w.trim_matches('\'').to_string())
+        .filter(|w| !w.is_empty())
+        .collect()
+}
+
+/// (substitutions + deletions + insertions) / reference length, by word-level edit distance.
+pub fn word_error_rate(hypothesis: &str, reference: &str) -> f64 {
+    let reference = normalized_words(reference);
+    let hypothesis = normalized_words(hypothesis);
+    if reference.is_empty() {
+        return if hypothesis.is_empty() { 0.0 } else { 1.0 };
+    }
+    let mut previous: Vec<usize> = (0..=hypothesis.len()).collect();
+    for (i, r) in reference.iter().enumerate() {
+        let mut current = vec![i + 1; hypothesis.len() + 1];
+        for (j, h) in hypothesis.iter().enumerate() {
+            let cost = usize::from(r != h);
+            current[j + 1] = (previous[j + 1] + 1).min(current[j] + 1).min(previous[j] + cost);
+        }
+        previous = current;
+    }
+    previous[hypothesis.len()] as f64 / reference.len() as f64
+}
+
+// MARK: - Output
+
+/// Writes the report as `.md` and `.json` and returns the Markdown file's path.
+pub fn write(results: &[ClipResult], engines: &[String]) -> anyhow::Result<PathBuf> {
+    let dir = results_dir();
+    std::fs::create_dir_all(&dir).with_context(|| format!("couldn't create {}", dir.display()))?;
+    let now = utc_now();
+    // No colons, so the name works on every file system.
+    let base = dir.join(now.replace(':', "-"));
+
+    std::fs::write(base.with_extension("json"), serde_json::to_vec_pretty(results)?)?;
+    let markdown = base.with_extension("md");
+    std::fs::write(&markdown, render(results, engines, &now))?;
+    Ok(markdown)
+}
+
+pub fn summary_table(results: &[ClipResult], engines: &[String]) -> String {
+    let mut lines = vec![
+        "| Engine | Mean WER | Mean STT latency | Mean cleanup latency |".to_string(),
+        "|---|---|---|---|".to_string(),
+    ];
+    for engine in engines {
+        let rows: Vec<&EngineResult> = results
+            .iter()
+            .flat_map(|c| &c.engines)
+            .filter(|r| &r.engine == engine && r.error.is_none())
+            .collect();
+        let wers: Vec<f64> = rows.iter().filter_map(|r| r.wer).collect();
+        let stt: Vec<f64> = rows.iter().map(|r| r.stt_seconds).collect();
+        let cleanup: Vec<f64> = rows.iter().filter_map(|r| r.cleanup_seconds).collect();
+        let cell = |values: &[f64], format: fn(f64) -> String| {
+            if values.is_empty() {
+                "–".to_string()
+            } else {
+                format(mean(values))
+            }
+        };
+        lines.push(format!(
+            "| {engine} | {} | {} | {} |",
+            cell(&wers, pct),
+            cell(&stt, ms),
+            cell(&cleanup, ms)
+        ));
+    }
+    lines.join("\n")
+}
+
+fn render(results: &[ClipResult], engines: &[String], now: &str) -> String {
+    let mut out = format!("# Murmur eval: {now}\n\n");
+    out += "WER is measured on the **raw** speech-to-text output against each clip's verbatim `reference`.\n\n";
+    out += &summary_table(results, engines);
+    out += "\n";
+
+    for clip in results {
+        out += &format!("\n---\n\n## {}\n\n", clip.clip);
+        out += &format!("`{}` · {:.1}s audio\n\n", clip.context.as_str(), clip.audio_seconds);
+        if let Some(reference) = &clip.reference {
+            out += &format!("**Reference (verbatim):** {reference}\n\n");
+        }
+        if let Some(intended) = &clip.intended {
+            out += &format!("**Intended:**\n\n{}\n\n", quote(intended));
+        }
+        for engine in &clip.engines {
+            out += &format!("### {}\n\n", engine.engine);
+            if let Some(error) = &engine.error {
+                out += &format!("> ⚠️ {error}\n\n");
+                continue;
+            }
+            let wer = engine.wer.map(|w| format!(" · WER {}", pct(w))).unwrap_or_default();
+            out += &format!("Raw, {}{wer}:\n\n{}\n\n", ms(engine.stt_seconds), quote(&engine.raw));
+            if let Some(cleaned) = &engine.cleaned {
+                out += &format!(
+                    "Cleaned, {}:\n\n{}\n\n",
+                    ms(engine.cleanup_seconds.unwrap_or_default()),
+                    quote(cleaned)
+                );
+            }
+        }
+    }
+    out
+}
+
+fn quote(text: &str) -> String {
+    if text.is_empty() {
+        return "> _(empty)_".into();
+    }
+    text.split('\n')
+        .map(|line| format!("> {line}"))
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+fn mean(values: &[f64]) -> f64 {
+    values.iter().sum::<f64>() / values.len().max(1) as f64
+}
+
+pub fn pct(value: f64) -> String {
+    format!("{:.1}%", value * 100.0)
+}
+
+pub fn ms(seconds: f64) -> String {
+    format!("{:.0} ms", seconds * 1000.0)
+}
+
+/// The current time in UTC, like `2026-10-22T05:26:04Z`.
+fn utc_now() -> String {
+    let secs = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_secs())
+        .unwrap_or(0);
+    let (days, rest) = (secs / 86_400, secs % 86_400);
+    let (year, month, day) = civil_from_days(days as i64);
+    format!(
+        "{year:04}-{month:02}-{day:02}T{:02}:{:02}:{:02}Z",
+        rest / 3600,
+        rest % 3600 / 60,
+        rest % 60
+    )
+}
+
+/// Days since 1970-01-01 to a (year, month, day) date, after Howard Hinnant's `civil_from_days`.
+fn civil_from_days(days: i64) -> (i64, u32, u32) {
+    let z = days + 719_468;
+    let era = z.div_euclid(146_097);
+    let doe = z.rem_euclid(146_097);
+    let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
+    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+    let mp = (5 * doy + 2) / 153;
+    let day = (doy - (153 * mp + 2) / 5 + 1) as u32;
+    let month = if mp < 10 { mp + 3 } else { mp - 9 } as u32;
+    let year = yoe + era * 400 + i64::from(month <= 2);
+    (year, month, day)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn wer_counts_word_edits() {
+        assert_eq!(word_error_rate("the quick brown fox", "the quick brown fox"), 0.0);
+        // One substitution in four words.
+        assert_eq!(word_error_rate("the quick brown box", "the quick brown fox"), 0.25);
+        // One deletion and one insertion.
+        assert_eq!(word_error_rate("quick brown fox jumps", "the quick brown fox"), 0.5);
+    }
+
+    #[test]
+    fn wer_ignores_case_and_punctuation() {
+        assert_eq!(word_error_rate("Don't stop, okay?", "don't stop okay"), 0.0);
+        assert_eq!(word_error_rate("'quoted' words", "quoted words"), 0.0);
+    }
+
+    #[test]
+    fn wer_with_an_empty_reference() {
+        assert_eq!(word_error_rate("", ""), 0.0);
+        assert_eq!(word_error_rate("something", ""), 1.0);
+    }
+
+    #[test]
+    fn dates() {
+        assert_eq!(civil_from_days(0), (1970, 1, 1));
+        assert_eq!(civil_from_days(20_383), (2025, 10, 22));
+        assert_eq!(civil_from_days(11_016), (2000, 2, 29));
+    }
+}
diff --git a/Eval/clips/.gitkeep b/rust/eval/clips/.gitkeep
similarity index 100%
rename from Eval/clips/.gitkeep
rename to rust/eval/clips/.gitkeep