diff --git a/CLAUDE.md b/CLAUDE.md
index da38ab4..5879d45 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -6,7 +6,7 @@ Push-to-talk dictation for macOS 26 on Apple Silicon. Hold a key, speak, release
 
 1. **Speed of the release-to-paste path.** This is the metric. The path runs from the hotkey release to the paste: capture stop, engine, processors, output. In code it is everything between the coordinator's `recordingStopped` and `inserted` events. Nothing goes on that path without a before-and-after benchmark.
 2. **Minimal UI.** No new settings, windows or overlay elements unless a feature cannot work without them. Prefer removing to adding.
-3. **On-device processing and privacy.** Audio and text never leave the Mac. No network calls, no telemetry, no accounts. The one-time model download from Hugging Face is the only exception and stays the only one.
+3. **On-device processing and privacy.** Audio and text never leave the Mac. No network calls, no telemetry, no accounts. One-time model downloads from Hugging Face are the only exception and stay the only one: the speech model at first launch, and an S1-mini polish model only when the user picks it. Each is pinned to a commit and checked against its SHA-256.
 
 ## Critical-path rule
 
@@ -26,7 +26,8 @@ swift run -c release pladder-cli <audio file> # transcribe one file, print timin
 ./scripts/make-fixtures.sh                    # synthesise benchmark fixtures into bench/fixtures (gitignored)
 swift run -c release pladder-cli bench bench/fixtures            # whole-buffer benchmark
 swift run -c release pladder-cli bench bench/fixtures --paced     # feed at real time, time endUtterance, check identity
