Clean the transcript up on the subscription you already have

Cleanup was the one step with only one place to run. Speech to text has three
providers behind a setting and the agent has three behind another, but the
model that drops the "eee"s out of a sentence was always a request to
OpenRouter, which meant a second key on a machine that already pays for a model
and already hands whole dictations to it as commands. Claude Code and Codex can
rewrite a sentence as easily as they can put something in your calendar, and
now they may.

cleanup.py is where that choice lives, so worker, the file transcriber and the
meeting all ask the same question rather than each building the same OpenRouter
request. What comes out of a CLI that failed is a CleanupError, which is an
ApiError, because to the chain a cleanup that failed is a cleanup that failed
however it was run: the raw transcript is still pasted and the reason still
shows in the corner, unchanged.

Neither CLI is given anything it does not need for the job. No tools, no MCP
servers, no session to resume, and the home directory rather than wherever the
agent is pointed, since a project's instructions have opinions about how text
should be written and none of them are about this transcript. The transcript
goes in fenced the same way the OpenRouter call fences it, because it is
material rather than an instruction however much of it reads like one. Claude
takes the cleanup rules as its whole system prompt; Codex has no system prompt
of its own, so they ride in front of the text, and its answer is read from the
file it writes on the way out rather than from a stdout that also carries a
header, its thinking and a token count.

The cost is seconds. OpenRouter answers in about one, a CLI in six or seven,
because each one opens a whole session to do it. That is the trade the box
says out loud, and the default has not moved: OpenRouter cleans up until you
say otherwise.

Codex's two lowest thinking levels now ask for "low". "minimal" was its bottom
rung until the newer models replaced it with "none", and each of them answers
the other's word with a 400, which the agent has been quietly hitting too.

In the settings window the model box belongs to whoever is chosen rather than
meaning three different things in turn, since an OpenRouter id and a Claude
alias do not belong in the same field, and under it is the same "found it or
not" line the agent tab has. dikte doctor asks about the program instead of the
key when a CLI does the cleaning, and the history records which model actually
did it.

README.md

@@ -1,7 +1,7 @@
 # Dikte
 
 Press `Ctrl+Space`, talk, press again. The recording goes to OpenAI or OpenRouter