-swift run -c release pladder-cli polish <text file>   # run the polish prompt over a transcript, print both timings
+swift run -c release pladder-cli polish <text file> [--model apple|s1-mini|s1-mini-8bit]   # one transcript, cold and warm
+swift run -c release pladder-cli polish-set docs/polish-set.json --model s1-mini-8bit    # a polish model over the test set: error rate, exact matches, timings
 ./scripts/overlay-demo.sh [dir] [--style …] [--speed …]  # play every overlay path with stand-ins, record the screen, cut contact sheets
 ```
 
@@ -50,7 +51,8 @@ swift run -c release pladder-cli polish <text file>   # run the polish prompt ov
 | Toggle key | Another recordable chord, off by default. A chord of its own latches at release however long the press; equal to the push-to-talk chord it makes that key hybrid: a tap under 400 ms latches, a longer hold stops at release. The next press of any chord, Escape or the 10 min cap ends a latched recording. The overlay is the same as for a held recording, in and out; only the menu's status line says which key stops it | Two-minute dictations should not need a key held for two minutes. Handy and VoiceInk default to hybrid on one key; here it is opt-in, because a stray tap would otherwise leave the microphone open until the cap pastes two minutes of room noise. Hold, toggle and hybrid are decided in `HotkeyGestureTracker`, a clockless value type timed by the instant each monitor stamps on its events, so both monitors behave alike and a press that waits for the microphone cannot make the next release look longer. A same-chord press within 50 ms of its release is a bounce (some Bluetooth keyboards do this mid-hold): it never acts, and the first one seen turns on a 50 ms settle before every stopping release for the rest of the run, so only a keyboard that needs it pays for it and the release path is otherwise untouched. No separate press debounce: both monitors already report alternating presses and releases. Without Accessibility the toggle chord registers with Carbon like the key; one Carbon cannot register has no stand-in, except that a hybrid chord follows the key's. With a lone modifier as a hybrid key, the Command of a later Cmd+C ends a latched recording |
 | Escape | Discards a recording without transcribing and plays the stop sound; taken only while a recording is on | Never taken globally, so Escape keeps closing dialogs. On the tap `HotkeyChordSet` catches it before the chord trackers, so the interrupted-press rule never sees it, and Escape with the chord's own modifiers held still counts; Carbon registers the bare key around each recording, from the main queue so the release path never waits on it. Under Secure Event Input a modifier-only chord stays on the tap, where no key-down arrives, so Escape cannot cancel there |
 | Output | Clipboard + simulated Cmd+V; the old clipboard is restored off the critical path | Universal, fast |
-| Post-processing | Filler remover, dictionary replacer, fuzzy custom-word corrector, whitespace normaliser, in that order | No latency, no network. An earlier Apple Intelligence step was removed from this path unmeasured; the model is back behind the experimental polish toggle only |
+| Polish model | A picker under the toggle: Apple Intelligence (default), S1-mini by Superwhisper at full precision (f16, 1.5 GB) or 8-bit (Q8_0, 805 MB), the S1-mini files run by llama.cpp on the GPU. `PolishRouter` is the coordinator's one refiner and forwards to the chosen model | On the polish set (docs/BENCHMARKS.md) S1-mini is more accurate than Apple's model and three to five times faster, and translated nothing where Apple's model translated two dictations. It is Qwen3-0.6B fine-tuned for dictation cleanup, trained on English, and needs its own fixed prompt. llama.cpp comes as its prebuilt XCFramework, pinned by release and checksum, because MLX Swift needs Xcode to build its Metal shaders; `bundle.sh` embeds and signs the framework. The GPU leaves the Neural Engine to Parakeet. A file downloads only when polish is on and the model picked, is loaded at the first key-down with the fixed prompt prefix decoded once, and is freed on a switch or with polish off. The licence asks for the name as "S1-mini" by "Superwhisper" |
+| Post-processing | Filler remover, dictionary replacer, fuzzy custom-word corrector, whitespace normaliser, spoken punctuation, in that order | No latency, no network. Spoken punctuation takes only phrases that are never ordinary words ("period", "Punkt", "punto" stay words), runs last because the whitespace step folds line breaks, and needs Spanish evidence for "coma"; Parakeet already writes numbers as digits. An earlier Apple Intelligence step was removed from this path unmeasured; the model is back behind the experimental polish toggle only |
 | Mute while dictating | Off by default; `kAudioDevicePropertyMute` on the default output device 200 ms into a recording, restored off the release path | Music or a call otherwise goes into the microphone. The delay means a tap-and-release never toggles anything; a device the user had already muted is left alone, and the device that was muted is the one unmuted even if the default changed meanwhile |
 | UI language | Follows the macOS system language; no setting | String Catalogs (`Localizable.xcstrings` in the app, `KeyNames.xcstrings` in `PladderSystem`) are compiled by `swift build`; `bundle.sh` merges their `.lproj` folders into `Pladder.app/Contents/Resources`, so `Bundle.main` serves them and no code names a bundle. `swift run` shows English. Core and Engines emit enum cases; the app turns them into text. German first; more languages are catalog contributions |
 | Recording cap | 10 min | Keeps the microphone from staying on when a key-up is lost. The cap ends a latched recording the same way |
@@ -61,6 +63,7 @@ swift run -c release pladder-cli polish <text file>   # run the polish prompt ov
 - `PladderCore` imports Foundation only. It never imports FluidAudio, AVFoundation or AppKit, so tests compile fast and engines are truly swappable.
 - Adding an engine: implement `TranscriptionEngine` in its own file under `PladderEngines`, register it in the `EngineRegistry` built in `AppModel`. One file plus one registry line; the settings picker reads the registry. The engine lifecycle — building, loading, status polling and swapping — lives in `EngineLoader`.
 - Adding a processor: implement `TextProcessor` in its own file, append a factory to `processorFactories` in `AppModel`. The pipeline is rebuilt when settings change, never per dictation. A processor sits on the critical path, so the benchmark rule applies.
+- Adding a polish model: a `PolishModel` case in `Settings`, a `ModelFile` pinned to a commit with its SHA-256 if it downloads, a `TranscriptRefiner` in `PladderRefine`, and a branch in `AppModel.applyPolishModel`; `PolishRouter` hands it the calls, the picker and `polish-set` read the enum. Judge it with `pladder-cli polish-set` before it goes in.
 - Adding a prompt: build an `OnDeviceLanguageModel(instructions:)` in `PladderRefine` and call `respond(to:)` or `respond(to:generating:)`; availability, prewarm, timeout and the drain of an abandoned call come with it. The coordinator only ever sees `TranscriptRefiner`.
 - The correction learner's two seams are protocols in `PladderCore`, `PastedTextObserver` and `CorrectionReviewer`, with fakes in the tests; the Accessibility and Foundation Models implementations live in `PladderSystem` (`AXPasteObserver`) and `PladderRefine` (`FoundationModelsCorrectionReviewer`).
 - Adding a hotkey role: a case in `HotkeyRole`, a `Hotkey` field in `Settings` with `[]` meaning off, an entry in the chords `startHotkey` hands the monitor and a mode in `startGesture`, a `HotkeyRecorderField` row. The monitors and trackers need nothing.
@@ -73,7 +76,8 @@ swift run -c release pladder-cli polish <text file>   # run the polish prompt ov
 - **First launch.** About 700 MB of CoreML models download from Hugging Face and compile on first load. The menu shows progress and the hotkey is disabled until the engine is ready.
 - **Cold latency.** The engine loads at launch and stays resident. The audio engine is prepared at launch and runs only while the key is held, so the system microphone indicator is off when idle. A cold encoder pass costs about 110 ms more than a warm one, which is more than every other stage together, so the coordinator warms the Neural Engine every two seconds while the key is held. A release that lands inside a warm pass waits for it: the signature is `engine` well above `engine-time`.
 - **Long recordings.** FluidAudio's encoder window is 15 s. Longer audio is split into windows and stitched, and seams can drop or duplicate words. Those windows now run while the key is held rather than at release, so the wait is flat with length, but the seam risk is unchanged: it is the same layout and the same merge. The paced benchmark guards it by requiring the text to be byte-identical to transcribing the whole recording at once, and the 30 s to 10 min fixtures watch the word error rate.
-- **Polish latency and quality.** The model takes about 1.5 to 2 seconds warm on an M1 for a typical dictation and is capped at eight; past the cap the text is pasted as dictated. A small model can still rewrite rather than clean; the guided `cleanedText` field, greedy sampling, inline examples and naming the transcript's language keep that rare, and `pladder-cli polish` is where prompt changes are judged.
+- **Polish latency and quality.** Apple's model takes about 1.5 to 2 seconds warm on an M1 for a typical dictation, S1-mini 0.3 to 0.5, and both are capped at eight; past the cap the text is pasted as dictated. A small model can still rewrite rather than clean; for Apple's the guided `cleanedText` field, greedy sampling, inline examples and naming the transcript's language keep that rare. S1-mini's known slips are in docs/BENCHMARKS.md, the worst a German number word read wrong, which real dictation rarely feeds it since Parakeet writes digits. `pladder-cli polish-set` is where model and prompt changes are judged.
+- **Polish model memory.** S1-mini stays loaded while chosen and polish is on: about 0.8 or 1.5 GB of weights plus a 235 MB key-value cache for its 2,048-token context. Long dictations are polished in chunks of about 250 words to fit.
 - **Clipboard clobbering.** Output saves the pasteboard, pastes, and restores it after a short delay.
 - **Permissions.** Accessibility and Microphone grants are keyed to the code signature. `bundle.sh` signs with an Apple Development or Developer ID certificate when one is in the keychain; an ad-hoc signature changes on every build and resets both grants.
 - **Lost key-up.** When the 10 min watchdog fires, the coordinator transcribes and pastes as if the user had released. Discarding is probably the right behaviour; tracked separately.
diff --git a/Package.swift b/Package.swift
index 7687d9a..e17303a 100644
--- a/Package.swift
+++ b/Package.swift
@@ -45,9 +45,18 @@ let package = Package(
             ]
         ),
 
-        // Apple's on-device model behind the polish hotkey. The only target
-        // that imports FoundationModels.
-        .target(name: "PladderRefine", dependencies: ["PladderCore"]),
+        // The polish models: Apple's on-device model, the only target that
+        // imports FoundationModels, and S1-mini through llama.cpp.
+        .target(name: "PladderRefine", dependencies: ["PladderCore", "llama"]),
+
+        // llama.cpp's own prebuilt release, Metal included: a dynamic
+        // framework that scripts/bundle.sh embeds in the app. Pinned by
+        // release and checksum; bump both together.
+        .binaryTarget(
+            name: "llama",
+            url: "https://github.com/ggml-org/llama.cpp/releases/download/b11191/llama-b11191-xcframework.zip",
+            checksum: "c8f9af07555a15b00a87334e13a21320596178c58bbafa2d7c4915c574e7086e"
+        ),
 
         // The menu bar app.
         .executableTarget(
@@ -73,7 +82,7 @@ let package = Package(
         // engines, or run the benchmark (see docs/BENCHMARKS.md).
         .executableTarget(
             name: "PladderCLI",
-            dependencies: ["PladderCore", "PladderEngines", "PladderAudio", "PladderBench", "PladderRefine"]
+            dependencies: ["PladderCore", "PladderEngines", "PladderAudio", "PladderBench", "PladderRefine", "PladderSystem"]
         ),
 
         .testTarget(name: "PladderCoreTests", dependencies: ["PladderCore"]),
diff --git a/README.md b/README.md
index c3b53fe..794994e 100644
--- a/README.md
+++ b/README.md
@@ -61,7 +61,8 @@ You type long prompts all day. Speech is three to four times faster than typing,
 - **Nothing leaves your Mac.** The speech model runs on the Neural Engine. There is no account, no server, no telemetry, and the app makes no network requests after the one-time model download.
 - **It knows your words.** A dictionary turns what the model hears into what you meant. "clode code" becomes "Claude Code", "get hub" becomes "GitHub", every time, at zero cost in latency. List a word on its own and near misses of it are repaired too, so "Chat G P T" comes out as "ChatGPT" without you predicting every way the model might mangle it. Correct a word by hand after a dictation and Pladder offers to remember it — checked on device, added only when you say so.
 - **It skips over the ums.** Hesitation sounds — "uh", "um", German "äh"/"ähm", Spanish "eh" — are dropped before the text is pasted. Still no cost in latency. Only English, German and Spanish fillers are covered for now; other languages pass through unchanged.
-- **Polish it when you want to.** Hold a second key instead and Apple's on-device model cleans the transcript before it is pasted: "wait, no, Friday" becomes "Friday", spoken numbers become digits, "first… second…" becomes a list. A second or two, still on your Mac, and only when you ask.
+- **Say "comma" and get one.** Spoken punctuation — "comma", "question mark", "new paragraph", German "Fragezeichen", Spanish "signo de interrogación" — becomes the mark itself, with no cost in latency.
+- **Polish it if you like.** Turn on the experimental polish and a small model cleans the transcript on your Mac before it is pasted: "wait, no, Friday" becomes "Friday", "first… second…" becomes a list. Apple's on-device model takes a second or two; S1-mini by Superwhisper, downloaded once when you pick it, about half a second.
 - **It behaves like part of macOS.** A menu bar app with a Liquid Glass status pill, a standard settings window, and nothing in the Dock.
 - **Twenty-five languages, detected automatically.** English, German, Spanish, French and the rest of Europe in the same session, with no setting to flip.
 - **Free and MIT.** The source is here. Read it, build it, change it.
@@ -94,7 +95,7 @@ Privacy here is not a policy, it is how the thing is built.
 
 - **Audio never leaves the Mac.** The microphone is open only while the key is held, and macOS shows the orange indicator only then. Audio goes from the microphone to the Neural Engine and is discarded.
 - **Text never leaves the Mac.** The transcript exists long enough to be pasted. Your previous clipboard is put back afterwards. After a paste, Pladder watches the field it pasted into for up to a minute through Accessibility, to notice when you fix a word; it reads only the pasted words and a little context, keeps nothing, and asks before adding anything to the dictionary.
-- **No network.** The only request Pladder ever makes is the one-time download of the speech model from Hugging Face, about 700 MB, on first launch. After that it works with Wi-Fi off. There is no update check, no crash reporter, no analytics.
+- **No network.** The only request Pladder ever makes is the one-time download of the speech model from Hugging Face, about 700 MB, on first launch, and, only if you pick S1-mini for the experimental polish, the one-time download of that model from Hugging Face too. After that it works with Wi-Fi off. There is no update check, no crash reporter, no analytics.
 - **No account.** Nothing to sign up for, nothing to log in to, nothing to cancel.
 - **Auditable.** The app is about five thousand lines of Swift under the MIT license, and none of them open a network connection. The model download is FluidAudio's, and it runs once.
 
@@ -151,7 +152,7 @@ Option+Space is Alfred's default hotkey and a common Raycast choice, and it type
 Yes. Press the send key, Right Option by default, at any point while you hold the push-to-talk key, and Return is pressed after the text is pasted. That sends a chat message or runs a terminal command without touching the keyboard again. The send key can be changed in Settings, like the push-to-talk key.
 
 **Can it clean up what I said?**
-Record a key for Dictate and polish in Settings and hold that instead. The dictation goes through Apple Intelligence on your Mac before it is pasted, which takes a second or two. It needs Apple Intelligence turned on in System Settings; without it that key pastes the text as dictated.
+Turn on Polish dictations in Settings, Processing, and pick a model. Apple Intelligence needs nothing downloaded but takes a second or two and needs Apple Intelligence turned on in System Settings. S1-mini by Superwhisper is downloaded once from Hugging Face (1.5 GB, or 805 MB at 8-bit) and takes about half a second; it is trained on English and also handles German and Spanish. Anything a model cannot fix is pasted as dictated.
 
 **Can I toggle instead of holding?**
 Yes. Record a toggle key in Settings: one tap starts a recording, the next tap inserts it. Give it the same combination as the push-to-talk key and that key does both: tap to start and tap again to insert, or hold and release as before. Escape discards a recording either way.
diff --git a/Sources/Pladder/AppModel.swift b/Sources/Pladder/AppModel.swift
index 3667f7e..d25acbb 100644
--- a/Sources/Pladder/AppModel.swift
+++ b/Sources/Pladder/AppModel.swift
@@ -51,6 +51,19 @@ final class AppModel {
     /// no-op that pastes as dictated.
     private(set) var polishAvailability: OnDeviceModelAvailability = TranscriptPolisher.availability
 
+    /// Where the chosen polish model's file stands; nil for Apple's, which
+    /// has none. Shown under the model picker.
+    private(set) var polishModelStatus: ModelFileStatus?
+    /// The coordinator's refiner; `applyPolishModel` points it at the model
+    /// the settings name.
+    private let polishRouter: PolishRouter
+    private let applePolisher = TranscriptPolisher()
+    /// The S1-mini polisher for the chosen file, nil while Apple's is chosen.
+    /// Only one is ever held, so switching frees the other's memory.
+    private var s1MiniPolisher: S1MiniPolisher?
+    private let modelFiles: ModelFiles
+    private let modelStatusRelay = ModelStatusRelay()
+
     /// The default chord, standing in for a stored chord Carbon cannot
     /// register while Accessibility is missing. The stored chord is never
     /// rewritten and returns with the grant.
@@ -135,6 +148,9 @@ final class AppModel {
                 // modifier-only one does.
                 updateEffectiveHotkey()
             }
+            if newValue.polishModel != old.polishModel || newValue.polishDictations != old.polishDictations {
+                applyPolishModel()
+            }
             try? store.save(newValue)
         }
     }
@@ -198,18 +214,27 @@ final class AppModel {
 
         // Processors, in pipeline order: fillers go first so the dictionary sees
         // cleaned text, the fuzzy custom-word corrector runs after the exact
-        // replacer so it only sees what the replacer could not fix, and
-        // whitespace is tidied last. Each entry is a factory so a processor that
-        // needs settings builds itself from them; nothing here knows which
-        // processor that is.
+        // replacer so it only sees what the replacer could not fix, whitespace
+        // is tidied next, and spoken punctuation comes last, because the
+        // whitespace step would fold its paragraph breaks back into spaces.
+        // Each entry is a factory so a processor that needs settings builds
+        // itself from them; nothing here knows which processor that is.
         let processorFactories: [@Sendable (Settings) -> any TextProcessor] = [
             { _ in FillerRemover(languageHint: { TranscriptLanguage.hint(for: $0) }) },
             { DictionaryReplacer(entries: $0.dictionary) },
             { CustomWordCorrector(entries: $0.dictionary) },
             { _ in WhitespaceNormalizer() },
+            { _ in SpokenPunctuation(languageHint: { TranscriptLanguage.hint(for: $0) }) },
         ]
         self.processors = processorFactories.map { $0(initial) }
 
+        let router = PolishRouter(applePolisher)
+        polishRouter = router
+        let modelStatusRelay = self.modelStatusRelay
+        modelFiles = ModelFiles(directory: ModelFiles.defaultDirectory) { file, status in
+            modelStatusRelay.send(file, status)
+        }
+
         let events = self.events
         let trusted = Permissions.isAccessibilityTrusted
         hotkeyUsesTap = trusted
@@ -221,7 +246,7 @@ final class AppModel {
             outputMuter: OutputMuteController(
                 control: CoreAudioOutputMute(),
                 log: { Self.muteLog.info("\($0, privacy: .public)") }),
-            refiner: TranscriptPolisher(),
+            refiner: router,
             hotkeyMonitor: trusted ? tapHotkey : carbonHotkey,
             makePipeline: { s in
                 ProcessorPipeline(processorFactories.map { $0(s) }, onFailure: { id, error in
@@ -250,6 +275,10 @@ final class AppModel {
         overlay = OverlayController(coordinator: coordinator)
         events.handler = { [weak self] event, at in self?.handle(event, at: at) }
         proposalRelay.handler = { [weak self] proposal in self?.propose(proposal) }
+        modelStatusRelay.handler = { [weak self] file, status in
+            guard let self, ModelFile(for: self.settings.polishModel) == file else { return }
+            self.polishModelStatus = status
+        }
     }
 
     /// `PLADDER_SETTINGS_PATH` points a copy launched for testing at a file
@@ -300,9 +329,59 @@ final class AppModel {
         }
         overlay.start()
         coordinator.start()
+        applyPolishModel()
         startPermissionMirroring()
     }
 
+    // MARK: Polish model
+
+    /// Points the coordinator's refiner at the chosen model. An S1-mini file
+    /// is downloaded only while polish is on and that model is chosen, the
+    /// one network use besides the speech model's; it is loaded at the first
+    /// key-down, not here, and freed when polish goes off or another model
+    /// is picked.
+    private func applyPolishModel() {
+        guard let file = ModelFile(for: settings.polishModel) else {
+            releaseS1Mini()
+            polishRouter.use(applePolisher)
+            polishModelStatus = nil
+            return
+        }
+        if s1MiniPolisher?.file != file {
+            releaseS1Mini()
+            let polisher = S1MiniPolisher(file: file, location: modelFiles.location(of: file))
+            s1MiniPolisher = polisher
+            polishRouter.use(polisher)
+        }
+        let polishing = settings.polishDictations
+        if !polishing, let polisher = s1MiniPolisher {
+            Task { await polisher.unload() }
+        }
+        if polishing {
+            Task.detached(priority: .utility) { await S1MiniPolisher.warmUpRuntime() }
+        }
+        let files = modelFiles
+        Task { [weak self] in
+            if polishing { await files.ensure(file) }
+            let status = await files.status(of: file)
+            guard let self, ModelFile(for: self.settings.polishModel) == file else { return }
+            self.polishModelStatus = status
+        }
+    }
+
+    /// Tries a failed download again; the picker's "Try Again".
+    func retryPolishModelDownload() {
+        guard let file = ModelFile(for: settings.polishModel) else { return }
+        let files = modelFiles
+        Task { await files.ensure(file) }
+    }
+
+    private func releaseS1Mini() {
+        guard let polisher = s1MiniPolisher else { return }
+        s1MiniPolisher = nil
+        Task { await polisher.unload() }
+    }
+
     func stop() {
         permissionTask?.cancel()
         overlay.stop()
@@ -333,7 +412,7 @@ final class AppModel {
             let total = Self.seconds(instant - released)
             // A polish cycle gets its own line, so the plain one stays the
             // number the benchmark rule watches; one predicate finds both.
-            let polish = timing.polish.map { "polish \(fmt($0)), " } ?? ""
+            let polish = timing.polish.map { "polish \(fmt($0)) (\(settings.polishModel.rawValue)), " } ?? ""
             let label = timing.polish == nil ? "release-to-paste" : "polished release-to-paste"
             let stages = "stop \(fmt(timing.captureStop)), engine \(fmt(timing.engine)), " +
                 "process \(fmt(timing.processing)), \(polish)paste \(fmt(timing.insert))"
@@ -616,6 +695,18 @@ final class AppModel {
     }
 }
 
+/// Bridges `ModelFiles`' status changes onto the main actor, and lets the
+/// files be set up before `self` exists, as `EventRelay` does for the
+/// coordinator.
+@MainActor
+final class ModelStatusRelay {
+    var handler: ((ModelFile, ModelFileStatus) -> Void)?
+
+    nonisolated func send(_ file: ModelFile, _ status: ModelFileStatus) {
+        Task { @MainActor in self.handler?(file, status) }
+    }
+}
+
 /// Bridges the learner's proposals onto the main actor, and lets the learner
 /// be built before `self` exists, as `EventRelay` does for the coordinator.
 @MainActor
diff --git a/Sources/Pladder/PolishRouter.swift b/Sources/Pladder/PolishRouter.swift
new file mode 100644
index 0000000..330e160
--- /dev/null
+++ b/Sources/Pladder/PolishRouter.swift
@@ -0,0 +1,26 @@
+import PladderCore
+import Synchronization
+
+/// The coordinator's one refiner. The coordinator is built once and keeps
+/// its refiner for life, while the polish model can be switched at any time,
+/// so this hands each call to the model the settings name. The switch is a
+/// lock around one reference; the call itself runs outside it.
+final class PolishRouter: TranscriptRefiner {
+    private let current: Mutex<any TranscriptRefiner>
+
+    init(_ initial: any TranscriptRefiner) {
+        current = Mutex(initial)
+    }
+
+    func use(_ refiner: any TranscriptRefiner) {
+        current.withLock { $0 = refiner }
+    }
+
+    func prepare() async {
+        await current.withLock { $0 }.prepare()
+    }
+
+    func refine(_ text: String) async -> String? {
+        await current.withLock { $0 }.refine(text)
+    }
+}
diff --git a/Sources/Pladder/Resources/Localizable.xcstrings b/Sources/Pladder/Resources/Localizable.xcstrings
index 6d4724c..2e3b773 100644
--- a/Sources/Pladder/Resources/Localizable.xcstrings
+++ b/Sources/Pladder/Resources/Localizable.xcstrings
@@ -1421,12 +1421,142 @@
         }
       }
     },
-    "Before the text is pasted, Apple Intelligence cleans it up on this Mac: self-corrections, spoken punctuation and numbers, lists. This adds a second or two to every dictation, and anything the model cannot fix is pasted as dictated.": {
+    "Spoken punctuation": {
       "localizations": {
         "de": {
           "stringUnit": {
             "state": "translated",
-            "value": "Bevor der Text eingefügt wird, bereinigt Apple Intelligence ihn auf diesem Mac: Selbstkorrekturen, gesprochene Satzzeichen und Zahlen, Listen. Das fügt jedem Diktat ein bis zwei Sekunden hinzu, und alles, was das Modell nicht beheben kann, wird so eingefügt, wie es diktiert wurde."
+            "value": "Gesprochene Satzzeichen"
+          }
+        }
+      }
+    },
+    "Turns spoken marks such as “comma”, “question mark” and “new paragraph” into the marks themselves, in English, German and Spanish.": {
+      "localizations": {
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Macht aus gesprochenen Zeichen wie „Komma“, „Fragezeichen“ und „neuer Absatz“ die Zeichen selbst, auf Englisch, Deutsch und Spanisch."
+          }
+        }
+      }
+    },
+    "Model": {
+      "localizations": {
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Modell"
+          }
+        }
+      }
+    },
+    "Apple Intelligence": {
+      "localizations": {
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Apple Intelligence"
+          }
+        }
+      }
+    },
+    "S1-mini by Superwhisper (1.5 GB)": {
+      "localizations": {
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "S1-mini von Superwhisper (1,5 GB)"
+          }
+        }
+      }
+    },
+    "S1-mini by Superwhisper, 8-bit (805 MB)": {
+      "localizations": {
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "S1-mini von Superwhisper, 8 Bit (805 MB)"
+          }
+        }
+      }
+    },
+    "Downloads when polish is on.": {
+      "localizations": {
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Wird geladen, sobald „Diktate polieren“ an ist."
+          }
+        }
+      }
+    },
+    "Downloading %@…": {
+      "localizations": {
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "%@ wird geladen…"
+          }
+        }
+      }
+    },
+    "Checking the download…": {
+      "localizations": {
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Download wird geprüft…"
+          }
+        }
+      }
+    },
+    "Try Again": {
+      "localizations": {
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Erneut versuchen"
+          }
+        }
+      }
+    },
+    "The download stopped, so dictations paste as dictated.": {
+      "localizations": {
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Der Download wurde abgebrochen, Diktate werden deshalb unverändert eingefügt."
+          }
+        }
+      }
+    },
+    "The download did not match the published model and was deleted, so dictations paste as dictated.": {
+      "localizations": {
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Der Download passte nicht zum veröffentlichten Modell und wurde gelöscht, Diktate werden deshalb unverändert eingefügt."
+          }
+        }
+      }
+    },
+    "The model could not be saved, probably for lack of disk space, so dictations paste as dictated.": {
+      "localizations": {
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Das Modell konnte nicht gespeichert werden, vermutlich fehlt Speicherplatz. Diktate werden deshalb unverändert eingefügt."
+          }
+        }
+      }
+    },
+    "Before the text is pasted, the model cleans it up on this Mac: self-corrections, spoken punctuation, lists. Apple Intelligence adds one to two seconds to every dictation, S1-mini by Superwhisper about half a second. S1-mini is trained on English, also handles German and Spanish, and is downloaded once from Hugging Face when you pick it. Anything a model cannot fix is pasted as dictated.": {
+      "localizations": {
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Bevor der Text eingefügt wird, bereinigt ihn das Modell auf diesem Mac: Selbstkorrekturen, gesprochene Satzzeichen, Listen. Apple Intelligence braucht dafür ein bis zwei Sekunden pro Diktat, S1-mini von Superwhisper etwa eine halbe. S1-mini ist auf Englisch trainiert, kann auch Deutsch und Spanisch und wird einmalig von Hugging Face geladen, wenn du es auswählst. Was ein Modell nicht bereinigen kann, wird unverändert eingefügt."
           }
         }
       }
diff --git a/Sources/Pladder/Settings/SettingsView.swift b/Sources/Pladder/Settings/SettingsView.swift
index 3b23619..3587678 100644
--- a/Sources/Pladder/Settings/SettingsView.swift
+++ b/Sources/Pladder/Settings/SettingsView.swift
@@ -1,6 +1,7 @@
 import AVFoundation
 import SwiftUI
 import PladderCore
+import PladderRefine
 
 import PladderSystem
 
@@ -352,21 +353,60 @@ private struct ProcessingSettingsView: View {
 
             Section {
                 Toggle("Polish dictations", isOn: $model.settings.polishDictations)
-                if let warning = model.polishAvailability.polishKeyText {
-                    Label(warning, systemImage: "exclamationmark.triangle")
-                        .font(.callout)
-                        .foregroundStyle(.orange)
-                        .fixedSize(horizontal: false, vertical: true)
+                Picker("Model", selection: $model.settings.polishModel) {
+                    ForEach(PolishModel.allCases, id: \.self) { choice in
+                        Text(choice.displayName).tag(choice)
+                    }
                 }
+                polishModelStatus
             } header: {
                 Text("Experimental")
             } footer: {
-                FootnoteText("Before the text is pasted, Apple Intelligence cleans it up on this Mac: self-corrections, spoken punctuation and numbers, lists. This adds a second or two to every dictation, and anything the model cannot fix is pasted as dictated.")
+                FootnoteText("Before the text is pasted, the model cleans it up on this Mac: self-corrections, spoken punctuation, lists. Apple Intelligence adds one to two seconds to every dictation, S1-mini by Superwhisper about half a second. S1-mini is trained on English, also handles German and Spanish, and is downloaded once from Hugging Face when you pick it. Anything a model cannot fix is pasted as dictated.")
             }
         }
         .formStyle(.grouped)
     }
 
+    /// What stands between the chosen model and a polished dictation:
+    /// Apple Intelligence switched off, or an S1-mini file still to come.
+    @ViewBuilder
+    private var polishModelStatus: some View {
+        if let status = model.polishModelStatus {
+            switch status {
+            case .ready:
+                EmptyView()
+            case .missing:
+                FootnoteText("Downloads when polish is on.")
+            case .downloading(let fraction):
+                ProgressView(value: fraction) {
+                    Text("Downloading \(model.settings.polishModel.displayName)…")
+                        .font(.callout)
+                } currentValueLabel: {
+                    Text(fraction, format: .percent.precision(.fractionLength(0)))
+                }
+            case .verifying:
+                ProgressView {
+                    Text("Checking the download…").font(.callout)
+                }
+            case .failed(let failure):
+                HStack(alignment: .firstTextBaseline) {
+                    Label(failure.text, systemImage: "exclamationmark.triangle")
+                        .font(.callout)
+                        .foregroundStyle(.orange)
+                        .fixedSize(horizontal: false, vertical: true)
+                    Spacer()
+                    Button("Try Again") { model.retryPolishModelDownload() }
+                }
+            }
+        } else if let warning = model.polishAvailability.polishKeyText {
+            Label(warning, systemImage: "exclamationmark.triangle")
+                .font(.callout)
+                .foregroundStyle(.orange)
+                .fixedSize(horizontal: false, vertical: true)
+        }
+    }
+
     /// Settings stores the *disabled* IDs, so absence means on.
     private func binding(for id: String) -> Binding<Bool> {
         Binding(
diff --git a/Sources/Pladder/StatusText.swift b/Sources/Pladder/StatusText.swift
index c43b69d..2c564cf 100644
--- a/Sources/Pladder/StatusText.swift
+++ b/Sources/Pladder/StatusText.swift
@@ -84,3 +84,29 @@ extension OnDeviceModelAvailability {
         }
     }
 }
+
+extension PolishModel {
+    /// The picker's wording. S1-mini's licence asks for its name exactly
+    /// so: "S1-mini" by "Superwhisper".
+    var displayName: String {
+        switch self {
+        case .appleIntelligence: String(localized: "Apple Intelligence")
+        case .s1Mini: String(localized: "S1-mini by Superwhisper (1.5 GB)")
+        case .s1Mini8Bit: String(localized: "S1-mini by Superwhisper, 8-bit (805 MB)")
+        }
+    }
+}
+
+extension ModelFileFailure {
+    /// Each says what dictations do meanwhile, like the Apple sentences.
+    var text: String {
+        switch self {
+        case .download:
+            String(localized: "The download stopped, so dictations paste as dictated.")
+        case .checksum:
+            String(localized: "The download did not match the published model and was deleted, so dictations paste as dictated.")
+        case .disk:
+            String(localized: "The model could not be saved, probably for lack of disk space, so dictations paste as dictated.")
+        }
+    }
+}
diff --git a/Sources/PladderCLI/main.swift b/Sources/PladderCLI/main.swift
index e56f2c8..322f0ec 100644
--- a/Sources/PladderCLI/main.swift
+++ b/Sources/PladderCLI/main.swift
@@ -6,6 +6,7 @@ import PladderBench
 import PladderCore
 import PladderEngines
 import PladderRefine
+import PladderSystem
 
 // Developer tool.
 //
@@ -28,11 +29,21 @@ import PladderRefine
 //                                         how many there were and what they cost. The
 //                                         `identical:` column then also proves the live
 //                                         passes leave the release's windows alone.
-//   pladder-cli polish <text file | ->    run the polisher over a transcript over a transcript
-//                                         with Apple's on-device model: once cold, once
-//                                         after prepare() and a two-second wait, the way
-//                                         a real press warms it. Prints both timings.
-//       [--instructions <file>]           try another system prompt before committing it.
+//   pladder-cli polish <text file | ->    run the polisher over a transcript: once cold,
+//                                         once after prepare() and a two-second wait, the
+//                                         way a real press warms it. Prints both timings.
+//       [--model <name>]                  apple (default), s1-mini or s1-mini-8bit. An S1-mini
+//                                         file is downloaded first if the app has not yet.
+//       [--instructions <file>]           Apple only: try another system prompt before
+//                                         committing it.
+//       [--gguf <file>]                   instead of --model: any S1-mini-family GGUF, such as a
+//                                         fine-tune being judged before it goes in the picker.
+//       [--control <line>]                S1-mini only: another control line than the app's.
+//   pladder-cli polish-set <set.json>     run a polish model over a test set (docs/polish-set.json)
+//       [--model <name>]                  after the app's processors, warm, and print each
+//                                         answer, the word error rate against the expected
+//                                         text per language, exact matches and timings.
+//       [--gguf <file>] [--control <line>] as for polish.
 //
 // Fixtures are audio files with a sibling .txt holding the spoken script, as
 // produced by scripts/make-fixtures.sh.
@@ -42,7 +53,8 @@ func usage() -> Never {
     usage: pladder-cli <audio file>
            pladder-cli bench <fixtures dir> [--runs N] [--pause S]
            pladder-cli bench <fixtures dir> --paced [--runs N] [--pause S] [--all] [--live]
-           pladder-cli polish <text file | -> [--instructions <file>]
+           pladder-cli polish <text file | -> [--model apple|s1-mini|s1-mini-8bit | --gguf <file>] [--control <line>] [--instructions <file>]
+           pladder-cli polish-set <set.json> [--model apple|s1-mini|s1-mini-8bit | --gguf <file>] [--control <line>]
 
     """.utf8))
     exit(2)
@@ -464,7 +476,7 @@ func runPacedBench(dir: String, runs: Int, pause: Double, includeShort: Bool, li
 /// polish toggle would paste. The first run is cold (no `prepare()`), the second
 /// warm, which is what a real press gets: the session is made and prewarmed
 /// at key-down, seconds before the release.
-func runPolish(_ path: String, instructionsPath: String?) async throws {
+func runPolish(_ path: String, model: PolishModel, options: PolishOptions) async throws {
     let text: String
     if path == "-" {
         text = String(decoding: FileHandle.standardInput.readDataToEndOfFile(), as: UTF8.self)
@@ -472,7 +484,9 @@ func runPolish(_ path: String, instructionsPath: String?) async throws {
         text = try String(contentsOf: URL(fileURLWithPath: path), encoding: .utf8)
     }
     let transcript = text.trimmingCharacters(in: .whitespacesAndNewlines)
-    print("availability: \(TranscriptPolisher.availability)")
+    if model == .appleIntelligence {
+        print("availability: \(TranscriptPolisher.availability)")
+    }
     print("input (\(transcript.split(whereSeparator: \.isWhitespace).count) words):")
     print(transcript)
 
@@ -488,20 +502,130 @@ func runPolish(_ path: String, instructionsPath: String?) async throws {
         }
     }
 
-    let polisher: TranscriptPolisher
-    if let instructionsPath {
-        let instructions = try String(contentsOf: URL(fileURLWithPath: instructionsPath), encoding: .utf8)
-        polisher = TranscriptPolisher(instructions: instructions)
-        print("instructions: \(instructionsPath)")
-    } else {
-        polisher = TranscriptPolisher()
-    }
+    let polisher = try await makePolisher(model, options: options)
     show("cold", await polisher.polish(transcript))
     await polisher.prepare()
     try await Task.sleep(for: .seconds(2))
     show("warm", await polisher.polish(transcript))
 }
 
+/// Either polisher behind one face, for the CLI: both report the same way.
+struct CLIPolisher {
+    let polish: @Sendable (String) async -> TranscriptPolisher.Report
+    let prepare: @Sendable () async -> Void
+}
+
+/// What the command line changes about a polisher; nil is the app's own.
+struct PolishOptions {
+    var instructionsPath: String?
+    var gguf: String?
+    var control: String?
+}
+
+/// The polisher the app would use for `model`, downloading an S1-mini file
+/// into the app's own model directory first if it is not there yet. With
+/// `--gguf`, an S1-mini polisher over that file instead.
+func makePolisher(_ model: PolishModel, options: PolishOptions = PolishOptions()) async throws -> CLIPolisher {
+    let instructionsPath = options.instructionsPath
+    if let gguf = options.gguf {
+        if instructionsPath != nil { usage() }
+        let url = URL(fileURLWithPath: gguf)
+        let file = ModelFile(fileName: url.lastPathComponent, url: url, sha256: "", byteCount: 0)
+        let polisher = S1MiniPolisher(file: file, location: url, control: options.control ?? S1MiniPolisher.controlLine)
+        print("model: \(gguf)")
+        if let control = options.control { print("control: \(control)") }
+        return CLIPolisher(polish: { await polisher.polish($0) }, prepare: { await polisher.prepare() })
+    }
+    guard let file = ModelFile(for: model) else {
+        if options.control != nil { usage() }
+        let polisher: TranscriptPolisher
+        if let instructionsPath {
+            let instructions = try String(contentsOf: URL(fileURLWithPath: instructionsPath), encoding: .utf8)
+            polisher = TranscriptPolisher(instructions: instructions)
+            print("instructions: \(instructionsPath)")
+        } else {
+            polisher = TranscriptPolisher()
+        }
+        return CLIPolisher(polish: { await polisher.polish($0) }, prepare: { await polisher.prepare() })
+    }
+    if instructionsPath != nil { usage() }
+    let files = ModelFiles(directory: ModelFiles.defaultDirectory) { _, status in
+        if case .downloading(let fraction) = status {
+            FileHandle.standardError.write(Data(String(format: "\rdownloading %3.0f%%", fraction * 100).utf8))
+        } else if status == .verifying {
+            FileHandle.standardError.write(Data("\rverifying          \n".utf8))
+        }
+    }
+    await files.ensure(file)
+    let status = await files.finished(file)
+    guard status == .ready else {
+        FileHandle.standardError.write(Data("\(file.fileName): \(status)\n".utf8))
+        exit(1)
+    }
+    let polisher = S1MiniPolisher(
+        file: file, location: files.location(of: file), control: options.control ?? S1MiniPolisher.controlLine)
+    print("model: \(file.fileName)")
+    if let control = options.control { print("control: \(control)") }
+    return CLIPolisher(polish: { await polisher.polish($0) }, prepare: { await polisher.prepare() })
+}
+
+/// One case of a polish test set: what the speech model heard and what
+/// should be pasted.
+struct PolishCase: Decodable {
+    let id: String
+    let lang: String
+    let input: String
+    let expected: String
+}
+
+/// Runs `model` over a test set the way the app would: the app's processors
+/// first, then the polish, warm. Prints every answer, then per-language word
+/// error rates against the expected text (case and punctuation ignored),
+/// exact matches (everything counts) and the polish time.
+func runPolishSet(_ path: String, model: PolishModel, options: PolishOptions) async throws {
+    let cases = try JSONDecoder().decode([PolishCase].self, from: Data(contentsOf: URL(fileURLWithPath: path)))
+    let hint: @Sendable (String) -> String? = { TranscriptLanguage.hint(for: $0) }
+    let pipeline = ProcessorPipeline([
+        FillerRemover(languageHint: hint), WhitespaceNormalizer(), SpokenPunctuation(languageHint: hint),
+    ])
+    let polisher = try await makePolisher(model, options: options)
+    await polisher.prepare()
+    // The first call pays for whatever prepare() could not warm.
+    _ = await polisher.polish("Warm up.")
+
+    var rates: [String: [Double]] = [:]
+    var exact = 0
+    var times: [Double] = []
+    for item in cases {
+        let processed = await pipeline.run(item.input)
+        let report = await polisher.polish(processed)
+        let output = report.text ?? processed
+        times.append(seconds(report.elapsed))
+        rates[item.lang, default: []].append(WordErrorRate.compute(reference: item.expected, hypothesis: output))
+        let matched = output.trimmingCharacters(in: .whitespacesAndNewlines) == item.expected
+        if matched { exact += 1 }
+        let failure = report.failure.map { " (\($0))" } ?? ""
+        print(String(format: "%@ %-26@ %5.2f s%@", matched ? "=" : " ", item.id, seconds(report.elapsed), failure))
+        print("    \(output.replacingOccurrences(of: "\n", with: "⏎"))")
+    }
+    print("")
+    let all = rates.values.flatMap { $0 }
+    let mean = { (values: [Double]) in values.reduce(0, +) / Double(max(values.count, 1)) }
+    let perLanguage = rates.keys.sorted().map { String(format: "%@ %.3f", $0, mean(rates[$0]!)) }.joined(separator: "  ")
+    times.sort()
+    print(String(format: "WER %.3f (%@), exact %d of %d, polish median %.2f s, p90 %.2f s",
+                 mean(all), perLanguage, exact, cases.count, times[times.count / 2], times[Int(Double(times.count) * 0.9)]))
+}
+
+func polishModel(named name: String) -> PolishModel? {
+    switch name {
+    case "apple": .appleIntelligence
+    case "s1-mini": .s1Mini
+    case "s1-mini-8bit": .s1Mini8Bit
+    default: nil
+    }
+}
+
 // MARK: - Entry
 
 var arguments = Array(CommandLine.arguments.dropFirst())
@@ -546,16 +670,25 @@ case "bench":
         if includeShort || live { usage() }
         try await runBench(dir: dir, runs: runs, pause: pause)
     }
-case "polish":
-    arguments.removeFirst()
-    var instructionsPath: String?
+case "polish", "polish-set":
+    let command = arguments.removeFirst()
+    var options = PolishOptions()
+    var model = PolishModel.appleIntelligence
     var textPath: String?
     while let arg = arguments.first {
         arguments.removeFirst()
-        if arg == "--instructions" {
+        if arg == "--instructions", command == "polish" {
+            guard let value = arguments.first else { usage() }
+            arguments.removeFirst()
+            options.instructionsPath = value
+        } else if arg == "--gguf" || arg == "--control" {
             guard let value = arguments.first else { usage() }
             arguments.removeFirst()
-            instructionsPath = value
+            if arg == "--gguf" { options.gguf = value } else { options.control = value }
+        } else if arg == "--model" {
+            guard let value = arguments.first, let chosen = polishModel(named: value) else { usage() }
+            arguments.removeFirst()
+            model = chosen
         } else if textPath == nil {
             textPath = arg
         } else {
@@ -563,7 +696,11 @@ case "polish":
         }
     }
     guard let textPath else { usage() }
-    try await runPolish(textPath, instructionsPath: instructionsPath)
+    if command == "polish" {
+        try await runPolish(textPath, model: model, options: options)
+    } else {
+        try await runPolishSet(textPath, model: model, options: options)
+    }
 case let path?:
     try await transcribeFile(path)
 }
diff --git a/Sources/PladderCore/Models/Settings.swift b/Sources/PladderCore/Models/Settings.swift
index 5746868..3915fd1 100644
--- a/Sources/PladderCore/Models/Settings.swift
+++ b/Sources/PladderCore/Models/Settings.swift
@@ -32,6 +32,18 @@ public enum OverlayAnimationSpeed: String, Codable, Sendable, CaseIterable, Equa
     }
 }
 
+/// Which model the polish runs through. Pure data; PladderRefine maps each
+/// case to a model and the app words it.
+public enum PolishModel: String, Codable, Sendable, CaseIterable, Equatable {
+    /// Apple's on-device model, part of macOS: nothing to download.
+    case appleIntelligence
+    /// S1-mini by Superwhisper at full precision (16-bit), downloaded once.
+    case s1Mini
+    /// The same model at 8-bit: about half the download and memory, and
+    /// faster, for a little accuracy (docs/BENCHMARKS.md).
+    case s1Mini8Bit
+}
+
 /// Everything the user can change. Persisted as JSON by `SettingsStore`.
 public struct Settings: Codable, Sendable, Equatable {
     public var engineID: EngineID
@@ -44,6 +56,8 @@ public struct Settings: Codable, Sendable, Equatable {
     /// Experimental and off by default: the model costs one to three seconds,
     /// so this sits on the normal hotkey's release path.
     public var polishDictations: Bool
+    /// What `polishDictations` runs the text through.
+    public var polishModel: PolishModel
     /// A chord that starts a recording on one press and ends it on the next.
     /// The same chord as `hotkey` makes that key hybrid: a tap latches, a hold
     /// stops at release. Empty, the default, turns it off.
@@ -74,6 +88,7 @@ public struct Settings: Codable, Sendable, Equatable {
         hotkey: Hotkey = .optionSpace,
         submitKey: Hotkey = .rightOption,
         polishDictations: Bool = false,
+        polishModel: PolishModel = .appleIntelligence,
         toggleHotkey: Hotkey = Hotkey(keyCodes: []),
         disabledProcessors: Set<String> = [],
         dictionary: [DictionaryEntry] = [],
@@ -90,6 +105,7 @@ public struct Settings: Codable, Sendable, Equatable {
         self.hotkey = hotkey
         self.submitKey = submitKey
         self.polishDictations = polishDictations
+        self.polishModel = polishModel
         self.toggleHotkey = toggleHotkey
         self.disabledProcessors = disabledProcessors
         self.dictionary = dictionary
@@ -106,7 +122,7 @@ public struct Settings: Codable, Sendable, Equatable {
     // Decoding tolerates missing keys so adding a field in a later version
     // never makes an existing settings file unreadable.
     private enum CodingKeys: String, CodingKey {
-        case engineID, hotkey, submitKey, polishDictations, disabledProcessors, dictionary, appendTrailingSpace, launchAtLogin, playSounds, appearance
+        case engineID, hotkey, submitKey, polishDictations, polishModel, disabledProcessors, dictionary, appendTrailingSpace, launchAtLogin, playSounds, appearance
         case overlayStyle, overlayGlass, overlayAnimationSpeed, muteOutputWhileDictating
         case toggleHotkey
         // Read once for the migration, never written.
@@ -128,6 +144,9 @@ public struct Settings: Codable, Sendable, Equatable {
         let legacyPolish = try c.decodeIfPresent(Hotkey.self, forKey: .polishHotkey) ?? Hotkey(keyCodes: [])
         polishDictations = try c.decodeIfPresent(Bool.self, forKey: .polishDictations)
             ?? (!legacyPolish.isEmpty)
+        // A model this build does not know, say from a newer version, falls
+        // back to Apple's rather than making the whole file unreadable.
+        polishModel = (try? c.decodeIfPresent(PolishModel.self, forKey: .polishModel)) ?? .appleIntelligence
         // Like the submit key, empty is meaningful: off.
         toggleHotkey = try c.decodeIfPresent(Hotkey.self, forKey: .toggleHotkey) ?? Hotkey(keyCodes: [])
         disabledProcessors = try c.decodeIfPresent(Set<String>.self, forKey: .disabledProcessors) ?? []
@@ -150,6 +169,7 @@ public struct Settings: Codable, Sendable, Equatable {
         try c.encode(hotkey, forKey: .hotkey)
         try c.encode(submitKey, forKey: .submitKey)
         try c.encode(polishDictations, forKey: .polishDictations)
+        try c.encode(polishModel, forKey: .polishModel)
         try c.encode(toggleHotkey, forKey: .toggleHotkey)
         try c.encode(disabledProcessors, forKey: .disabledProcessors)
         try c.encode(dictionary, forKey: .dictionary)
diff --git a/Sources/PladderCore/Processors/FillerRemover.swift b/Sources/PladderCore/Processors/FillerRemover.swift
index 85d5294..be7c9c5 100644
--- a/Sources/PladderCore/Processors/FillerRemover.swift
+++ b/Sources/PladderCore/Processors/FillerRemover.swift
@@ -120,26 +120,51 @@ public struct FillerRemover: TextProcessor {
         var out = ""
         out.reserveCapacity(text.count)
         var cursor = 0
+        // Set by a filler that opened a sentence, and spent on the first
+        // letter that follows it: "Test. Ähm, beim Timeout" keeps "Beim"
+        // a sentence start, as a filler opening the transcript always did.
+        var capitalizeNext = false
+        func append(_ segment: String) {
+            guard capitalizeNext, let letter = segment.firstIndex(where: { !$0.isWhitespace }) else {
+                out += segment
+                return
+            }
+            capitalizeNext = false
+            out += segment[..<letter]
+            out += segment[letter].uppercased()
+            out += segment[segment.index(after: letter)...]
+        }
         for match in matches {
-            out += ns.substring(with: NSRange(location: cursor, length: match.range.location - cursor))
+            let before = ns.substring(with: NSRange(location: cursor, length: match.range.location - cursor))
+            append(before)
+            if !capitalizeNext { capitalizeNext = Self.endsSentence(out) }
             cursor = match.range.upperBound
             out += " "
         }
-        out += ns.substring(from: cursor)
+        append(ns.substring(from: cursor))
 
-        var result = spaceRun.stringByReplacingMatches(
+        return spaceRun.stringByReplacingMatches(
             in: out,
             range: NSRange(location: 0, length: (out as NSString).length),
             withTemplate: " ")
             .trimmingCharacters(in: .whitespaces)
-        guard !result.isEmpty else { return "" }
+    }
 
-        if matches[0].range.location == 0,
-           let first = result.first,
-           first.isLowercase
-        {
-            result = String(first).uppercased() + result.dropFirst()
+    /// Whether text ends where a sentence may start: nothing yet, or a full
+    /// stop, question or exclamation mark. An ellipsis trails off rather
+    /// than ending one.
+    private static func endsSentence(_ text: String) -> Bool {
+        // From the end, since this runs once per filler on the text so far.
+        var end = text.endIndex
+        while end > text.startIndex, text[text.index(before: end)].isWhitespace {
+            end = text.index(before: end)
+        }
+        guard end > text.startIndex else { return true }
+        let head = text[..<end]
+        switch head.last {
+        case "!", "?": return true
+        case ".": return !head.hasSuffix("..")
+        default: return false
         }
-        return result
     }
 }
diff --git a/Sources/PladderCore/Processors/SpokenPunctuation.swift b/Sources/PladderCore/Processors/SpokenPunctuation.swift
new file mode 100644
index 0000000..8bd326c
--- /dev/null
+++ b/Sources/PladderCore/Processors/SpokenPunctuation.swift
@@ -0,0 +1,178 @@
+import Foundation
+
+/// Turns punctuation the speaker said out loud into the mark: "question
+/// mark", "Fragezeichen", "signo de interrogación" become "?", and so on in
+/// English, German and Spanish.
+///
+/// The speech model already turns most spoken marks into punctuation and
+/// numbers into digits; what reaches this step is the rest, usually with the
+/// model's own punctuation stuck to it ("verschieben? Fragezeichen."). That
+/// punctuation is absorbed into the mark, so the result carries it once.
+///
+/// Only phrases that are never an ordinary word are taken. "period",
+/// "Punkt" and "punto" are left alone, since "a trial period", "ein
+/// wichtiger Punkt" and "el punto" are far more common than a dictated full
+/// stop, and so are "colon" and "dos puntos". The one ambiguous phrase kept,
+/// Spanish "coma", is a word in English too, so it needs the same language
+/// evidence the filler remover uses. Between two digits "Komma" and "coma"
+/// are the decimal comma: "3 Komma 5" becomes "3,5".
+///
+/// Runs after the whitespace step, which would otherwise fold the line
+/// breaks of "new paragraph" back into spaces.
+public struct SpokenPunctuation: TextProcessor {
+    public static let processorID = "spoken-punctuation"
+
+    public let id = SpokenPunctuation.processorID
+    public let displayName = "Spoken punctuation"
+    public let detail = "Turns spoken marks such as “comma”, “question mark” and “new paragraph” into the marks themselves, in English, German and Spanish."
+
+    private enum Mark {
+        case comma, fullStop, question, exclamation, colon, semicolon, paragraph
+
+        var text: String {
+            switch self {
+            case .comma: ","
+            case .fullStop: "."
+            case .question: "?"
+            case .exclamation: "!"
+            case .colon: ":"
+            case .semicolon: ";"
+            case .paragraph: "\n\n"
+            }
+        }
+
+        /// The next word starts a sentence.
+        var endsSentence: Bool {
+            switch self {
+            case .fullStop, .question, .exclamation, .paragraph: true
+            case .comma, .colon, .semicolon: false
+            }
+        }
+    }
+
+    /// Longer phrases first, so "punto y coma" is never read as "coma".
+    private static let phrases: [(pattern: String, mark: Mark)] = [
+        ("punto y coma", .semicolon),
+        ("semicolon|semikolon", .semicolon),
+        ("question mark|fragezeichen|signo de interrogaci[oó]n", .question),
+        ("exclamation (?:mark|point)|ausrufezeichen|signo de exclamaci[oó]n", .exclamation),
+        ("full stop|punto final", .fullStop),
+        ("doppelpunkt", .colon),
+        ("new paragraph|neuer absatz|nuevo p[aá]rrafo", .paragraph),
+        ("comma|komma", .comma),
+    ]
+
+    /// Needs the language evidence; see the type's comment.
+    private static let spanishComma = "coma"
+
+
+    private let universal: [(regex: NSRegularExpression, mark: Mark)]
+    private let spanish: NSRegularExpression
+    /// Every phrase in one pass. Almost no dictation holds one, and this is
+    /// the only scan such a dictation pays.
+    private let candidate: NSRegularExpression
+    private let languageHint: (@Sendable (String) -> String?)?
+
+    /// - Parameter languageHint: The same closure the filler remover gets:
+    ///   a confident ISO 639-1 code for the text, or nil. Called only when
+    ///   the text holds "coma".
+    public init(languageHint: (@Sendable (String) -> String?)? = nil) {
+        self.languageHint = languageHint
+        universal = Self.phrases.map { (try! NSRegularExpression(pattern: Self.pattern($0.pattern), options: .caseInsensitive), $0.mark) }
+        spanish = try! NSRegularExpression(pattern: Self.pattern(Self.spanishComma), options: .caseInsensitive)
+        let every = (Self.phrases.map(\.pattern) + [Self.spanishComma]).joined(separator: "|")
+        candidate = try! NSRegularExpression(pattern: Self.pattern(every), options: .caseInsensitive)
+    }
+
+    /// The phrase as a whole word. The punctuation around it is taken by
+    /// hand in `apply`: a pattern that starts with optional spaces cannot be
+    /// scanned for quickly.
+    private static func pattern(_ phrase: String) -> String {
+        "\\b(?:\(phrase))\\b"
+    }
+
+    public func process(_ text: String) async throws -> String {
+        guard candidate.firstMatch(in: text, range: NSRange(location: 0, length: (text as NSString).length)) != nil
+        else { return text }
+        var result = text
+        for (regex, mark) in universal {
+            result = Self.apply(regex, mark: mark, to: result)
+        }
+        if result.range(of: Self.spanishComma, options: .caseInsensitive) != nil,
+           let languageHint, languageHint(result) == "es"
+        {
+            result = Self.apply(spanish, mark: .comma, to: result)
+        }
+        return result
+    }
+
+    private static func apply(_ regex: NSRegularExpression, mark: Mark, to text: String) -> String {
+        let ns = text as NSString
+        let matches = regex.matches(in: text, range: NSRange(location: 0, length: ns.length))
+        guard !matches.isEmpty else { return text }
+
+        var out = ""
+        var cursor = 0
+        var capitalizeNext = false
+        for match in matches {
+            // The speech model's own punctuation around the phrase, and the
+            // spaces on either side: "verschieben? Fragezeichen." is one mark.
+            var start = match.range.location
+            while start > cursor, isSpace(ns.character(at: start - 1)) { start -= 1 }
+            while start > cursor, isStray(ns.character(at: start - 1)) { start -= 1 }
+            while start > cursor, isSpace(ns.character(at: start - 1)) { start -= 1 }
+            let lead = ns.substring(with: NSRange(location: start, length: match.range.location - start))
+            var before = ns.substring(with: NSRange(location: cursor, length: start - cursor))
+            if capitalizeNext { before = capitalized(before); capitalizeNext = false }
+            out += before
+            cursor = match.range.upperBound
+            let trailStart = cursor
+            while cursor < ns.length, isStray(ns.character(at: cursor)) { cursor += 1 }
+            let trailed = cursor > trailStart
+            // Spaces after the phrase, up to the next word or line break.
+            while cursor < ns.length, isSpace(ns.character(at: cursor)) { cursor += 1 }
+            let next = cursor < ns.length ? ns.character(at: cursor) : nil
+
+            if mark == .comma, out.last?.isNumber == true, lead.allSatisfy(\.isWhitespace),
+               !trailed, let next, isDigit(next)
+            {
+                // "3 Komma 5": the decimal comma, no spaces.
+                out += ","
+                continue
+            }
+            if mark == .paragraph {
+                // A paragraph keeps the sentence mark before it; only the
+                // spaces go.
+                out += lead.trimmingCharacters(in: .whitespaces)
+                while out.last?.isWhitespace == true { out.removeLast() }
+                out += out.isEmpty ? "" : mark.text
+            } else {
+                while out.last?.isWhitespace == true { out.removeLast() }
+                out += mark.text
+                // One space before the next word; none before a line break
+                // or at the end.
+                if let next, !isNewline(next) { out += " " }
+            }
+            capitalizeNext = mark.endsSentence
+        }
+        var tail = ns.substring(from: cursor)
+        if capitalizeNext { tail = capitalized(tail) }
+        out += tail
+        return out.trimmingCharacters(in: .whitespaces)
+    }
+
+    private static func isSpace(_ c: unichar) -> Bool { c == 0x20 || c == 0x09 || c == 0xA0 }
+    private static func isNewline(_ c: unichar) -> Bool { c == 0x0A || c == 0x0D }
+    private static func isDigit(_ c: unichar) -> Bool { c >= 0x30 && c <= 0x39 }
+    /// Punctuation the speech model put around the spoken word.
+    private static func isStray(_ c: unichar) -> Bool { ",.;:!?".utf16.contains(c) }
+
+    /// The first letter upper-cased, if there is one before anything else.
+    /// A word with a capital inside ("iPhone") is left as it is.
+    private static func capitalized(_ text: String) -> String {
+        guard let index = text.firstIndex(where: { !$0.isWhitespace }), text[index].isLetter else { return text }
+        let next = text.index(after: index)
+        if next < text.endIndex, text[next].isUppercase { return text }
+        return text[..<index] + text[index].uppercased() + text[next...]
+    }
+}
diff --git a/Sources/PladderRefine/LlamaModel.swift b/Sources/PladderRefine/LlamaModel.swift
new file mode 100644
index 0000000..11f3d92
--- /dev/null
+++ b/Sources/PladderRefine/LlamaModel.swift
@@ -0,0 +1,173 @@
+import Foundation
+import llama
+
+/// One GGUF model and one context on llama.cpp, generating greedily.
+///
+/// Every llama.cpp call runs on the model's own serial queue: a decode blocks
+/// its thread for hundreds of milliseconds, which must not happen on Swift's
+/// cooperative pool, and the context is not thread-safe. Callers await.
+///
+/// The prompt is split into a fixed prefix (the system prompt and whatever
+/// never changes) and the part that does. The prefix is decoded once, at
+/// load, and its key-value cache kept, so a dictation only pays for its own
+/// tokens.
+final class LlamaModel: @unchecked Sendable {
+    enum Failure: Error, Equatable {
+        case load
+        case tokenize
+        case decode(Int32)
+        case contextFull
+        case timedOut
+    }
+
+    /// Context length in tokens. The key-value cache is allocated for all of
+    /// it up front (about 114 KB a token for Qwen3-0.6B), so it is sized for
+    /// one chunk of a long dictation, in and out, not for the model's limit.
+    static let contextLength: UInt32 = 2048
+
+    private let queue = DispatchQueue(label: "de.dinooo13.pladder.llama", qos: .userInitiated)
+    // Touched on `queue` only.
+    private let model: OpaquePointer
+    private let context: OpaquePointer
+    private let vocab: OpaquePointer
+    private let sampler: UnsafeMutablePointer<llama_sampler>
+    private let prefix: [llama_token]
+
+    /// Loads the model onto the GPU and decodes `prefix`. Blocking; call from
+    /// `load(path:prefix:)`.
+    private init(path: String, prefix: String) throws {
+        _ = Self.backend
+        var modelParams = llama_model_default_params()
+        modelParams.n_gpu_layers = -1
+        guard let model = llama_model_load_from_file(path, modelParams) else { throw Failure.load }
+        var contextParams = llama_context_default_params()
+        contextParams.n_ctx = Self.contextLength
+        contextParams.n_batch = Self.contextLength
+        contextParams.no_perf = true
+        guard let context = llama_init_from_model(model, contextParams) else {
+            llama_model_free(model)
+            throw Failure.load
+        }
+        self.model = model
+        self.context = context
+        vocab = llama_model_get_vocab(model)
+        sampler = llama_sampler_chain_init(llama_sampler_chain_default_params())
+        llama_sampler_chain_add(sampler, llama_sampler_init_greedy())
+        self.prefix = try Self.tokenize(prefix, vocab: vocab)
+        try decode(self.prefix)
+    }
+
+    deinit {
+        llama_sampler_free(sampler)
+        llama_free(context)
+        llama_model_free(model)
+    }
+
+    /// Loads `path` and decodes `prefix` off the caller's thread.
+    static func load(path: String, prefix: String) async throws -> LlamaModel {
+        try await withCheckedThrowingContinuation { continuation in
+            loadQueue.async {
+                continuation.resume(with: Result { try LlamaModel(path: path, prefix: prefix) })
+            }
+        }
+    }
+
+    /// Greedy continuation of the prefix with `suffix`, up to an end-of-turn
+    /// token, `maxTokens` or `deadline`, whichever comes first. The deadline
+    /// is checked between tokens, so an answer can overrun it by one token.
+    func complete(suffix: String, maxTokens: Int, deadline: ContinuousClock.Instant) async throws -> String {
+        try await withCheckedThrowingContinuation { continuation in
+            queue.async {
+                continuation.resume(with: Result {
+                    try self.completeNow(suffix: suffix, maxTokens: maxTokens, deadline: deadline)
+                })
+            }
+        }
+    }
+
+    // MARK: On the queue
+
+    private func completeNow(suffix: String, maxTokens: Int, deadline: ContinuousClock.Instant) throws -> String {
+        // Back to the prefix: the previous dictation's tokens go, the
+        // prefix's cache stays.
+        let memory = llama_get_memory(context)
+        if !llama_memory_seq_rm(memory, 0, llama_pos(prefix.count), -1) {
+            llama_memory_clear(memory, true)
+            try decode(prefix)
+        }
+        llama_sampler_reset(sampler)
+
+        let input = try Self.tokenize(suffix, vocab: vocab)
+        let room = Int(Self.contextLength) - prefix.count - input.count
+        guard room > 0 else { throw Failure.contextFull }
+        guard ContinuousClock.now < deadline else { throw Failure.timedOut }
+        try decode(input)
+
+        var bytes: [CChar] = []
+        var piece = [CChar](repeating: 0, count: 256)
+        for _ in 0..<min(maxTokens, room) {
+            guard ContinuousClock.now < deadline else { throw Failure.timedOut }
+            var token = llama_sampler_sample(sampler, context, -1)
+            if llama_vocab_is_eog(vocab, token) { break }
+            let count = llama_token_to_piece(vocab, token, &piece, Int32(piece.count), 0, false)
+            if count > 0 { bytes.append(contentsOf: piece[0..<Int(count)]) }
+            try withUnsafeMutablePointer(to: &token) { pointer in
+                let status = llama_decode(context, llama_batch_get_one(pointer, 1))
+                if status != 0 { throw Failure.decode(status) }
+            }
+        }
+        // Pieces are bytes; a multi-byte character may span two of them, so
+        // the text is only decoded once it is whole.
+        return String(decoding: bytes.map { UInt8(bitPattern: $0) }, as: UTF8.self)
+    }
+
+    private func decode(_ tokens: [llama_token]) throws {
+        guard !tokens.isEmpty else { return }
+        var tokens = tokens
+        let status = tokens.withUnsafeMutableBufferPointer { buffer in
+            llama_decode(context, llama_batch_get_one(buffer.baseAddress, Int32(buffer.count)))
+        }
+        if status != 0 { throw Failure.decode(status) }
+    }
+
+    /// Special tokens such as `<|im_start|>` are parsed, since the chat
+    /// format is written out by hand; no beginning-of-text token is added,
+    /// which the Qwen family does not use.
+    static func tokenize(_ text: String, vocab: OpaquePointer) throws -> [llama_token] {
+        let utf8 = Array(text.utf8CString.dropLast())
+        var tokens = [llama_token](repeating: 0, count: utf8.count + 8)
+        var count = llama_tokenize(vocab, utf8, Int32(utf8.count), &tokens, Int32(tokens.count), false, true)
+        if count < 0 {
+            tokens = [llama_token](repeating: 0, count: Int(-count))
+            count = llama_tokenize(vocab, utf8, Int32(utf8.count), &tokens, Int32(tokens.count), false, true)
+        }
+        guard count >= 0 else { throw Failure.tokenize }
+        return Array(tokens.prefix(Int(count)))
+    }
+
+    // MARK: Process-wide
+
+    /// Sets up the backends ahead of the first load. The first time a build
+    /// of llama.cpp runs, Metal compiles its shaders, about seven seconds on
+    /// an M1; macOS caches them after that, so only the first launch after
+    /// an install or update pays, and with this it pays in the background.
+    static func warmUp() async {
+        await withCheckedContinuation { continuation in
+            loadQueue.async {
+                _ = backend
+                continuation.resume()
+            }
+        }
+    }
+
+    /// Loads are rare and slow; they get a queue of their own so a load never
+    /// waits behind another model's generation.
+    private static let loadQueue = DispatchQueue(label: "de.dinooo13.pladder.llama.load", qos: .userInitiated)
+
+    /// Once per process, before the first model: the backends, and llama.cpp's
+    /// own logging, which would otherwise print every tensor to stderr.
+    private static let backend: Void = {
+        llama_log_set({ _, _, _ in }, nil)
+        llama_backend_init()
+    }()
+}
diff --git a/Sources/PladderRefine/ModelFiles.swift b/Sources/PladderRefine/ModelFiles.swift
new file mode 100644
index 0000000..a68c82f
--- /dev/null
+++ b/Sources/PladderRefine/ModelFiles.swift
@@ -0,0 +1,207 @@
+import CryptoKit
+import Foundation
+import PladderCore
+
+/// A model file the polish can download: where it comes from, pinned to a
+/// commit so it can never change under us, and the checksum it must match
+/// before it is used.
+public struct ModelFile: Sendable, Equatable {
+    public let fileName: String
+    public let url: URL
+    public let sha256: String
+    public let byteCount: Int64
+
+    /// S1-mini by Superwhisper at 16-bit, from Superwhisper's own repository.
+    public static let s1MiniFullPrecision = ModelFile(
+        fileName: "s1-mini-f16.gguf",
+        url: URL(string: "https://huggingface.co/superwhisper/s1-mini-GGUF/resolve/34add00a48a2e5d24e5a4ee5405a99620a3a240c/s1-mini-f16.gguf")!,
+        sha256: "0370da4f1bae19e3150bcafa33c5d396c15f97bf25519540a3e013db5cc00af4",
+        byteCount: 1_509_347_232)
+
+    /// The same weights at Q8_0. Superwhisper publishes only 16-bit and
+    /// 4-bit files, and 4-bit lost German and Spanish on the polish set, so
+    /// this is mradermacher's quantisation of the same release.
+    public static let s1Mini8Bit = ModelFile(
+        fileName: "s1-mini.Q8_0.gguf",
+        url: URL(string: "https://huggingface.co/mradermacher/s1-mini-GGUF/resolve/f46488282bc2417789271ea5dab6b85c423f9439/s1-mini.Q8_0.gguf")!,
+        sha256: "19ddecf5dd46cb37ea13ce78d013c197b39c0bc69b880ea0b3f7c16528ddb52e",
+        byteCount: 804_754_240)
+
+    /// The file a polish model needs; nil for Apple's, which ships with macOS.
+    public init?(for model: PolishModel) {
+        switch model {
+        case .appleIntelligence: return nil
+        case .s1Mini: self = .s1MiniFullPrecision
+        case .s1Mini8Bit: self = .s1Mini8Bit
+        }
+    }
+
+    /// For the tests, which download a local file, and the CLI, which runs
+    /// a model file that is not in the picker.
+    public init(fileName: String, url: URL, sha256: String, byteCount: Int64) {
+        self.fileName = fileName
+        self.url = url
+        self.sha256 = sha256
+        self.byteCount = byteCount
+    }
+}
+
+/// Where a model file stands. The app words it.
+public enum ModelFileStatus: Sendable, Equatable {
+    case missing
+    case downloading(fraction: Double)
+    /// Downloaded, the checksum is being computed.
+    case verifying
+    case ready
+    case failed(ModelFileFailure)
+}
+
+public enum ModelFileFailure: Error, Sendable, Equatable {
+    /// No connection, a server error, or the download stopped.
+    case download
+    /// The file arrived but is not the one pinned: never used, deleted.
+    case checksum
+    /// It could not be written, usually a full disk.
+    case disk
+}
+
+/// The downloaded model files, one directory, one download at a time per
+/// file. This is the polish's one network use: the one-time download from
+/// Hugging Face, started only when the user picks a model that needs it.
+public actor ModelFiles {
+    public let directory: URL
+    private let onChange: @Sendable (ModelFile, ModelFileStatus) -> Void
+    private var statuses: [String: ModelFileStatus] = [:]
+    private var downloads: [String: Task<Void, Never>] = [:]
+
+    /// `onChange` is called on every status change, off the main actor.
+    public init(directory: URL, onChange: @escaping @Sendable (ModelFile, ModelFileStatus) -> Void = { _, _ in }) {
+        self.directory = directory
+        self.onChange = onChange
+    }
+
+    /// `~/Library/Application Support/Pladder/Models`, beside the settings.
+    public static var defaultDirectory: URL {
+        FileManager.default.homeDirectoryForCurrentUser
+            .appending(path: "Library/Application Support/Pladder/Models")
+    }
+
+    public nonisolated func location(of file: ModelFile) -> URL {
+        directory.appending(path: file.fileName)
+    }
+
+    /// A file on disk is ready: it is only ever moved into place after its
+    /// checksum matched.
+    public func status(of file: ModelFile) -> ModelFileStatus {
+        if let status = statuses[file.fileName] { return status }
+        return FileManager.default.fileExists(atPath: location(of: file).path) ? .ready : .missing
+    }
+
+    /// Starts the download unless the file is there or on its way. A failed
+    /// download is tried again.
+    public func ensure(_ file: ModelFile) {
+        switch status(of: file) {
+        case .ready, .downloading, .verifying: return
+        case .missing, .failed: break
+        }
+        set(file, .downloading(fraction: 0))
+        downloads[file.fileName] = Task { await self.download(file) }
+    }
+
+    /// Waits for a download `ensure` started; returns the final status.
+    public func finished(_ file: ModelFile) async -> ModelFileStatus {
+        await downloads[file.fileName]?.value
+        return status(of: file)
+    }
+
+    private func set(_ file: ModelFile, _ status: ModelFileStatus) {
+        statuses[file.fileName] = status
+        onChange(file, status)
+    }
+
+    private func download(_ file: ModelFile) async {
+        defer { downloads[file.fileName] = nil }
+        let staging = directory.appending(path: file.fileName + ".download")
+        do {
+            try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        } catch {
+            return set(file, .failed(.disk))
+        }
+        do {
+            try await fetch(file, to: staging)
+        } catch let failure as ModelFileFailure {
+            return set(file, .failed(failure))
+        } catch {
+            return set(file, .failed(.download))
+        }
+        set(file, .verifying)
+        let digest = await Task.detached(priority: .utility) { Self.sha256(of: staging) }.value
+        guard digest == file.sha256 else {
+            try? FileManager.default.removeItem(at: staging)
+            return set(file, .failed(.checksum))
+        }
+        do {
+            try? FileManager.default.removeItem(at: location(of: file))
+            try FileManager.default.moveItem(at: staging, to: location(of: file))
+        } catch {
+            return set(file, .failed(.disk))
+        }
+        statuses[file.fileName] = nil
+        onChange(file, .ready)
+    }
+
+    /// A plain download task, polled for progress. The file lands in
+    /// `staging` before the completion handler returns, since URLSession
+    /// deletes its temporary file right after.
+    private func fetch(_ file: ModelFile, to staging: URL) async throws {
+        let session = URLSession(configuration: .ephemeral)
+        defer { session.finishTasksAndInvalidate() }
+        let task: URLSessionDownloadTask
+        let result = AsyncStream<Result<Void, ModelFileFailure>>.makeStream()
+        task = session.downloadTask(with: file.url) { temporary, response, error in
+            // A file URL (the tests) has no status code.
+            let succeeded = (response as? HTTPURLResponse).map { (200..<300).contains($0.statusCode) } ?? true
+            guard error == nil, let temporary, succeeded else {
+                result.continuation.yield(.failure(.download))
+                return
+            }
+            do {
+                try? FileManager.default.removeItem(at: staging)
+                try FileManager.default.moveItem(at: temporary, to: staging)
+                result.continuation.yield(.success(()))
+            } catch {
+                result.continuation.yield(.failure(.disk))
+            }
+        }
+        task.resume()
+        let progress = Task {
+            while !Task.isCancelled {
+                try? await Task.sleep(for: .milliseconds(250))
+                // Woken by the cancel: the download is over, and a late
+                // report would overwrite what came after it.
+                guard !Task.isCancelled else { return }
+                let received = task.countOfBytesReceived
+                if received > 0 {
+                    set(file, .downloading(fraction: min(1, Double(received) / Double(file.byteCount))))
+                }
+            }
+        }
+        defer { progress.cancel() }
+        for await outcome in result.stream {
+            try outcome.get()
+            return
+        }
+        throw ModelFileFailure.download
+    }
+
+    /// Streamed, so a 1.5 GB file never sits in memory.
+    private static func sha256(of url: URL) -> String? {
+        guard let handle = try? FileHandle(forReadingFrom: url) else { return nil }
+        defer { try? handle.close() }
+        var hasher = SHA256()
+        while let chunk = try? handle.read(upToCount: 16 << 20), !chunk.isEmpty {
+            hasher.update(data: chunk)
+        }
+        return hasher.finalize().map { String(format: "%02x", $0) }.joined()
+    }
+}
diff --git a/Sources/PladderRefine/S1MiniPolisher.swift b/Sources/PladderRefine/S1MiniPolisher.swift
new file mode 100644
index 0000000..6c0f521
--- /dev/null
+++ b/Sources/PladderRefine/S1MiniPolisher.swift
@@ -0,0 +1,170 @@
+import Foundation
+import PladderCore
+import os
+
+/// The polish on S1-mini by Superwhisper: Qwen3-0.6B fine-tuned to clean
+/// dictation (fillers, self-corrections, spoken punctuation, numbers, lists),
+/// run by llama.cpp on the GPU.
+///
+/// Trained on English only, it still resolved German and Spanish
+/// self-corrections and lists on the polish set, and translated nothing,
+/// where Apple's model turned two of them into English (docs/BENCHMARKS.md).
+/// Its prompt is the one it was trained on, not `TranscriptPolisher`'s: a
+/// fixed system line and a control line, then the transcript.
+///
+/// Best effort like the Apple polisher: no file yet, a load that fails, the
+/// time budget, an empty answer all return nil and the coordinator pastes
+/// the text as dictated. The model stays loaded from the first `prepare()`
+/// until `unload()`, as the speech engine does.
+public actor S1MiniPolisher: TranscriptRefiner {
+    /// S1-mini's system prompt, word for word from its model card; it is
+    /// part of the input format the model was trained on.
+    static let systemPrompt = "You are a text normalizer for speech-to-text transcripts. The input begins with a control line specifying the styling, structure, and context settings; clean the transcript to match those settings and output only the cleaned text."
+
+    /// Semi-formal keeps the capitals a dictation into any app wants
+    /// (semi-casual lower-cases sentence starts, formal rewrites "let's" as
+    /// "let us"), and lists lets spoken enumerations become lines without
+    /// forcing a list where there is none. Chosen on the polish set.
+    public static let controlLine = "[Styling: semi-formal] [Structure: lists] [Context: general]"
+
+    /// The part of the prompt that never changes, decoded once at load.
+    /// Qwen's chat format, written out: the model's template would add the
+    /// same, and a thinking block must stay empty (`enable_thinking=False`).
+    static let promptPrefix = promptPrefix(control: controlLine)
+
+    static func promptPrefix(control: String) -> String {
+        "<|im_start|>system\n\(systemPrompt)<|im_end|>\n<|im_start|>user\n\(control)\n"
+    }
+
+    static func promptSuffix(for transcript: String) -> String {
+        "\(transcript)<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n"
+    }
+
+    /// The context holds 2,048 tokens for the prompt, the chunk and its
+    /// answer, so chunks are smaller than the Apple polisher's.
+    static let chunkThreshold = 400
+    static let chunkSize = 250
+
+    public nonisolated let file: ModelFile
+    private let location: URL
+    private let timeout: Duration
+    private var model: LlamaModel?
+    private var loading: Task<LlamaModel?, Never>?
+    private static let log = Logger(subsystem: "de.dinooo13.pladder", category: "polish")
+
+    /// `location` is where `ModelFiles` keeps `file`.
+    /// The control line this polisher sends; the CLI can try another.
+    private let control: String
+
+    /// `location` is where `ModelFiles` keeps `file`. `control` is for the
+    /// CLI, which judges a style or a fine-tune of S1-mini before it goes in;
+    /// the app always uses the default.
+    public init(
+        file: ModelFile, location: URL, timeout: Duration = .seconds(8),
+        control: String = S1MiniPolisher.controlLine
+    ) {
+        self.file = file
+        self.location = location
+        self.timeout = timeout
+        self.control = control
+    }
+
+    /// Loads the model if its file is there. Called at key-down, so a first
+    /// dictation's load happens while the user is still speaking.
+    public func prepare() async {
+        _ = await loaded()
+    }
+
+    public func refine(_ text: String) async -> String? {
+        await polish(text).text
+    }
+
+    /// Sets up llama.cpp without loading a model: cheap except on the first
+    /// launch after an install, when Metal compiles its shaders for seconds.
+    /// The app calls it as soon as S1-mini is chosen, so no dictation waits.
+    public static func warmUpRuntime() async {
+        await LlamaModel.warmUp()
+    }
+
+    /// Frees the model's memory; the next `prepare()` loads it again.
+    public func unload() {
+        loading?.cancel()
+        loading = nil
+        model = nil
+    }
+
+    /// `refine` with the numbers kept, for the log and the CLI. One log line
+    /// per call, numbers only: the transcript never goes in the log.
+    public func polish(_ text: String) async -> TranscriptPolisher.Report {
+        let started = ContinuousClock.now
+        let deadline = started + timeout
+        let pieces = TranscriptPolisher.chunks(of: text, threshold: Self.chunkThreshold, size: Self.chunkSize)
+        var report = TranscriptPolisher.Report(
+            text: nil, elapsed: .zero, wordsIn: TranscriptPolisher.wordCount(text), wordsOut: 0,
+            chunks: pieces.count, mode: .completion, failure: nil)
+        if let model = await loaded() {
+            do {
+                var cleaned: [String] = []
+                for piece in pieces {
+                    // Room for an answer somewhat longer than the input: a
+                    // list adds line breaks and dashes.
+                    let maxTokens = TranscriptPolisher.wordCount(piece) * 3 + 64
+                    let answer = try await model.complete(
+                        suffix: Self.promptSuffix(for: piece), maxTokens: maxTokens, deadline: deadline)
+                    let filtered = PolishPostFilter.clean(answer)
+                    guard !filtered.isEmpty else { throw EmptyAnswer() }
+                    cleaned.append(filtered)
+                }
+                let joined = cleaned.joined(separator: " ")
+                report.text = joined
+                report.wordsOut = TranscriptPolisher.wordCount(joined)
+            } catch LlamaModel.Failure.timedOut {
+                report.failure = "timed out"
+            } catch is EmptyAnswer {
+                report.failure = "empty answer"
+            } catch {
+                report.failure = "model error \(error)"
+            }
+        } else {
+            report.failure = FileManager.default.fileExists(atPath: location.path) ? "model did not load" : "not downloaded"
+        }
+        report.elapsed = ContinuousClock.now - started
+        Self.log(report, file: file)
+        return report
+    }
+
+    private struct EmptyAnswer: Error {}
+
+    /// The loaded model, loading it first if its file is there; nil
+    /// otherwise. Concurrent callers share one load.
+    private func loaded() async -> LlamaModel? {
+        if let model { return model }
+        if let loading { return await loading.value }
+        guard FileManager.default.fileExists(atPath: location.path) else { return nil }
+        let path = location.path
+        let prefix = Self.promptPrefix(control: control)
+        let task = Task { try? await LlamaModel.load(path: path, prefix: prefix) }
+        loading = task
+        let model = await task.value
+        // `unload()` during the load cancelled this task: drop the result.
+        if loading == task, !task.isCancelled { self.model = model }
+        if loading == task { loading = nil }
+        return self.model
+    }
+
+    private static func log(_ report: TranscriptPolisher.Report, file: ModelFile) {
+        let secs = String(format: "%.3f", Double(report.elapsed.components.seconds)
+            + Double(report.elapsed.components.attoseconds) / 1e18)
+        if let failure = report.failure {
+            log.notice(
+                "polish (\(file.fileName, privacy: .public)) failed after \(secs, privacy: .public) s, \(report.wordsIn, privacy: .public) words in: \(failure, privacy: .public)")
+        } else {
+            log.notice(
+                """
+                polish (\(file.fileName, privacy: .public)) \(secs, privacy: .public) s, \
+                \(report.wordsIn, privacy: .public) words in, \(report.wordsOut, privacy: .public) out\
+                \(report.chunks > 1 ? ", \(report.chunks) chunks" : "", privacy: .public)
+                """)
+        }
+    }
+}
diff --git a/Sources/PladderRefine/TranscriptPolisher.swift b/Sources/PladderRefine/TranscriptPolisher.swift
index 8cfdfd1..092ec30 100644
--- a/Sources/PladderRefine/TranscriptPolisher.swift
+++ b/Sources/PladderRefine/TranscriptPolisher.swift
@@ -61,6 +61,9 @@ public actor TranscriptPolisher: TranscriptRefiner {
             case guided
             /// Plain `respond(to:)`, after guided generation could not decode.
             case plain
+            /// A local model completing the prompt format it was trained on
+            /// (`S1MiniPolisher`).
+            case completion
         }
 
         /// Nil when the model could not help; paste the input as it is.
@@ -175,17 +178,18 @@ public actor TranscriptPolisher: TranscriptRefiner {
     // MARK: Chunking
 
     /// The transcript as it is when it is short, which is most dictations;
-    /// otherwise windows of about `chunkSize` words,
-    /// cut after a sentence end so no window starts mid-sentence.
-    static func chunks(of text: String) -> [String] {
+    /// otherwise windows of about `size` words (`chunkSize` by default),
+    /// cut after a sentence end so no window starts mid-sentence. The
+    /// S1-mini polisher passes its own, smaller numbers.
+    static func chunks(of text: String, threshold: Int = chunkThreshold, size: Int = chunkSize) -> [String] {
         let words = text.split(whereSeparator: \.isWhitespace)
-        guard words.count > chunkThreshold else { return [text] }
+        guard words.count > threshold else { return [text] }
         var windows: [String] = []
         var current: [Substring] = []
         for word in words {
             current.append(word)
             let endsSentence = word.last.map { ".?!".contains($0) } ?? false
-            if current.count >= chunkSize, endsSentence {
+            if current.count >= size, endsSentence {
                 windows.append(current.joined(separator: " "))
                 current = []
             }
diff --git a/Tests/PladderCoreTests/DictationCoordinatorTests.swift b/Tests/PladderCoreTests/DictationCoordinatorTests.swift
index 5f23c7f..5c74ca2 100644
--- a/Tests/PladderCoreTests/DictationCoordinatorTests.swift
+++ b/Tests/PladderCoreTests/DictationCoordinatorTests.swift
@@ -1840,6 +1840,7 @@ final class EventLog: @unchecked Sendable {
         #expect(decoded.hotkey == .optionSpace)
         #expect(decoded.submitKey == .rightOption)
         #expect(!decoded.polishDictations)
+        #expect(decoded.polishModel == .appleIntelligence)
         #expect(decoded.appendTrailingSpace == true)
         #expect(decoded.appearance == .system)
         #expect(decoded.overlayStyle == .compact)
@@ -1856,6 +1857,21 @@ final class EventLog: @unchecked Sendable {
         #expect(!off.polishDictations)
     }
 
+    @Test func polishModelPersists() throws {
+        var settings = Settings(engineID: EchoEngine.engineID)
+        settings.polishModel = .s1Mini8Bit
+        let decoded = try JSONDecoder().decode(Settings.self, from: JSONEncoder().encode(settings))
+        #expect(decoded.polishModel == .s1Mini8Bit)
+    }
+
+    @Test func anUnknownPolishModelFallsBackToApples() throws {
+        // Written by a newer build that knows a model this one does not.
+        let json = #"{"engineID":"echo","polishDictations":true,"polishModel":"someFutureModel"}"#
+        let decoded = try JSONDecoder().decode(Settings.self, from: Data(json.utf8))
+        #expect(decoded.polishModel == .appleIntelligence)
+        #expect(decoded.polishDictations)
+    }
+
     @Test func appearancePersists() throws {
         let dir = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
         let url = dir.appendingPathComponent("settings.json")
diff --git a/Tests/PladderCoreTests/FillerRemoverTests.swift b/Tests/PladderCoreTests/FillerRemoverTests.swift
index 6c5bc0d..4fdd3b8 100644
--- a/Tests/PladderCoreTests/FillerRemoverTests.swift
+++ b/Tests/PladderCoreTests/FillerRemoverTests.swift
@@ -43,6 +43,20 @@ import Testing
         #expect(try await run("Umm, i'll be there soon") == "I'll be there soon")
     }
 
+    @Test func capitalisesAfterAFillerThatOpensALaterSentence() async throws {
+        #expect(try await run("Ich habe einen Test geschrieben. Ähm, beim Timeout bin ich unsicher.")
+            == "Ich habe einen Test geschrieben. Beim Timeout bin ich unsicher.")
+        #expect(try await run("Done? uh, what next") == "Done? What next")
+        #expect(try await run("Stop! Äh äh, weiter") == "Stop! Weiter")
+        #expect(try await run("Añadí una prueba. Eh, no estoy seguro.", hint: { _ in "es" })
+            == "Añadí una prueba. No estoy seguro.")
+    }
+
+    @Test func leavesCaseAloneAfterAFillerMidSentence() async throws {
+        #expect(try await run("Ich weiß, äh, nicht") == "Ich weiß nicht")
+        #expect(try await run("the build, uh, passed") == "the build passed")
+    }
+
     @Test func consumesNeighbouringCommasForUniversalFillers() async throws {
         #expect(try await run("we could, uh, ship it") == "we could ship it")
     }
diff --git a/Tests/PladderCoreTests/SpokenPunctuationTests.swift b/Tests/PladderCoreTests/SpokenPunctuationTests.swift
new file mode 100644
index 0000000..8f3e33d
--- /dev/null
+++ b/Tests/PladderCoreTests/SpokenPunctuationTests.swift
@@ -0,0 +1,80 @@
+import Testing
+@testable import PladderCore
+
+@Suite struct SpokenPunctuationTests {
+    private func run(_ text: String, hint: (@Sendable (String) -> String?)? = nil) async throws -> String {
+        try await SpokenPunctuation(languageHint: hint).process(text)
+    }
+
+    // MARK: What the speech model leaves behind
+
+    @Test func absorbsTheSpeechModelsOwnPunctuation() async throws {
+        // Parakeet's output for "…verschieben Fragezeichen" and "…to three
+        // question mark": its mark and the spoken one become one.
+        #expect(try await run("Können wir den Termin auf drei verschieben? Fragezeichen.")
+            == "Können wir den Termin auf drei verschieben?")
+        #expect(try await run("Can we push the call to three question mark?") == "Can we push the call to three?")
+    }
+
+    @Test func turnsEachLanguagesMarksIntoPunctuation() async throws {
+        #expect(try await run("Hi Sarah comma thanks") == "Hi Sarah, thanks")
+        #expect(try await run("Hallo Sarah Komma danke") == "Hallo Sarah, danke")
+        #expect(try await run("Wow exclamation mark that worked") == "Wow! That worked")
+        #expect(try await run("Das klappt Ausrufezeichen") == "Das klappt!")
+        #expect(try await run("Es gibt drei Dinge Doppelpunkt Milch, Eier, Brot") == "Es gibt drei Dinge: Milch, Eier, Brot")
+        #expect(try await run("first part semicolon second part") == "first part; second part")
+        #expect(try await run("That is all full stop") == "That is all.")
+        #expect(try await run("Podemos mover la llamada signo de interrogación") == "Podemos mover la llamada?")
+        #expect(try await run("primero punto y coma segundo") == "primero; segundo")
+    }
+
+    @Test func capitalisesTheWordAfterASentenceMark() async throws {
+        #expect(try await run("done question mark what next") == "done? What next")
+        #expect(try await run("fertig Fragezeichen dann los") == "fertig? Dann los")
+        #expect(try await run("send it question mark iPhone users too") == "send it? iPhone users too")
+    }
+
+    @Test func startsAParagraphAndKeepsTheSentenceMarkBeforeIt() async throws {
+        #expect(try await run("That is the summary. New paragraph. next we ship.")
+            == "That is the summary.\n\nNext we ship.")
+        #expect(try await run("Das war es. Neuer Absatz jetzt weiter") == "Das war es.\n\nJetzt weiter")
+    }
+
+    @Test func aCommaBetweenDigitsIsTheDecimalComma() async throws {
+        #expect(try await run("Es waren 3 Komma 5 Prozent") == "Es waren 3,5 Prozent")
+        #expect(try await run("fueron 3 coma 5 grados", hint: { _ in "es" }) == "fueron 3,5 grados")
+    }
+
+    // MARK: What stays a word
+
+    @Test func leavesAmbiguousWordsAlone() async throws {
+        let texts = [
+            "The trial period ends on Friday.",
+            "Das ist ein wichtiger Punkt. Punkt acht Uhr geht es los.",
+            "Ese es el punto clave.",
+            "The colon is part of the large intestine.",
+            "Tenemos dos puntos de vista.",
+        ]
+        for text in texts {
+            #expect(try await run(text, hint: { _ in nil }) == text)
+        }
+    }
+
+    @Test func spanishComaNeedsSpanishEvidence() async throws {
+        #expect(try await run("The patient was in a coma for a week.", hint: { _ in "en" })
+            == "The patient was in a coma for a week.")
+        #expect(try await run("The patient was in a coma for a week.") == "The patient was in a coma for a week.")
+        #expect(try await run("Hola Sara coma gracias", hint: { _ in "es" }) == "Hola Sara, gracias")
+    }
+
+    @Test func leavesTextWithoutSpokenMarksUnchanged() async throws {
+        let text = "Der Build läuft auf der CI durch, und die Tests brauchen weniger als eine Sekunde."
+        #expect(try await run(text) == text)
+        #expect(try await run("") == "")
+    }
+
+    @Test func partsOfLongerWordsAreNotMarks() async throws {
+        #expect(try await run("Kommandozeile und Kommata") == "Kommandozeile und Kommata")
+        #expect(try await run("commas and commander") == "commas and commander")
+    }
+}
diff --git a/Tests/PladderRefineTests/S1MiniTests.swift b/Tests/PladderRefineTests/S1MiniTests.swift
new file mode 100644
index 0000000..ce1fe6a
--- /dev/null
+++ b/Tests/PladderRefineTests/S1MiniTests.swift
@@ -0,0 +1,120 @@
+import Foundation
+import PladderCore
+import Testing
+@testable import PladderRefine
+
+// Nothing here loads a model or touches the network: the downloads come from
+// a file URL, and the polisher is asked about a file that is not there.
+
+@Suite struct S1MiniPromptTests {
+    @Test func thePromptIsQwensChatFormatWithAnEmptyThinkBlock() {
+        // What S1-mini's own chat template renders with enable_thinking=False,
+        // taken from its tokenizer: the model was trained on exactly this.
+        let prompt = S1MiniPolisher.promptPrefix + S1MiniPolisher.promptSuffix(for: "hello there")
+        #expect(prompt == """
+            <|im_start|>system
+            \(S1MiniPolisher.systemPrompt)<|im_end|>
+            <|im_start|>user
+            [Styling: semi-formal] [Structure: lists] [Context: general]
+            hello there<|im_end|>
+            <|im_start|>assistant
+            <think>
+
+            </think>
+
+
+            """)
+    }
+
+    @Test func theSystemPromptIsTheModelCardsWordForWord() {
+        #expect(S1MiniPolisher.systemPrompt.hasPrefix("You are a text normalizer for speech-to-text transcripts."))
+        #expect(S1MiniPolisher.systemPrompt.hasSuffix("output only the cleaned text."))
+    }
+
+    @Test func longDictationsAreChunkedSmallerThanForApple() {
+        let sentence = "One two three four five six seven eight nine ten."
+        let text = Array(repeating: sentence, count: 50).joined(separator: " ")  // 500 words
+        #expect(TranscriptPolisher.chunks(of: text).count == 1)
+        let chunks = TranscriptPolisher.chunks(
+            of: text, threshold: S1MiniPolisher.chunkThreshold, size: S1MiniPolisher.chunkSize)
+        #expect(chunks.count == 2)
+        #expect(chunks.joined(separator: " ") == text)
+    }
+
+    @Test func eachModelNamesItsFile() {
+        #expect(ModelFile(for: .appleIntelligence) == nil)
+        #expect(ModelFile(for: .s1Mini) == .s1MiniFullPrecision)
+        #expect(ModelFile(for: .s1Mini8Bit) == .s1Mini8Bit)
+        // Pinned to a commit, never a branch.
+        for file in [ModelFile.s1MiniFullPrecision, .s1Mini8Bit] {
+            #expect(file.url.host() == "huggingface.co")
+            #expect(!file.url.path().contains("/resolve/main/"))
+            #expect(file.sha256.count == 64)
+        }
+    }
+
+    @Test func withoutItsFileThePolisherPastesAsDictated() async {
+        let missing = FileManager.default.temporaryDirectory.appending(path: UUID().uuidString + ".gguf")
+        let polisher = S1MiniPolisher(file: .s1Mini8Bit, location: missing)
+        await polisher.prepare()
+        let report = await polisher.polish("hello there")
+        #expect(report.text == nil)
+        #expect(report.failure == "not downloaded")
+        #expect(await polisher.refine("hello there") == nil)
+    }
+}
+
+@Suite struct ModelFilesTests {
+    private func scratch() throws -> URL {
+        let dir = FileManager.default.temporaryDirectory.appending(path: "ModelFilesTests-" + UUID().uuidString)
+        try FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        return dir
+    }
+
+    private func source(in dir: URL, contents: String) throws -> URL {
+        let url = dir.appending(path: "source.bin")
+        try Data(contents.utf8).write(to: url)
+        return url
+    }
+
+    @Test func aDownloadThatMatchesItsChecksumBecomesReady() async throws {
+        let dir = try scratch()
+        defer { try? FileManager.default.removeItem(at: dir) }
+        let file = ModelFile(
+            fileName: "model.gguf", url: try source(in: dir, contents: "weights"),
+            // SHA-256 of "weights".
+            sha256: "9a129038d9a00aed0cf6a7ea059ca50a813449061ab87848cf1a13eafdf33b2c",
+            byteCount: 7)
+        let files = ModelFiles(directory: dir.appending(path: "models"))
+        #expect(await files.status(of: file) == .missing)
+        await files.ensure(file)
+        #expect(await files.finished(file) == .ready)
+        #expect(try String(contentsOf: files.location(of: file), encoding: .utf8) == "weights")
+    }
+
+    @Test func aDownloadThatDoesNotMatchIsDeletedAndNeverUsed() async throws {
+        let dir = try scratch()
+        defer { try? FileManager.default.removeItem(at: dir) }
+        let file = ModelFile(
+            fileName: "model.gguf", url: try source(in: dir, contents: "tampered"),
+            sha256: "9a129038d9a00aed0cf6a7ea059ca50a813449061ab87848cf1a13eafdf33b2c",
+            byteCount: 8)
+        let models = dir.appending(path: "models")
+        let files = ModelFiles(directory: models)
+        await files.ensure(file)
+        #expect(await files.finished(file) == .failed(.checksum))
+        #expect(!FileManager.default.fileExists(atPath: files.location(of: file).path))
+        #expect(try FileManager.default.contentsOfDirectory(atPath: models.path).isEmpty)
+    }
+
+    @Test func aMissingSourceFailsAsADownload() async throws {
+        let dir = try scratch()
+        defer { try? FileManager.default.removeItem(at: dir) }
+        let file = ModelFile(
+            fileName: "model.gguf", url: dir.appending(path: "nowhere.bin"),
+            sha256: String(repeating: "0", count: 64), byteCount: 1)
+        let files = ModelFiles(directory: dir.appending(path: "models"))
+        await files.ensure(file)
+        #expect(await files.finished(file) == .failed(.download))
+    }
+}
diff --git a/docs/BENCHMARKS.md b/docs/BENCHMARKS.md
index 8553251..960c1ec 100644
--- a/docs/BENCHMARKS.md
+++ b/docs/BENCHMARKS.md
@@ -194,18 +194,98 @@ release-to-paste 0.312 s: stop 0.012, engine 0.250, process 0.003, paste 0.014;
 ```
 
 A polished dictation logs its own line, with the model
-call as a fifth stage:
+call as a fifth stage and the model it ran on:
 
 ```
-polished release-to-paste 1.912 s: stop 0.012, engine 0.250, process 0.003, polish 1.620, paste 0.014; audio 6.1 s
+polished release-to-paste 1.912 s: stop 0.012, engine 0.250, process 0.003, polish 1.620 (appleIntelligence), paste 0.014; audio 6.1 s
 ```
 
 `polish` is the model call; it exists only for dictations run with the
 experimental polish toggle on, and the plain line is unchanged for everything else. It is
 `0.000` when the transcript was under four words and the model was skipped.
 The prompt's own cost and output are measured with
-`swift run -c release pladder-cli polish <text file>`, which runs it cold and
-warm.
+`swift run -c release pladder-cli polish <text file> [--model …]`, which runs
+it cold and warm, and a model as a whole with the polish set below.
+
+## Polish models
+
+`docs/polish-set.json` holds 42 dictations, 14 each in English, German and
+Spanish, with the text that should be pasted: self-corrections, spoken
+punctuation, number words, both kinds of spoken list, a question and a
+request that must not be answered, clean text that must come back
+unchanged, code identifiers, repeats, an email and a longer passage. The
+inputs are hand-written in the shape Parakeet produces, with fillers left
+in; real dictation mostly arrives with numbers already as digits.
+
+```sh
+swift run -c release pladder-cli polish-set docs/polish-set.json --model apple|s1-mini|s1-mini-8bit
+```
+
+runs the app's processors over each input, then the model, warm, and prints
+every answer, the word error rate against the expected text (case and
+punctuation ignored), how many answers match exactly (everything counts) and
+the polish time. Greedy decoding throughout, so a rerun gives the same
+answers.
+
+M1 MacBook Air, 16 GB, macOS 27.0, September 2026:
+
+| Model | Word error (en / de / es) | Exact of 42 | Polish median | p90 |
+|---|---|---|---|---|
+| Apple Intelligence (macOS 27) | 0.108 (0.037 / 0.152 / 0.135) | 18 | 1.66 s | 2.07 s |
+| S1-mini, full precision (f16, 1.5 GB) | 0.071 (0.021 / 0.115 / 0.078) | 22 | 0.49 s | 0.86 s |
+| S1-mini, 8-bit (Q8_0, 805 MB) | 0.091 (0.008 / 0.115 / 0.149) | 21 | 0.34 s | 0.61 s |
+
+What the numbers do not show: Apple's model translated two dictations into
+English (a German question, a Spanish self-correction), changed "halb acht"
+to "8:00", and wrote no list as separate lines. S1-mini, trained on English
+only, translated nothing and resolved the German and Spanish
+self-corrections, but ignores "Nächster Punkt" and "Siguiente punto" as list
+cues and mangled one German sentence around a code identifier. Its load, at
+the first key-down after launch or a model switch, is well under a second
+from a warm disk and happens while the user speaks.
+
+A German fine-tune of S1-mini, `Joni000000000/s1-mini-de-v3` (Q4_K_M, 397 MB,
+trained on real Parakeet German output), was judged with
+`polish-set --gguf <file> --control <line>` and not added:
+
+| Control line styling | Word error (en / de / es) | Exact of 42 | Polish median |
+|---|---|---|---|
+| semi-formal (the app's) | 0.106 (0.033 / 0.132 / 0.153) | 19 | 0.25 s |
+| semi-casual | 0.108 (0.033 / 0.139 / 0.153) | 19 | 0.25 s |
+| casual | 0.096 (0.009 / 0.130 / 0.149) | 21 | 0.25 s |
+
+In German it turned "Nächster Punkt" enumerations into lines (keeping the cue
+words), wrote "3. März" and placed the comma after "Ich glaube", where
+S1-mini did not; but it left "für vier, Entschuldigung, fünf Personen"
+unresolved, dropped a code identifier, and fused "Build taggen". Part of its
+higher error is its own convention of keeping small counts as words. Its
+English and Spanish answers were the same as S1-mini 8-bit's in 23 of 28
+cases despite its card calling it German only. It is 4-bit only; a 14-case
+German slice is too small to overrule its author's 69 probes either way.
+
+LFM2.5-1.2B-Instruct and Gemma 3 1B, run with Pladder's own prompt, were
+tried and dropped: the first described or answered the transcript instead
+of cleaning it, the second mostly returned it untouched. MLX 4-bit S1-mini
+was faster still but lost German and Spanish.
+
+## Processors
+
+The processors run on every dictation, so their cost is measured on the
+fixtures' text through the whole pipeline (filler remover with the app's
+language hint, dictionary, custom words, whitespace, spoken punctuation),
+median of 31 runs, M1. "Typical" has a filler in every sentence; "worst" adds
+a spoken question mark to every sentence.
+
+| Fixture | main, typical | spoken punctuation, typical | main, worst | spoken punctuation, worst |
+|---|---|---|---|---|
+| 10s | 1.53 ms | 1.97 ms | 1.51 ms | 1.62 ms |
+| 60s | 1.71 ms | 1.81 ms | 1.73 ms | 2.04 ms |
+| 2m | 1.96 ms | 2.14 ms | 2.00 ms | 2.61 ms |
+| 10m | 3.77 ms | 4.83 ms | 4.13 ms | 6.85 ms |
+
+The floor of about 1.5 ms is the language recogniser the filler remover asks
+whenever an ambiguous filler is present. Differences under a millisecond at
+10 s are noise.
 
 What each stage contains:
 