-for transcription, a model on OpenRouter cleans it up (dropping the *uh*s, the
+for transcription, a model cleans it up (dropping the *uh*s, the
 restarts, the missing punctuation), and the result lands in your clipboard and
 is pasted into whatever window you were typing in.
 
@@ -43,8 +43,8 @@ again and leaves your settings and dictations alone unless you pass `--purge`.
 
 Three keys go in the settings window: **OpenAI**, **Groq** and **OpenRouter**.
 Speech to text runs on any of them (`gpt-4o-transcribe` by default), cleanup
-always on OpenRouter (`google/gemini-3.5-flash-lite`), so a single OpenRouter key
-can cover both. They fall back to `OPENAI_API_KEY`, `GROQ_API_KEY` and
+on OpenRouter (`google/gemini-3.5-flash-lite`) or, when either is installed, on
+Claude Code or Codex instead, so a single OpenRouter key can cover both. They fall back to `OPENAI_API_KEY`, `GROQ_API_KEY` and
 `OPENROUTER_API_KEY`, and are
 stored in `~/.config/dikte/config.json`, mode 600. Cleanup can be switched off,
 in which case the raw transcript is pasted, and a thinking model's effort can be
@@ -148,6 +148,7 @@ audio.py          PCM capture: pw-record for dictation, ffmpeg for a meeting
 meeting.py        channel split, speaker labelling, cleanup, minutes
 assistant.py      running a dictation through Claude Code, Codex or OpenRouter
 api.py            transcription on either provider, OpenRouter cleanup (stdlib only)
+cleanup.py        who rewrites the transcript: OpenRouter, Claude Code or Codex
 worker.py         transcribe → clean up → clipboard → paste
 vad.py            deciding whether a recording holds speech at all
 filetranscribe.py file transcription: ffmpeg, chunking, timestamps

README.tr.md

@@ -1,7 +1,7 @@
 # Dikte
 
 `Ctrl+Space`'e bas, konuş, tekrar bas. Ses OpenAI'ye ya da OpenRouter'a gidip
-yazıya çevrilir, OpenRouter'daki bir model transkripti temizler (ıı'lar,
+yazıya çevrilir, bir model transkripti temizler (ıı'lar,
 tekrarlar, eksik noktalama), sonuç panoya kopyalanır ve o an yazdığın pencereye
 yapıştırılır.
 
@@ -44,8 +44,8 @@ diktelerine dokunmaz.
 
 Ayarlar penceresinde üç anahtar istenir: **OpenAI**, **Groq** ve **OpenRouter**.
 Sesi yazıya çevirme üçünden birinde çalışır (varsayılan `gpt-4o-transcribe`),
-temizleme her zaman OpenRouter'da (`google/gemini-3.5-flash-lite`), yani tek bir
-OpenRouter anahtarı ikisine de yeter. Boş bırakırsan `OPENAI_API_KEY`,
+temizleme OpenRouter'da (`google/gemini-3.5-flash-lite`) ya da kuruluysa Claude
+Code veya Codex'te, yani tek bir OpenRouter anahtarı ikisine de yeter. Boş bırakırsan `OPENAI_API_KEY`,
 `GROQ_API_KEY` ve `OPENROUTER_API_KEY` kullanılır;
 anahtarlar `~/.config/dikte/config.json`
 içinde, izinler 600. Temizlemeyi tamamen kapatabilirsin, o zaman ham transkript
@@ -147,6 +147,7 @@ audio.py          PCM kaydı: diktede pw-record, toplantıda ffmpeg
 meeting.py        kanal ayırma, konuşmacı etiketi, temizleme, tutanak
 assistant.py      dikteyi Claude Code, Codex ya da OpenRouter'dan geçirme
 api.py            iki sağlayıcıda transkript + OpenRouter temizleme (yalnız stdlib)
+cleanup.py        transkripti kim temizler: OpenRouter, Claude Code ya da Codex
 worker.py         transkript → temizleme → pano → yapıştırma
 vad.py            kayıtta gerçekten konuşma var mı kararı
 filetranscribe.py dosyadan transkript: ffmpeg, parçalama, zaman damgaları

assistant.py

@@ -75,7 +75,10 @@ CODEX_ITEMS = {
 CLAUDE_EFFORT = {"none": "low", "minimal": "low", "low": "low",
                  "medium": "medium", "high": "high", "xhigh": "xhigh",
                  "max": "max"}
-CODEX_EFFORT = {"none": "minimal", "minimal": "minimal", "low": "low",
+# "minimal" was Codex's bottom rung until the newer models replaced it with
+# "none", and each of them rejects the other's word for it with a 400. "low" is
+# the one every model has, so the two lowest rungs land there instead.
+CODEX_EFFORT = {"none": "low", "minimal": "low", "low": "low",
                 "medium": "medium", "high": "high", "xhigh": "high",
                 "max": "high"}
 
@@ -421,7 +424,7 @@ def _conclude(found, code, stderr, session, service):
     if code != 0 and not found["answer"]:
         if session and _session_missing(stderr):
             raise _SessionGone()
-        raise AssistantError(_last_line(stderr) or found["failure"] or t(
+        raise AssistantError(last_line(stderr) or found["failure"] or t(
             "{service} exited with code {code}.", service=service, code=code))
     if found["failure"] and not found["answer"]:
         raise AssistantError(found["failure"])
@@ -480,6 +483,11 @@ def _finish(proc):
     return stderr
 
 
-def _last_line(text):
+def last_line(text):
+    """The line worth showing out of a CLI's stderr: the last one it wrote.
+
+    Shared with cleanup, which runs the same two programs for a different job
+    and fails the same way when they are unhappy.
+    """
     lines = [line for line in (text or "").splitlines() if line.strip()]
     return lines[-1].strip() if lines else ""

cleanup.py

@@ -0,0 +1,181 @@
+"""Who rewrites the transcript once it has been heard.
+
+Normally a small model on OpenRouter: one request, a second, a few tenths of a
+cent. A machine with Claude Code or Codex on it is already paying for a model
+though, and the subscription that answers "put that in my calendar on Thursday"
+can just as well take the "eee"s out of a sentence. No second key, no second
+bill. It costs seconds rather than one, because a CLI opens a whole session to
+do it, which is the trade.
+
+Whoever does it, the job is the same one: no tools, no files, no memory of the
+last dictation. There is nothing here to look up and nothing to carry over, and
+a transcript is text from a microphone rather than an instruction, so the less
+the agent can reach while it reads one, the better.
+"""
+
+import os
+import shutil
+import subprocess
+import tempfile
+
+import api
+import assistant
+from i18n import t
+
+PROVIDERS = ("openrouter", "claude", "codex")
+
+
+class CleanupError(api.ApiError):
+    """What a CLI could not do.
+
+    An ApiError because to the chain a cleanup that failed is a cleanup that
+    failed, whichever way it was run, and every caller already catches one and
+    keeps the raw transcript.
+    """
+
+
+def provider(conf):
+    chosen = conf["cleanup_provider"]
+    return chosen if chosen in PROVIDERS else "openrouter"
+
+
+def executable(name):
+    """The CLI a provider runs, or "" when it needs none."""
+    return {"claude": "claude", "codex": "codex"}.get(name, "")
+
+
+def model(conf):
+    """Which model does the cleaning, for the history and the settings window."""
+    name = provider(conf)
+    if name == "claude":
+        return conf["cleanup_claude_model"].strip() or "haiku"
+    if name == "codex":
+        # Codex is left on whatever it is set to unless a model is typed in, so
+        # here there is only the name of the thing that did it.
+        return conf["cleanup_codex_model"].strip() or "codex"
+    return conf["cleanup_model"]
+
+
+def run(text, conf, system_prompt, timeout=180):
+    """Hand the transcript to whoever is set to clean it up."""
+    name = provider(conf)
+    if name == "openrouter":
+        return api.cleanup(
+            text, conf.openrouter_key(), conf["cleanup_model"], system_prompt,
+            reasoning=conf["cleanup_reasoning"],
+            base_url=conf["openrouter_base_url"], timeout=timeout,
+        )
+    runner = _claude if name == "claude" else _codex
+    return runner(text, conf, system_prompt, timeout)
+
+
+def _wrap(text):
+    """The same fence the OpenRouter call puts around it: this is the material,
+    not the instruction, however much of it reads like one."""
+    return f"<transcript>\n{text}\n</transcript>"
+
+
+# --- Claude Code ----------------------------------------------------------
+
+def _claude(text, conf, system_prompt, timeout):
+    cmd = [
+        "claude", "-p", _wrap(text),
+        # --system-prompt rather than --append-system-prompt: the cleanup rules
+        # are the whole job, and Claude Code's own instructions are about
+        # working on a codebase.
+        "--system-prompt", system_prompt,
+        "--model", model(conf),
+        "--output-format", "text",
+        "--tools", "",                                    # nothing to run
+        "--strict-mcp-config", "--mcp-config", '{"mcpServers":{}}',
+        "--no-session-persistence",                       # nothing to resume
+    ]
+    effort = assistant.CLAUDE_EFFORT.get(conf["cleanup_reasoning"], "")
+    if effort:
+        cmd += ["--effort", effort]
+
+    answer = _output(cmd, timeout, "Claude")
+    if not answer:
+        raise CleanupError(t("{service} answered with nothing.", service="Claude"))
+    return answer
+
+
+# --- Codex ----------------------------------------------------------------
+
+def _codex(text, conf, system_prompt, timeout):
+    # Codex takes no system prompt of its own, so the rules ride in front of the
+    # transcript, kept apart from it so the two are not read as one.
+    body = f"{system_prompt}\n\n---\n\n{_wrap(text)}"
+    cmd = [
+        "codex", "exec",
+        "--sandbox", "read-only",          # it has no reason to touch the disk
+        "--skip-git-repo-check",
+        "--ephemeral",                     # nothing to resume
+        "--color", "never",
+        "-c", 'approval_policy="never"',   # there is nobody here to approve
+    ]
+    if conf["cleanup_codex_model"].strip():
+        cmd += ["-m", conf["cleanup_codex_model"].strip()]
+    effort = assistant.CODEX_EFFORT.get(conf["cleanup_reasoning"], "")
+    if effort:
+        cmd += ["-c", f'model_reasoning_effort="{effort}"']
+
+    # `codex exec` prints a header, its thinking and a token count around the
+    # answer; the file it writes on the way out is the answer on its own.
+    handle, last_message = tempfile.mkstemp(prefix="dikte-cleanup-", suffix=".txt")
+    os.close(handle)
+    cmd += ["-o", last_message, body]
+    try:
+        _output(cmd, timeout, "Codex")
+        answer = _read(last_message)
+    finally:
+        try:
+            os.unlink(last_message)
+        except OSError:
+            pass
+
+    if not answer:
+        raise CleanupError(t("{service} answered with nothing.", service="Codex"))
+    return answer
+
+
+def _read(path):
+    try:
+        with open(path, encoding="utf-8", errors="replace") as fh:
+            return fh.read().strip()
+    except OSError:
+        return ""
+
+
+# --- running a CLI --------------------------------------------------------
+
+def _output(cmd, timeout, service):
+    """Run cmd to the end and return what it printed.
+
+    It runs in the home directory rather than wherever the agent is pointed: a
+    project's instructions have opinions about how text should be written, and
+    none of them are about this transcript.
+    """
+    binary = cmd[0]
+    if not shutil.which(binary):
+        raise CleanupError(t(
+            "{binary} not found. Install it, or have OpenRouter clean up "
+            "instead, under Settings → API and models.", binary=binary,
+        ))
+    try:
+        done = subprocess.run(
+            cmd, cwd=os.path.expanduser("~"), stdin=subprocess.DEVNULL,
+            capture_output=True, text=True, encoding="utf-8", errors="replace",
+            timeout=timeout,
+        )
+    except subprocess.TimeoutExpired:
+        raise CleanupError(t("{service} did not finish within {seconds} seconds.",
+                             service=service, seconds=timeout)) from None
+    except OSError as exc:
+        raise CleanupError(t("Could not run {binary}: {error}",
+                             binary=binary, error=exc)) from exc
+    if done.returncode != 0:
+        raise CleanupError(assistant.last_line(done.stderr) or t(
+            "{service} exited with code {code}.",
+            service=service, code=done.returncode))
+    return (done.stdout or "").strip()

cli.py

@@ -25,6 +25,7 @@ from PyQt6.QtCore import QCoreApplication, QTimer
 import api
 import assistant
 import audio
+import cleanup
 import config as cfg
 import filetranscribe
 import hotkey
@@ -764,16 +765,18 @@ def cmd_status(opts):
 def cmd_doctor(opts):
     """What the settings window checks behind its buttons, in one pass."""
     conf = cfg.Config()
-    programs = {name: shutil.which(name) or ""
-                for name in ("pw-record", "wl-copy", "ydotool", "ffmpeg",
-                             "pactl", "kwriteconfig6",
-                             assistant.executable(assistant.provider(conf)) or "claude")}
+    wanted = ["pw-record", "wl-copy", "ydotool", "ffmpeg", "pactl", "kwriteconfig6",
+              assistant.executable(assistant.provider(conf)) or "claude",
+              cleanup.executable(cleanup.provider(conf))]
+    programs = {name: shutil.which(name) or "" for name in wanted if name}
     target = conf.transcribe_target()
+    cleaner = cleanup.provider(conf)
     checks = {
         "programs": programs,
         "transcription": {"provider": target.provider, "model": target.model,
                           "key": bool(target.api_key)},
-        "cleanup": {"enabled": conf["cleanup_enabled"], "model": conf["cleanup_model"],
+        "cleanup": {"enabled": conf["cleanup_enabled"], "provider": cleaner,
+                    "model": cleanup.model(conf),
                     "key": bool(conf.openrouter_key())},
         "agent": {"provider": assistant.provider(conf),
                   "directory": assistant.working_dir(conf)},
@@ -784,8 +787,11 @@ def cmd_doctor(opts):
     lines += [
         f"{'✓' if target.api_key else '✗'} {target.service} key, transcribing on "
         f"{target.model}",
-        f"{'✓' if conf.openrouter_key() else '✗'} OpenRouter key, cleaning up on "
-        f"{conf['cleanup_model']}",
+        # Cleanup on a CLI needs no key, so what is checked is the program.
+        (f"{'✓' if conf.openrouter_key() else '✗'} OpenRouter key, cleaning up on "
+         f"{conf['cleanup_model']}") if cleaner == "openrouter" else
+        (f"{'✓' if programs[cleanup.executable(cleaner)] else '✗'} "
+         f"{cleanup.executable(cleaner)}, cleaning up on {cleanup.model(conf)}"),
         f"{'✓' if checks['running'] else '·'} application "
         + ("running" if checks["running"] else "not running"),
     ]

config.py

@@ -375,7 +375,10 @@ DEFAULTS = {
     "language": "tr",
     "transcribe_prompt": "",
     "cleanup_enabled": True,
+    "cleanup_provider": "openrouter",  # openrouter | claude | codex
     "cleanup_model": "google/gemini-3.5-flash-lite",
+    "cleanup_claude_model": "haiku",   # Claude Code: an alias, or a full model id
+    "cleanup_codex_model": "",         # empty -> whatever Codex is set to
     "cleanup_reasoning": "",        # empty -> whatever the model does by default
     "cleanup_prompt": "",           # empty -> language-specific default
     "auto_paste": True,

filetranscribe.py

@@ -17,6 +17,7 @@ import wave
 from PyQt6.QtCore import QObject, pyqtSignal
 
 import api
+import cleanup
 from i18n import t
 
 CHUNK_SECONDS = 600          # 10 min ≈ 19 MB at 16 kHz mono s16
@@ -130,14 +131,7 @@ class FileTranscriber(QObject):
         out = []
         for block in split_text(text, timestamps):
             self._check()
-            out.append(api.cleanup(
-                block,
-                conf.openrouter_key(),
-                conf["cleanup_model"],
-                prompt,
-                reasoning=conf["cleanup_reasoning"],
-                base_url=conf["openrouter_base_url"],
-            ))
+            out.append(cleanup.run(block, conf, prompt))
         return ("\n" if timestamps else "\n\n").join(out)
 
 

i18n.py

@@ -186,6 +186,18 @@ TR = {
     "Connection works. {count} audio models visible.":
         "Bağlantı tamam. {count} ses modeli görünüyor.",
     "Clean the transcript with a model": "Transkripti bir modelle temizle",
+    "OpenRouter is the quickest and the only one that needs nothing installed. "
+    "Claude Code and Codex clean up on the subscription you already have, "
+    "without a second key, and take a few seconds longer because each one opens "
+    "a session to do it.":
+        "En hızlısı OpenRouter'dır ve kurulu bir program istemeyen tek seçenektir. "
+        "Claude Code ile Codex, temizliği hâlihazırda ödediğin abonelik üzerinden "
+        "yapar, ikinci bir anahtar istemez; her biri bunun için bir oturum açtığından "
+        "birkaç saniye daha uzun sürer.",
+    "{binary} is not on your PATH, so cleanup would fail and the raw transcript "
+    "would be pasted. Install it, or pick another one above.":
+        "{binary} PATH'te değil; temizleme başarısız olur ve ham transkript "
+        "yapıştırılır. Kur ya da yukarıdan başka birini seç.",
     "Thinking": "Düşünme",
     "Model's own default": "Modelin kendi varsayılanı",
     "Off": "Kapalı",
@@ -380,6 +392,14 @@ TR = {
     "It was not allowed to use: {tools}": "Şunları kullanmasına izin yoktu: {tools}",
     "The model returned an empty reply.": "Model boş cevap döndürdü.",
 
+    # --- cleanup, when a CLI does it ----------------------------------------
+    "{binary} not found. Install it, or have OpenRouter clean up instead, "
+    "under Settings → API and models.":
+        "{binary} bulunamadı. Kur ya da Ayarlar → API ve modeller sekmesinden "
+        "temizliği OpenRouter'a bırak.",
+    "{service} did not finish within {seconds} seconds.":
+        "{service} {seconds} saniye içinde bitmedi.",
+
     # --- settings: the agent ------------------------------------------------
     "Agent": "Ajan",
     "This shortcut records the same way dictation does, but the transcript is "

meeting.py

@@ -25,6 +25,7 @@ import wave
 from PyQt6.QtCore import QObject, pyqtSignal
 
 import api
+import cleanup
 import config as cfg
 import filetranscribe
 import vad
@@ -208,14 +209,7 @@ class MeetingPipeline(QObject):
             if len(blocks) > 1:
                 self._say(t("Cleaning up {index}/{count}…",
                             index=index, count=len(blocks)))
-            out.append(api.cleanup(
-                block,
-                conf.openrouter_key(),
-                conf["cleanup_model"],
-                prompt,
-                reasoning=conf["cleanup_reasoning"],
-                base_url=conf["openrouter_base_url"],
-            ))
+            out.append(cleanup.run(block, conf, prompt, timeout=600))
         return "\n".join(out)
 
     def _write(self, doc_path, minutes, transcript, entry):

settings_ui.py

@@ -16,6 +16,7 @@ from PyQt6.QtWidgets import (
 import api
 import assistant
 import audio
+import cleanup
 import config as cfg
 import filetranscribe
 import hotkey
@@ -49,6 +50,15 @@ CLEANUP_MODELS = [
     "google/gemini-2.5-flash-lite", "anthropic/claude-haiku-4.5",
     "openai/gpt-5-mini", "meta-llama/llama-3.3-70b-instruct",
 ]
+# The same two CLIs the agent can run on, doing the smaller job instead. They
+# are offered second: a request to OpenRouter is over in a second, and a CLI
+# opens a session first.
+CLEANUP_PROVIDERS = [
+    ("OpenRouter", "openrouter"), ("Claude Code", "claude"), ("Codex", "codex"),
+]
+# Cleaning up a sentence is the lightest thing either of them will ever be
+# asked, so the small model comes first.
+CLEANUP_CLAUDE_MODELS = ["haiku", "sonnet", "opus", "fable"]
 # Minutes are a harder job than cleanup: an hour of talk has to be read whole
 # and turned into decisions, so the starting points are the larger models.
 MEETING_MODELS = [
@@ -282,16 +292,42 @@ class SettingsWindow(QDialog):
         outer.addWidget(stt)
 
         orr = QGroupBox(t("Transcript cleanup"))
-        orr_form = QFormLayout(orr)
+        orr_form = self.cleanup_form = QFormLayout(orr)
         self.cleanup_enabled = QCheckBox(t("Clean the transcript with a model"))
         orr_form.addRow("", self.cleanup_enabled)
 
+        self.cleanup_provider = QComboBox()
+        for label, value in CLEANUP_PROVIDERS:
+            self.cleanup_provider.addItem(t(label), value)
+        self.cleanup_provider.setToolTip(t(
+            "OpenRouter is the quickest and the only one that needs nothing "
+            "installed. Claude Code and Codex clean up on the subscription you "
+            "already have, without a second key, and take a few seconds longer "
+            "because each one opens a session to do it."
+        ))
+        self.cleanup_provider.currentIndexChanged.connect(self._cleanup_provider_changed)
+        orr_form.addRow(t("Runs on"), self.cleanup_provider)
+
         self.cleanup_model = QComboBox()
         self.cleanup_model.setEditable(True)
         self.cleanup_model.addItems(CLEANUP_MODELS)
         self.refresh_models = QPushButton(t("Fetch model list"))
         self.refresh_models.clicked.connect(self._load_models)
-        orr_form.addRow(t("Model"), self._row(self.cleanup_model, self.refresh_models))
+        self.cleanup_model_row = self._row(self.cleanup_model, self.refresh_models)
+        orr_form.addRow(t("Model"), self.cleanup_model_row)
+
+        # One row per provider rather than one box that means a different thing
+        # in each: an OpenRouter id and a Claude alias do not belong in the same
+        # field, and only the row of whoever is chosen is on screen.
+        self.cleanup_claude_model = QComboBox()
+        self.cleanup_claude_model.setEditable(True)
+        self.cleanup_claude_model.addItems(CLEANUP_CLAUDE_MODELS)
+        orr_form.addRow(t("Model"), self.cleanup_claude_model)
+
+        self.cleanup_codex_model = QComboBox()
+        self.cleanup_codex_model.setEditable(True)
+        self.cleanup_codex_model.addItems([t("Codex's own default")] + CODEX_MODELS)
+        orr_form.addRow(t("Model"), self.cleanup_codex_model)
 
         self.cleanup_reasoning = QComboBox()
         for label, value in REASONING_LEVELS:
@@ -951,6 +987,12 @@ class SettingsWindow(QDialog):
         self._provider_changed()  # selecting index 0 fires no signal
         self.cleanup_enabled.setChecked(conf["cleanup_enabled"])
         self.cleanup_model.setCurrentText(conf["cleanup_model"])
+        self.cleanup_claude_model.setCurrentText(conf["cleanup_claude_model"])
+        self.cleanup_codex_model.setCurrentText(
+            conf["cleanup_codex_model"] or t("Codex's own default")
+        )
+        self._select_data(self.cleanup_provider, conf["cleanup_provider"])
+        self._cleanup_provider_changed()  # selecting index 0 fires no signal
         self._select_data(self.cleanup_reasoning, conf["cleanup_reasoning"])
         self.cleanup_prompt.setPlainText(conf["cleanup_prompt"] or cfg.default_cleanup_prompt())
         self.file_cleanup_prompt.setPlainText(
@@ -1029,7 +1071,14 @@ class SettingsWindow(QDialog):
             conf[who.model] = self._models[name].strip() or cfg.DEFAULTS[who.model]
 
         conf["cleanup_enabled"] = self.cleanup_enabled.isChecked()
+        conf["cleanup_provider"] = self.cleanup_provider.currentData() or "openrouter"
         conf["cleanup_model"] = self.cleanup_model.currentText().strip()
+        conf["cleanup_claude_model"] = (self.cleanup_claude_model.currentText().strip()
+                                        or cfg.DEFAULTS["cleanup_claude_model"])
+        codex_cleanup_model = self.cleanup_codex_model.currentText().strip()
+        conf["cleanup_codex_model"] = (
+            "" if codex_cleanup_model == t("Codex's own default") else codex_cleanup_model
+        )
         conf["cleanup_reasoning"] = self.cleanup_reasoning.currentData() or ""
 
         # Store an empty prompt when it matches the default, so switching the
@@ -1347,6 +1396,27 @@ class SettingsWindow(QDialog):
             else missing
         )
 
+    def _cleanup_provider_changed(self):
+        provider = self.cleanup_provider.currentData() or "openrouter"
+        self.cleanup_form.setRowVisible(self.cleanup_model_row,
+                                        provider == "openrouter")
+        self.cleanup_form.setRowVisible(self.cleanup_claude_model,
+                                        provider == "claude")
+        self.cleanup_form.setRowVisible(self.cleanup_codex_model,
+                                        provider == "codex")
+        binary = cleanup.executable(provider)
+        found = shutil.which(binary) if binary else ""
+        if not binary:
+            self.models_label.setText(t("Runs on OpenRouter."))
+        elif found:
+            self.models_label.setText(t("Found: {path}", path=found))
+        else:
+            self.models_label.setText(t(
+                "{binary} is not on your PATH, so cleanup would fail and the raw "
+                "transcript would be pasted. Install it, or pick another one "
+                "above.", binary=binary,
+            ))
+
     def _assistant_provider_changed(self):
         provider = self.assistant_provider.currentData() or "claude"
         self.claude_box.setVisible(provider == "claude")

tests/test_assistant.py

@@ -79,9 +79,12 @@ class Effort(unittest.TestCase):
         self.assertEqual(assistant.CODEX_EFFORT["xhigh"], "high")
         self.assertEqual(assistant.CODEX_EFFORT["max"], "high")
 
-    def test_claude_has_no_rung_below_low(self):
-        self.assertEqual(assistant.CLAUDE_EFFORT["none"], "low")
-        self.assertEqual(assistant.CLAUDE_EFFORT["minimal"], "low")
+    def test_neither_one_asks_for_a_rung_below_low(self):
+        # Claude has none; Codex has one, but calls it "minimal" on the older
+        # models and "none" on the newer ones, and refuses the wrong word.
+        for scale in (assistant.CLAUDE_EFFORT, assistant.CODEX_EFFORT):
+            self.assertEqual(scale["none"], "low")
+            self.assertEqual(scale["minimal"], "low")
 
     def test_an_empty_setting_asks_for_nothing(self):
         self.assertEqual(assistant.CLAUDE_EFFORT.get("", ""), "")
@@ -232,10 +235,10 @@ class SessionMissing(unittest.TestCase):
                 self.assertFalse(assistant._session_missing(text))
 
     def test_the_last_line_is_the_one_worth_showing(self):
-        self.assertEqual(assistant._last_line("warning\n\nreal error\n"),
+        self.assertEqual(assistant.last_line("warning\n\nreal error\n"),
                          "real error")
-        self.assertEqual(assistant._last_line(""), "")
-        self.assertEqual(assistant._last_line(None), "")
+        self.assertEqual(assistant.last_line(""), "")
+        self.assertEqual(assistant.last_line(None), "")
 
 
 class Conclude(DikteTest):

tests/test_cleanup.py

@@ -0,0 +1,211 @@
+"""Who cleans the transcript up, and what they are asked.
+
+The CLIs are faked at subprocess.run: what the tests read is the argument list
+each one is given, where the answer is picked up from, and what happens to the
+chain when the program is missing, slow or unhappy. The OpenRouter path is the
+one that was always there and is checked here only for still being taken.
+"""
+
+import os
+import subprocess
+import unittest
+from unittest import mock
+
+import api
+import cleanup
+from tests.support import DikteTest
+
+
+def fake_run(stdout="", code=0, stderr="", last_message=""):
+    """Stand in for subprocess.run, writing the file Codex would have written."""
+    calls = []
+
+    def run(cmd, **kwargs):
+        calls.append(cmd)
+        if last_message and "-o" in cmd:
+            with open(cmd[cmd.index("-o") + 1], "w", encoding="utf-8") as fh:
+                fh.write(last_message)
+        return subprocess.CompletedProcess(cmd, code, stdout, stderr)
+
+    return mock.patch.object(subprocess, "run", side_effect=run), calls
+
+
+class Provider(DikteTest):
+    def test_the_default_is_still_openrouter(self):
+        self.assertEqual(cleanup.provider(self.config()), "openrouter")
+
+    def test_a_provider_this_version_does_not_have(self):
+        self.assertEqual(
+            cleanup.provider(self.config(cleanup_provider="ollama")), "openrouter")
+
+    def test_each_one_is_recognised(self):
+        for name in cleanup.PROVIDERS:
+            with self.subTest(name=name):
+                self.assertEqual(
+                    cleanup.provider(self.config(cleanup_provider=name)), name)
+
+    def test_what_each_one_runs(self):
+        self.assertEqual(cleanup.executable("claude"), "claude")
+        self.assertEqual(cleanup.executable("codex"), "codex")
+        self.assertEqual(cleanup.executable("openrouter"), "")
+
+    def test_the_model_named_in_the_history_is_the_one_that_did_it(self):
+        self.assertEqual(cleanup.model(self.config(cleanup_model="some/model")),
+                         "some/model")
+        self.assertEqual(
+            cleanup.model(self.config(cleanup_provider="claude")), "haiku")
+        self.assertEqual(
+            cleanup.model(self.config(cleanup_provider="claude",
+                                      cleanup_claude_model="opus")), "opus")
+        # Codex on its own default has no model id to report, only a name.
+        self.assertEqual(
+            cleanup.model(self.config(cleanup_provider="codex")), "codex")
+        self.assertEqual(
+            cleanup.model(self.config(cleanup_provider="codex",
+                                      cleanup_codex_model="gpt-5.4")), "gpt-5.4")
+
+
+class OpenRouter(DikteTest):
+    def test_it_is_still_one_request_with_the_settings_as_they_were(self):
+        conf = self.config(openrouter_api_key="sk-or-test",
+                           cleanup_model="some/model", cleanup_reasoning="low")
+        with mock.patch.object(api, "cleanup", return_value="Done.") as call:
+            self.assertEqual(cleanup.run("uh, done", conf, "the rules"), "Done.")
+        text, key, model, prompt = call.call_args.args
+        self.assertEqual((text, key, model, prompt),
+                         ("uh, done", "sk-or-test", "some/model", "the rules"))
+        self.assertEqual(call.call_args.kwargs["reasoning"], "low")
+
+    def test_no_cli_is_started_for_it(self):
+        conf = self.config(openrouter_api_key="sk-or-test")
+        patcher, calls = fake_run(stdout="never")
+        with patcher, mock.patch.object(api, "cleanup", return_value="Done."):
+            cleanup.run("uh, done", conf, "the rules")
+        self.assertEqual(calls, [])
+
+
+class ClaudeCode(DikteTest):
+    def setUp(self):
+        super().setUp()
+        self.conf = self.config(cleanup_provider="claude")
+        self.patch_attr(cleanup.shutil, "which", lambda name: f"/usr/bin/{name}")
+
+    def run_cleanup(self, text="uh, book it", **kwargs):
+        patcher, calls = fake_run(**kwargs)
+        with patcher:
+            answer = cleanup.run(text, self.conf, "the rules")
+        return answer, calls[0]
+
+    def test_the_transcript_goes_in_fenced_and_the_rules_go_in_as_the_prompt(self):
+        answer, cmd = self.run_cleanup(stdout="Book it.\n")
+        self.assertEqual(answer, "Book it.")
+        self.assertEqual(cmd[0], "claude")
+        self.assertIn("<transcript>\nuh, book it\n</transcript>", cmd)
+        self.assertEqual(cmd[cmd.index("--system-prompt") + 1], "the rules")
+        self.assertEqual(cmd[cmd.index("--model") + 1], "haiku")
+
+    def test_it_is_given_nothing_to_run_and_nothing_to_remember(self):
+        _, cmd = self.run_cleanup(stdout="Book it.")
+        self.assertEqual(cmd[cmd.index("--tools") + 1], "")
+        self.assertIn("--strict-mcp-config", cmd)
+        self.assertIn("--no-session-persistence", cmd)
+
+    def test_the_thinking_setting_is_carried_over_in_its_own_words(self):
+        self.conf["cleanup_reasoning"] = "none"
+        _, cmd = self.run_cleanup(stdout="Book it.")
+        self.assertEqual(cmd[cmd.index("--effort") + 1], "low")
+
+    def test_no_thinking_setting_means_no_flag(self):
+        _, cmd = self.run_cleanup(stdout="Book it.")
+        self.assertNotIn("--effort", cmd)
+
+    def test_a_model_of_your_own(self):
+        self.conf["cleanup_claude_model"] = "claude-sonnet-5"
+        _, cmd = self.run_cleanup(stdout="Book it.")
+        self.assertEqual(cmd[cmd.index("--model") + 1], "claude-sonnet-5")
+
+    def test_an_answer_of_nothing_is_a_failure_rather_than_an_empty_paste(self):
+        with self.assertRaises(cleanup.CleanupError):
+            self.run_cleanup(stdout="   \n")
+
+    def test_the_last_line_of_the_complaint_is_what_gets_shown(self):
+        with self.assertRaises(cleanup.CleanupError) as caught:
+            self.run_cleanup(code=1, stderr="a warning\nout of credit\n")
+        self.assertEqual(str(caught.exception), "out of credit")
+
+    def test_a_failure_is_the_same_kind_the_chain_already_catches(self):
+        # worker, the file transcriber and the meeting all keep the raw
+        # transcript when an ApiError comes out of here.
+        self.assertTrue(issubclass(cleanup.CleanupError, api.ApiError))
+
+    def test_a_program_that_is_not_installed_says_so_before_running_anything(self):
+        self.patch_attr(cleanup.shutil, "which", lambda name: "")
+        with self.assertRaises(cleanup.CleanupError) as caught:
+            self.run_cleanup(stdout="Book it.")
+        self.assertIn("claude", str(caught.exception))
+
+    def test_a_run_that_never_ends(self):
+        def run(cmd, **kwargs):
+            raise subprocess.TimeoutExpired(cmd, 180)
+
+        with mock.patch.object(subprocess, "run", side_effect=run):
+            with self.assertRaises(cleanup.CleanupError) as caught:
+                cleanup.run("uh, book it", self.conf, "the rules")
+        self.assertIn("180", str(caught.exception))
+
+
+class Codex(DikteTest):
+    def setUp(self):
+        super().setUp()
+        self.conf = self.config(cleanup_provider="codex")
+        self.patch_attr(cleanup.shutil, "which", lambda name: f"/usr/bin/{name}")
+
+    def run_cleanup(self, text="uh, book it", **kwargs):
+        patcher, calls = fake_run(**kwargs)
+        with patcher:
+            answer = cleanup.run(text, self.conf, "the rules")
+        return answer, calls[0]
+
+    def test_the_rules_ride_in_front_of_the_transcript(self):
+        answer, cmd = self.run_cleanup(last_message="Book it.\n")
+        self.assertEqual(answer, "Book it.")
+        self.assertEqual(cmd[:2], ["codex", "exec"])
+        self.assertEqual(cmd[-1],
+                         "the rules\n\n---\n\n<transcript>\nuh, book it\n</transcript>")
+
+    def test_the_answer_is_read_from_the_file_rather_than_the_noise_on_stdout(self):
+        answer, _ = self.run_cleanup(
+            stdout="workdir: /home\nmodel: gpt-5.4\ntokens used 400\n",
+            last_message="Book it.",
+        )
+        self.assertEqual(answer, "Book it.")
+
+    def test_that_file_does_not_stay_behind(self):
+        _, cmd = self.run_cleanup(last_message="Book it.")
+        self.assertFalse(os.path.exists(cmd[cmd.index("-o") + 1]))
+
+    def test_it_may_read_but_not_write_and_has_nobody_to_ask(self):
+        _, cmd = self.run_cleanup(last_message="Book it.")
+        self.assertEqual(cmd[cmd.index("--sandbox") + 1], "read-only")
+        self.assertIn('approval_policy="never"', cmd)
+        self.assertIn("--ephemeral", cmd)
+
+    def test_the_model_is_left_alone_until_one_is_typed_in(self):
+        _, cmd = self.run_cleanup(last_message="Book it.")
+        self.assertNotIn("-m", cmd)
+        self.conf["cleanup_codex_model"] = "gpt-5.4"
+        _, cmd = self.run_cleanup(last_message="Book it.")
+        self.assertEqual(cmd[cmd.index("-m") + 1], "gpt-5.4")
+
+    def test_the_thinking_setting_lands_on_the_nearest_rung_codex_has(self):
+        self.conf["cleanup_reasoning"] = "xhigh"
+        _, cmd = self.run_cleanup(last_message="Book it.")
+        self.assertIn('model_reasoning_effort="high"', cmd)
+
+    def test_an_answer_of_nothing(self):
+        with self.assertRaises(cleanup.CleanupError):
+            self.run_cleanup(stdout="tokens used 400", last_message="")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_cli.py

@@ -366,6 +366,34 @@ class Providers(DikteTest):
         self.assertIn("Groq", out)
 
 
+class Doctor(DikteTest):
+    """One pass over everything the settings window checks behind its buttons."""
+
+    def run_doctor(self, as_json=True, **settings):
+        self.write_config(settings)
+        with mock.patch.object(ipc, "send", return_value=None), \
+                captured() as (out, _err):
+            cli.cmd_doctor(Options(json=as_json))
+        return json.loads(out.getvalue()) if as_json else out.getvalue()
+
+    def test_cleanup_on_openrouter_is_a_question_about_the_key(self):
+        reply = self.run_doctor(cleanup_model="some/model")
+        self.assertEqual(reply["cleanup"]["provider"], "openrouter")
+        self.assertEqual(reply["cleanup"]["model"], "some/model")
+        self.assertIn("OpenRouter key, cleaning up on some/model",
+                      self.run_doctor(as_json=False, cleanup_model="some/model"))
+
+    def test_cleanup_on_a_cli_is_a_question_about_the_program(self):
+        reply = self.run_doctor(cleanup_provider="codex",
+                                cleanup_codex_model="gpt-5.4")
+        self.assertEqual(reply["cleanup"]["provider"], "codex")
+        self.assertEqual(reply["cleanup"]["model"], "gpt-5.4")
+        self.assertIn("codex", reply["programs"])
+        self.assertIn("codex, cleaning up on gpt-5.4",
+                      self.run_doctor(as_json=False, cleanup_provider="codex",
+                                      cleanup_codex_model="gpt-5.4"))
+
+
 class Finding(DikteTest):
     def test_no_history_at_all(self):
         self.assertIsNone(cli._find_history("last"))

tests/test_ui.py

@@ -44,7 +44,10 @@ CHANGED = {
     "groq_transcribe_model": "whisper-large-v3",
     "openrouter_transcribe_model": "openai/whisper-1",
     "cleanup_enabled": False,
+    "cleanup_provider": "claude",
     "cleanup_model": "some/other-model",
+    "cleanup_claude_model": "opus",
+    "cleanup_codex_model": "gpt-5",
     "cleanup_reasoning": "high",
     "cleanup_prompt": "Only fix the punctuation.",
     "file_cleanup_prompt": "Keep the stamps where they are.",
@@ -128,6 +131,20 @@ class Settings(DikteTest):
             with self.subTest(key=key):
                 self.assertEqual(stored[key], value)
 
+    def test_the_model_box_on_screen_belongs_to_whoever_cleans_up(self):
+        """An OpenRouter id and a Claude alias are not the same field."""
+        window = self.window(cfg.Config())
+        boxes = {"openrouter": window.cleanup_model_row,
+                 "claude": window.cleanup_claude_model,
+                 "codex": window.cleanup_codex_model}
+        for provider, box in boxes.items():
+            with self.subTest(provider=provider):
+                window._select_data(window.cleanup_provider, provider)
+                shown = [name for name, other in boxes.items()
+                         if not other.isHidden()]
+                self.assertEqual(shown, [provider])
+                self.assertFalse(box.isHidden())
+
     def test_the_settings_the_window_does_not_show_are_left_alone(self):
         """A tab nobody wrote must not reset what the command line set."""
         self.write_config({"silence_db": -42.0, "speech_margin_db": 15.0,

worker.py

@@ -18,6 +18,7 @@ from PyQt6.QtCore import QObject, pyqtSignal
 import api
 import assistant
 import audio
+import cleanup
 import config as cfg
 import i18n
 import paste
@@ -112,14 +113,7 @@ class Pipeline(QObject):
             if (conf["assistant_cleanup"] if ask else conf["cleanup_enabled"]):
                 self.stage.emit(t("Cleaning up…"))
                 try:
-                    text = api.cleanup(
-                        raw,
-                        conf.openrouter_key(),
-                        conf["cleanup_model"],
-                        conf.cleanup_prompt(),
-                        reasoning=conf["cleanup_reasoning"],
-                        base_url=conf["openrouter_base_url"],
-                    )
+                    text = cleanup.run(raw, conf, conf.cleanup_prompt())
                 except api.ApiError as exc:
                     # Keep the transcript, but never let the failure pass unseen:
                     # a rejected key would otherwise look like working dictation.
@@ -159,7 +153,7 @@ class Pipeline(QObject):
                 "duration": round(duration, 1),
                 "elapsed": round(time.monotonic() - started, 1),
                 "model": target.model,
-                "cleanup_model": conf["cleanup_model"] if conf["cleanup_enabled"] else "",
+                "cleanup_model": cleanup.model(conf) if conf["cleanup_enabled"] else "",
                 "cleanup_error": warning,
                 "mode": "ask" if ask else "",
                 "question": question,