diff --git a/docs/polish-set.json b/docs/polish-set.json
new file mode 100644
index 0000000..005fce5
--- /dev/null
+++ b/docs/polish-set.json
@@ -0,0 +1,44 @@
+[
+{"id":"en-01-selfcorr-time","lang":"en","input":"Um, let's meet on Monday, wait, no, Tuesday at ten.","expected":"Let's meet on Tuesday at 10."},
+{"id":"en-02-selfcorr-name","lang":"en","input":"Send the report to Mark, I mean Martin, by Friday.","expected":"Send the report to Martin by Friday."},
+{"id":"en-03-spoken-punct","lang":"en","input":"Hi Sarah comma thanks for the quick reply period Can we push the call to three question mark","expected":"Hi Sarah, thanks for the quick reply. Can we push the call to 3?"},
+{"id":"en-04-numbers","lang":"en","input":"The invoice was two hundred and fifty dollars, and we paid it on the third of March.","expected":"The invoice was $250, and we paid it on the 3rd of March."},
+{"id":"en-05-list-ordinal","lang":"en","input":"For the release we need three things. First, update the changelog. Second, tag the build. And third, uh, post the notes.","expected":"For the release we need three things:\n- Update the changelog\n- Tag the build\n- Post the notes"},
+{"id":"en-06-list-bullet","lang":"en","input":"Agenda for tomorrow. Bullet budget review. Bullet hiring plan. Bullet office move.","expected":"Agenda for tomorrow:\n- Budget review\n- Hiring plan\n- Office move"},
+{"id":"en-07-question","lang":"en","input":"What's the difference between a process and a thread? I always, uh, mix them up.","expected":"What's the difference between a process and a thread? I always mix them up."},
+{"id":"en-08-request","lang":"en","input":"Write me a short poem about the sea and, um, make it rhyme.","expected":"Write me a short poem about the sea and make it rhyme."},
+{"id":"en-09-clean","lang":"en","input":"The build passes on CI and the tests take under a second.","expected":"The build passes on CI and the tests take under a second."},
+{"id":"en-10-technical","lang":"en","input":"Can you refactor the DictationCoordinator so that the overlay reads willPolish at key down instead of at release?","expected":"Can you refactor the DictationCoordinator so that the overlay reads willPolish at key down instead of at release?"},
+{"id":"en-11-repeat-falsestart","lang":"en","input":"I think we we should, we should probably ship it on Thursday.","expected":"I think we should probably ship it on Thursday."},
+{"id":"en-12-email","lang":"en","input":"Hi Anna, just a quick note. The meeting moved to four thirty. Let me know if that, uh, works for you. Best, Tom.","expected":"Hi Anna,\n\nJust a quick note. The meeting moved to 4:30. Let me know if that works for you.\n\nBest,\nTom"},
+{"id":"en-13-long","lang":"en","input":"So I looked into the crash from yesterday and it turns out the engine was unloaded while a transcription was still running. The fix is to wait for the in-flight task before unloading. I also added a test for it. Um, I'm not sure about the timeout though, maybe two seconds is too short.","expected":"So I looked into the crash from yesterday and it turns out the engine was unloaded while a transcription was still running. The fix is to wait for the in-flight task before unloading. I also added a test for it. I'm not sure about the timeout though, maybe 2 seconds is too short."},
+{"id":"en-14-selfcorr-sorry","lang":"en","input":"Book a table for four, sorry, five people at seven thirty.","expected":"Book a table for 5 people at 7:30."},
+{"id":"de-01-selfcorr-time","lang":"de","input":"Ähm, wir treffen uns am Montag, nein, am Dienstag um zehn.","expected":"Wir treffen uns am Dienstag um 10."},
+{"id":"de-02-selfcorr-name","lang":"de","input":"Schick den Bericht an Markus, ich meine Martin, bis Freitag.","expected":"Schick den Bericht an Martin bis Freitag."},
+{"id":"de-03-spoken-punct","lang":"de","input":"Hallo Sarah Komma danke für die schnelle Antwort Punkt Können wir den Termin auf drei verschieben Fragezeichen","expected":"Hallo Sarah, danke für die schnelle Antwort. Können wir den Termin auf 3 verschieben?"},
+{"id":"de-04-numbers","lang":"de","input":"Die Rechnung war zweihundertfünfzig Euro und wir haben sie am dritten März bezahlt.","expected":"Die Rechnung war 250 Euro und wir haben sie am 3. März bezahlt."},
+{"id":"de-05-list-ordinal","lang":"de","input":"Für das Release brauchen wir drei Dinge. Erstens das Changelog aktualisieren. Zweitens den Build taggen. Und drittens, äh, die Notizen posten.","expected":"Für das Release brauchen wir drei Dinge:\n- Das Changelog aktualisieren\n- Den Build taggen\n- Die Notizen posten"},
+{"id":"de-06-list-bullet","lang":"de","input":"Agenda für morgen. Nächster Punkt Budget. Nächster Punkt Einstellungen. Nächster Punkt Umzug.","expected":"Agenda für morgen:\n- Budget\n- Einstellungen\n- Umzug"},
+{"id":"de-07-question","lang":"de","input":"Was ist der Unterschied zwischen einem Prozess und einem Thread? Ich verwechsle die, ähm, immer.","expected":"Was ist der Unterschied zwischen einem Prozess und einem Thread? Ich verwechsle die immer."},
+{"id":"de-08-request","lang":"de","input":"Schreib mir ein kurzes Gedicht über das Meer und, äh, lass es sich reimen.","expected":"Schreib mir ein kurzes Gedicht über das Meer und lass es sich reimen."},
+{"id":"de-09-clean","lang":"de","input":"Der Build läuft auf der CI durch und die Tests brauchen weniger als eine Sekunde.","expected":"Der Build läuft auf der CI durch und die Tests brauchen weniger als eine Sekunde."},
+{"id":"de-10-technical","lang":"de","input":"Kannst du den DictationCoordinator so umbauen, dass das Overlay willPolish beim Drücken liest und nicht beim Loslassen?","expected":"Kannst du den DictationCoordinator so umbauen, dass das Overlay willPolish beim Drücken liest und nicht beim Loslassen?"},
+{"id":"de-11-repeat-falsestart","lang":"de","input":"Ich glaube wir wir sollten, wir sollten es wohl am Donnerstag ausliefern.","expected":"Ich glaube, wir sollten es wohl am Donnerstag ausliefern."},
+{"id":"de-12-email","lang":"de","input":"Hallo Anna, nur kurz zur Info. Das Meeting ist auf halb fünf verschoben. Sag Bescheid, ob dir das, äh, passt. Viele Grüße, Tom.","expected":"Hallo Anna,\n\nnur kurz zur Info. Das Meeting ist auf halb fünf verschoben. Sag Bescheid, ob dir das passt.\n\nViele Grüße\nTom"},
+{"id":"de-13-long","lang":"de","input":"Also ich habe mir den Absturz von gestern angeschaut und es stellt sich heraus, dass die Engine entladen wurde, während noch eine Transkription lief. Der Fix ist, auf die laufende Aufgabe zu warten, bevor entladen wird. Ich habe auch einen Test dafür geschrieben. Ähm, beim Timeout bin ich mir aber nicht sicher, vielleicht sind zwei Sekunden zu kurz.","expected":"Also ich habe mir den Absturz von gestern angeschaut und es stellt sich heraus, dass die Engine entladen wurde, während noch eine Transkription lief. Der Fix ist, auf die laufende Aufgabe zu warten, bevor entladen wird. Ich habe auch einen Test dafür geschrieben. Beim Timeout bin ich mir aber nicht sicher, vielleicht sind 2 Sekunden zu kurz."},
+{"id":"de-14-selfcorr-sorry","lang":"de","input":"Reservier einen Tisch für vier, Entschuldigung, fünf Personen um halb acht.","expected":"Reservier einen Tisch für 5 Personen um halb acht."},
+{"id":"es-01-selfcorr-time","lang":"es","input":"Eh, nos vemos el lunes, no, el martes a las diez.","expected":"Nos vemos el martes a las 10."},
+{"id":"es-02-selfcorr-name","lang":"es","input":"Envía el informe a Marcos, quiero decir Martín, antes del viernes.","expected":"Envía el informe a Martín antes del viernes."},
+{"id":"es-03-spoken-punct","lang":"es","input":"Hola Sara coma gracias por la respuesta rápida punto Podemos mover la llamada a las tres signo de interrogación","expected":"Hola Sara, gracias por la respuesta rápida. ¿Podemos mover la llamada a las 3?"},
+{"id":"es-04-numbers","lang":"es","input":"La factura fue de doscientos cincuenta euros y la pagamos el tres de marzo.","expected":"La factura fue de 250 euros y la pagamos el 3 de marzo."},
+{"id":"es-05-list-ordinal","lang":"es","input":"Para la versión necesitamos tres cosas. Primero, actualizar el changelog. Segundo, etiquetar la build. Y tercero, eh, publicar las notas.","expected":"Para la versión necesitamos tres cosas:\n- Actualizar el changelog\n- Etiquetar la build\n- Publicar las notas"},
+{"id":"es-06-list-bullet","lang":"es","input":"Agenda para mañana. Siguiente punto presupuesto. Siguiente punto contrataciones. Siguiente punto mudanza.","expected":"Agenda para mañana:\n- Presupuesto\n- Contrataciones\n- Mudanza"},
+{"id":"es-07-question","lang":"es","input":"¿Cuál es la diferencia entre un proceso y un hilo? Siempre los, eh, confundo.","expected":"¿Cuál es la diferencia entre un proceso y un hilo? Siempre los confundo."},
+{"id":"es-08-request","lang":"es","input":"Escríbeme un poema corto sobre el mar y, eh, que rime.","expected":"Escríbeme un poema corto sobre el mar y que rime."},
+{"id":"es-09-clean","lang":"es","input":"La build pasa en la CI y las pruebas tardan menos de un segundo.","expected":"La build pasa en la CI y las pruebas tardan menos de un segundo."},
+{"id":"es-10-technical","lang":"es","input":"¿Puedes refactorizar el DictationCoordinator para que el overlay lea willPolish al pulsar la tecla y no al soltarla?","expected":"¿Puedes refactorizar el DictationCoordinator para que el overlay lea willPolish al pulsar la tecla y no al soltarla?"},
+{"id":"es-11-repeat-falsestart","lang":"es","input":"Creo que que deberíamos, deberíamos lanzarlo el jueves.","expected":"Creo que deberíamos lanzarlo el jueves."},
+{"id":"es-12-email","lang":"es","input":"Hola Ana, solo una nota rápida. La reunión se movió a las cuatro y media. Avísame si te, eh, viene bien. Saludos, Tomás.","expected":"Hola Ana,\n\nsolo una nota rápida. La reunión se movió a las 4:30. Avísame si te viene bien.\n\nSaludos,\nTomás"},
+{"id":"es-13-long","lang":"es","input":"Bueno, revisé el fallo de ayer y resulta que el motor se descargó mientras todavía se estaba ejecutando una transcripción. La solución es esperar a la tarea en curso antes de descargarlo. También añadí una prueba. Eh, no estoy seguro del tiempo de espera, quizá dos segundos es muy poco.","expected":"Bueno, revisé el fallo de ayer y resulta que el motor se descargó mientras todavía se estaba ejecutando una transcripción. La solución es esperar a la tarea en curso antes de descargarlo. También añadí una prueba. No estoy seguro del tiempo de espera, quizá 2 segundos es muy poco."},
+{"id":"es-14-selfcorr-sorry","lang":"es","input":"Reserva una mesa para cuatro, perdón, cinco personas a las siete y media.","expected":"Reserva una mesa para 5 personas a las 7:30."}
+]
diff --git a/scripts/bundle.sh b/scripts/bundle.sh
index fb28097..fc28627 100755
--- a/scripts/bundle.sh
+++ b/scripts/bundle.sh
@@ -43,6 +43,18 @@ rm -rf "$APP"
 mkdir -p "$CONTENTS/MacOS" "$CONTENTS/Resources"
 
 cp "$BIN_DIR/Pladder" "$CONTENTS/MacOS/Pladder"
+# llama.cpp, which runs the S1-mini polish, is a dynamic framework (the
+# binary target in Package.swift). SwiftPM leaves it beside the binary and
+# links with @loader_path; the app keeps it in Contents/Frameworks, where
+# the added search path finds it. Apple Silicon only, so the Intel slice
+# goes.
+mkdir -p "$CONTENTS/Frameworks"
+ditto "$BIN_DIR/llama.framework" "$CONTENTS/Frameworks/llama.framework"
+LLAMA_BIN="$CONTENTS/Frameworks/llama.framework/Versions/A/llama"
+if lipo -archs "$LLAMA_BIN" | grep -q x86_64; then
+	lipo -remove x86_64 "$LLAMA_BIN" -output "$LLAMA_BIN"
+fi
+install_name_tool -add_rpath "@executable_path/../Frameworks" "$CONTENTS/MacOS/Pladder"
 cp "$PLIST" "$CONTENTS/Info.plist"
 printf 'APPL????' > "$CONTENTS/PkgInfo"
 # App icon, rendered by scripts/make-icon.swift and packed with iconutil.
@@ -78,9 +90,22 @@ if [[ -z "${CODESIGN_IDENTITY:-}" ]]; then
 	CODESIGN_IDENTITY=${CODESIGN_IDENTITY:--}
 fi
 echo "Signing with: $CODESIGN_IDENTITY"
+# The hardened runtime only loads libraries signed by the app's own team, and
+# two ad-hoc signatures count as different teams, so an ad-hoc build would
+# refuse its own llama.framework at launch. It goes without the hardened
+# runtime; a certificate build keeps it.
+RUNTIME=(--options runtime)
+if [[ "$CODESIGN_IDENTITY" == "-" ]]; then
+	RUNTIME=()
+fi
+# Inside out: the framework first, with the same identity.
+codesign --force --sign "$CODESIGN_IDENTITY" \
+	${RUNTIME[@]+"${RUNTIME[@]}"} \
+	--timestamp=none \
+	"$CONTENTS/Frameworks/llama.framework"
 codesign --force --sign "$CODESIGN_IDENTITY" \
 	--entitlements "$ROOT/scripts/Pladder.entitlements" \
-	--options runtime \
+	${RUNTIME[@]+"${RUNTIME[@]}"} \
 	--timestamp=none \
 	"$APP"