FlowVoice (OS-wide dictation + history)
Omniscio's OS-wide dictation: hold a hotkey, speak, and the cleaned transcript is typed at the cursor in whatever app is focused — a browser, an editor, Slack — not just Omniscio's own message box. Covers the two hotkey slots, the Gemini, hosted, cloud and on-computer speech engines and what each costs, the floating pill and composer mic button, where to configure it, the words the engine is told to expect, and the promises that a recording is kept and a dictation delivered whole or its audio saved. Each plan includes a monthly dictation allowance — Free 15 minutes, Pro, Team, Enterprise and Developer 5 hours (Team's per seat) — and cloud captions for a screen recording spend the same minutes.
On this page
What it is
FlowVoice is a self-contained port of the standalone FlowVoice app, living entirely under src/main/services/flowvoice/ (main) and src/renderer/src/features/flowvoice/ (renderer), with its own flowvoice:* IPC channels and its own JSON settings/history stores; it does not touch Omniscio's existing voice stack. See the contract at .claude/memory/contracts/flowvoice.contract.md. The feature is on by default (a stored false always wins; a throwaway test copy such as the sandbox, an E2E run or dev2 starts off, so it never floats its own pill over your real screen) and is not gated behind an unreleased-feature flag: the settings card is visible to every user.
What happens to a dictation's audio: it is kept for every dictation rather than only the failed ones, and nothing about a dictation's own outcome can delete it. A kept recording's words live on the recording itself — each recording carries its own transcript, so one whose history row has aged out is not shown blank.
A delivered dictation makes promises it keeps: the words the speech engine heard are delivered even when it never finalized them, a transcript far too short for its audio keeps that recording instead of being trusted, and every dictation you have made stays in a history list inside the settings card.
A speech engine that hears an unfamiliar name writes the nearest ordinary word instead — "initial" for "Omniscio", "sequel" for "SQL". FlowVoice can send a list of expected words with every dictation on the cloud engine, so the engine spells them right at the source rather than the app patching the text afterwards. There are two lists: the words you keep yourself, and the words Omniscio learns from the corrections you make. Other engines ignore both.
Where to find it
Settings → Voice Control, under the Dictation (FlowVoice) heading. Without leaving a session you can also reach the same card from the message box: a right-click on the mic (or the Menu key / Shift+F10 with the mic focused) opens the card in a dialog over your composer rather than sending you to Settings (flowvoice.contract.md settings-open-where-the-user-is; rendered by VoiceSpeechSettings.tsx). The dialog splits the card into a sidebar of sections — General (the on switch, the paused-by-another-dictation-app note, the permission pills), Shortcut, Speech & mic, Words, Behavior, Usage & cost and History — and shows one section at a time, opening on General each time; Up/Down move through the list and each section opens scrolled to its top. While FlowVoice is off the dialog shows only the on switch, and switching it on brings the sections in without closing the dialog. The Settings page keeps every section stacked on one page, in the same order.
Saved recordings and the dictation History live in that same card, under History, and the CLI routes that trigger dictation are listed under For agents.
The Words to recognise card is in the same place — Settings → Voice Control, under the Dictation (FlowVoice) heading — with your own list first, then the Learn from my corrections switch and the Learned from your corrections list. Right-clicking the mic button in a session's message box opens the same card over the session, and searching Settings for "learned words" finds it.
Where to configure it
Progressive disclosure: only the master Enable FlowVoice toggle is visible until it is on; the card then shows Microphone / Accessibility / Automation status pills (and a Server pill as well on the hosted engine — it reports the hosted service, so it is absent when you dictate on Gemini or the cloud engine) with a Recheck action, the one dictation hotkey recorder, the speech engine picker (Gemini, hosted, the company's cloud speech, or Fluid Speech Mini on your own computer), language, microphone picker, the Sound cues / Mute other sounds while dictating (macOS and Windows only) / Send automatically / Show floating pill toggles, and the history list. macOS requires Microphone, Accessibility and Automation. Accessibility covers the hold-to-talk global hotkey and the synthetic keystroke; Automation (System Settings -> Privacy & Security -> Automation) is what lets Omniscio drive System Events to perform the paste, and it needs the com.apple.security.automation.apple-events entitlement in the packaged build before macOS will even offer it. Naming only Accessibility is a known trap: the toggle-mode hotkey is an Electron globalShortcut that needs NO grant at all, so dictation can appear to work perfectly while the cross-app paste is dead. Granting cannot be automated, so the card deep-links to the System Settings pane. The Automation pill is OBSERVED rather than polled, because no read of that grant is free of a consent prompt: it stays neutral until the first dictation, turns green once an Apple event goes through, and turns red only when macOS refuses one for lack of consent — which also shows a hint naming the System Settings path and noting that dictating into Omniscio itself keeps working without it (noteAppleEventOutcome in permissions.ts). When a paste into another app fails, the message names only the permission that is actually missing: it checks Accessibility right then, so with Accessibility off it names Accessibility alone (and says to remove Omniscio from the list and add it back if the switch already looks on, because an app update can leave a stale switch), with Accessibility on it names Automation alone, and it names both only when both are missing or the check cannot answer (missingMacPasteGrant in permissions.ts). On macOS the Microphone pill is observed too, once a dictation has run: macOS answers the app's own microphone check once per launch, so a grant you give at the first dictation's prompt never showed and the pill stayed missing while every dictation recorded (seen 2026-10-12). Now a dictation that opens the mic turns it green for the rest of the session, and a dictation macOS refuses turns it red (noteMicrophoneCaptureOutcome in permissions.ts). Windows/Linux need no explicit grants (permissions.ts).
Your microphone stays found when its ID changes. The microphone picker saves the browser's ID for the device, and that ID can change with nothing unplugged — Windows re-registering the device, or the app's pages loading from a different address (the development server versus the built app). FlowVoice therefore also remembers each microphone's NAME, in the same memory the screen recorder uses (screenRecorderDeviceNames), and every dictation start carries that memory to the recorder. When the saved ID is no longer listed, the recorder opens the one listed microphone with the remembered name, with no notice, and FlowVoice saves its new ID so the picker shows it again. Only when no listed microphone carries the name — or two different devices do — does the dictation fall back to the default microphone with the "Your chosen microphone couldn't be opened" notice. Names are remembered when you pick a microphone and whenever a dictation opens one; a default microphone standing in is never remembered as your choice. Contract: screen-recorder-live-camera-and-mic-contract.md a-saved-device-is-found-again-by-its-name.
How it behaves
Hotkeys (one key, hold or toggle)
The card offers one dictation hotkey plus a Hold/Toggle choice, never two recorder fields. Settings store it as two slots (hotkeyHold + hotkeyToggle in src/shared/flowvoice/types.ts) and hotkey-mode.ts maps the one selection onto them so exactly ONE slot is ever bound — the other is '':
- Hold to talk: default
Control+Meta— hold Ctrl+Windows (Ctrl+Cmd on macOS). It replacedCommandOrControl+Shift+D, which also fires Chrome/Edge/Firefox "bookmark all tabs" and VS Code's Run view, and the key hook only OBSERVES keystrokes, so both fired. Either order works: the hold starts when the second of the two keys goes down, so Ctrl then Win and Win then Ctrl both start it (until 2026-10-21 only Ctrl-first did — a Ctrl that completed the chord after Win was ignored, so pressing Win first never dictated). Releasing either key ends the dictation. Ctrl+Windows is a live Windows chord: the OS desktop shortcuts (Ctrl+Win+Left/Right, Ctrl+Win+D) start a hold as well. Nothing is typed from one — a recording that catches no speech is retained and the phase returns to idle without a paste (MIN_RECOVERABLE_MSincontroller.ts). Bound via uiohook-napi (keydown starts, keyup stops), the only way to drive press-and-hold; a bare held modifier (e.g. Right Cmd, stored askey:NNNNN) or a modifier-only combo is valid in this slot only — the Toggle slot cannot bind one, and the settings card warns when you try. A quick tap is still safe: a key-up that races ahead of the async start is remembered and stops the capture as soon as it begins (controller.ts). - Toggle on / off: unbound by default. Bound via Electron
globalShortcut(press flips recording on/off); it refuses bare modifiers and combos already taken by another Omniscio shortcut, and the settings card warns when a bare modifier is recorded into this slot.
Both are rebindable in-card via the click-to-capture HotkeyRecorder. A slot the app could not bind says so under the recorder — which shortcut, and why (another app already uses it, the key is one you type normally, the keyboard hook has not started yet) — instead of leaving a shortcut on screen that never fires; the reason travels in the runtime state as hotkeyBindError. Because both are global, neither can be a key you type normally — a letter, digit, Space, Backspace, an arrow, punctuation, or one of those with only Shift: the recorder refuses it and asks you to add Ctrl, Alt or the Windows/Command key (a function key, or modifiers alone, are fine), the settings route refuses to save one, and a value an older version saved is simply not bound. The recorder also stops listening the moment you click or tab away, so a key typed in another field is never captured.
The macOS fn / Globe key cannot be used as the dictation hotkey. It is unsupported at all three layers independently — Chromium fires no keyboard event for it (so the recorder cannot even see the press), uiohook-napi's key table has no fn entry (Hold mode cannot match it), and Electron accelerators have none (Toggle mode cannot register it). The recorder used to sit on "Listening…" forever with no explanation; it now says the key did not reach the app and names fn as an example, and says the same for any key that arrives but maps to no bindable accelerator (a media key, F25+). Pick a normal key or combination instead.
When another dictation app is running
A second dictation tool on the same computer hears the same keypress you do, transcribes it too, and pastes it too — so one sentence lands twice and your speech goes to a service you never chose. Because FlowVoice ships on, it now checks for that: if a known dictation app is running (Wispr Flow, superwhisper, Dragon, MacWhisper, VoiceInk and friends) and you have never turned FlowVoice on or off yourself, dictation stays paused — no hotkey bound, no floating pill — and one card in the inbox says why. The card's button opens the master toggle, and turning FlowVoice on there is your answer: it arms dictation and clears the card, and from then on your choice is the only thing that decides.
The check is re-run while Omniscio is open (every five minutes, and again when the computer wakes or you unlock it), so a dictation app you launch later is caught as well — never in the middle of a dictation, which would cut a recording short. A check that cannot read the process list reads as "no other app": a failed probe can never silence your dictation. The pause lives only in memory and is never written to your settings file.
Mute other sounds while dictating (macOS and Windows)
An opt-in switch, off by default (muteOutputWhileDictating in FlowVoiceSettings). When it is on, a dictation silences the computer's sound output so music or a video does not bleed into the microphone, and the end of the dictation puts the sound back exactly as it was. Contract: flowvoice-mute-while-dictating-contract.md.
- What it changes. Only the system output mute, never the volume and never a media play/pause key (that key is a toggle and can start music instead of stopping it).
- Already muted stays muted. FlowVoice reads the mute state first and only ever undoes a mute it made itself.
- The chimes are still heard. The start chime plays first and the mute lands about 0.4 s later (
START_CHIME_MS); at the stop the sound comes back first and the stop chime plays right after, so stopping never waits on the unmute. - Every ending restores. Stop, cancel, an error, an abandoned start (the last dictation ending) and quitting the app (bounded to 3 s in the
flowvoice disposeshutdown step) all put the sound back. - A crash never leaves the computer muted. A small
flowvoice-output-mute.jsonmarker is written to the app's data folder before the mute and deleted only after a successful unmute; on the next launch a marker still there is unmuted and cleared. - A failure never blocks a dictation. If the state cannot be read, the marker cannot be written or the mute fails, nothing is muted and the dictation carries on; every failure is logged with the dictation it belongs to.
- How. macOS uses
osascript(output muted of (get volume settings),set volume with/without output muted); Windows uses Core AudioIAudioEndpointVolumeGetMute/SetMuteon the default output device through an encoded PowerShell command. Both run without a shell (output-mute-routes.ts); the lifecycle isoutput-mute.ts. The Windows route is covered by tests at the command boundary and has not yet been checked on real Windows hardware. - Other platforms. The switch is hidden and nothing runs.
How dictation works (pipeline)
Hotkey down: remember the frontmost app, then a hidden recorder-host window captures the mic and streams audio live to the FlowVoice /stream WebSocket. Hotkey up: the mic is held live until it has heard you stop — the stop tail, whose ceiling is CAPTURE_TAIL_MS (1000 ms) and whose floor is TAIL_QUIET_MIN_MS (250 ms). A key-up lands on the last syllable, so the mic stays up while that syllable is still arriving and closes as soon as your captured audio shows it has gone quiet, never before 250 ms and never past the second. The tail reads its own 125 ms window against its own 200 RMS quiet bar — SILENT_CAPTURE_LOUDEST_RMS (100, the no-text measure) is deliberately NOT the tail's bar, and the engine-side flush exit keeps it. The 250 ms floor is the measured p95 of "the last speaking-level window ends this far past the release" (180 ms) plus one microphone batch (64 ms), which is what stops a cut landing across audio still in flight after a pause; only trailing room tone is ever dropped, so the last word is never clipped. The same change also gave the tail back at least 150 ms on every press (400 → 250) by asking the shared worklet for 1024-sample batches (64 ms) where it used to get 4096 (256 ms), so the deciding audio reaches the meter up to 192 ms sooner — every other microphone user keeps 4096, because their frame budgets are counted in frames. The stop-to-paste number stops at the instant the paste is SENT, not after the 150 ms paste-settle that follows it: it measures when the text appears.
A noisy room no longer costs the whole second either: on the cloud engine the tail ALSO ends when the last quarter second of arrived audio held no sustained voice (two 125 ms windows at 400 RMS, never before 450 ms). The words are delivered at that point, and the microphone keeps running to the unchanged second so the audio arriving after the cut is transcribed again from the kept recording and appended into the same paste — but only where that dictation's own text landed: if the text was pasted at another app's cursor (you switched away while it transcribed), or the window it went to is no longer in front (Omniscio having lost focus counts for a dictation that began there), the recovered words are typed nowhere and the pill says they are saved in your dictation history. Measured across 591 kept recordings, that takes the tail's p95 from 1000 ms to 450 ms and asks the repair to run on 3.4 % of dictations. The early close applies only to an engine that can repair what it cut; every other engine keeps the quiet-only rule.
A repair’s second reading is stitched in by word order, from the transcript’s own ending only. The recovered audio is read again, so the second reading usually re-covers a stretch the transcript already holds and then goes on — and two readings of one stretch never agree word for word (measured: “I want it to all be” against “I wanted to all be”). The overlap is therefore matched by word ORDER rather than exact wording, so a substitution does not paste the same words twice. Two limits keep that from eating new speech: the match is taken only from the transcript’s OWN ENDING (as many words as the reading has, plus the one word a reading may add), and only when it starts at the reading’s first word. Anything else is treated as new speech and appended whole, because ordinary words (“the”, “and”, “I”) pair up by chance across a long dictation, and a chance anchor that swallowed a reading would lose the very words the repair exists to recover — silently, since the dictation would no longer look incomplete.
Then the stream finishes. On the Gemini engine that means telling Gemini the audio has ended and waiting up to 3 seconds for its last words (it moves on about a tenth of a second after they arrive, so a normal stop is not slowed; a stop made right after the engine ended a turn of its own does not wait out the full 3 seconds either — the provider reads your own captured audio and moves on when it shows you had already stopped, .claude/memory/flowvoice-runtime-details.md the-engine-gets-time-for-the-last-word). A dictation that looks truncated is held past those 3 seconds, up to 8 — and only one that looks truncated: rare presses where the engine had finalized nothing, an in-progress read was still standing, and that read carried fewer than 8 characters for every second you held the key (your own complete dictations measure 10-21, the press this exists for 6.8). A final ends the hold the instant it lands; if none arrives the wait ends at the 8-second cap and the dictation is treated as possibly incomplete — the recording is kept and one click re-transcribes it. Every other dictation waits exactly 3 seconds.
The text the engine returned is pasted at the focused app's cursor via the clipboard-paste path (a constant Cmd/Ctrl+V; the transcript is never interpolated into an osascript/PowerShell string; max 5,000 characters per paste, and a longer dictation is pasted in pieces — see inject.ts). What you had copied before comes back afterwards: the clipboard is borrowed for the paste and put back about three seconds later, and a dictation pasted in pieces is written back whole to make that paste work, then restored the same way. The copy is taken the moment you let go of the key, and the paste waits at most 0.6 seconds for it. Four cases deliberately leave the dictation there instead: the paste FAILED (so Ctrl/Cmd+V still gives you the words); you copied a password or anything else your password manager marked as concealed (those copies are meant to disappear on their own); you copied something new yourself in the meantime (yours wins); and the clipboard was so slow to read that the wait ran out. When it really cannot put your copy back — the clipboard was too slow to read in time, or what you had copied was a file rather than text, formatting or an image — it tells you so once instead of quietly leaving the dictation there, with no mention of what you had copied. Either way the dictation is always in your dictation history. The paste never leaves the transcript in clipboard history: the copy is marked do-not-record, the signal a password manager sets on a copied secret, so Windows clipboard history and cloud clipboard sync, the macOS pasteboard managers and Klipper all skip it — dictated words do not travel to any clipboard service on your account. Transcription streams live, and every captured frame is ALSO written to a file on disk as it arrives, so a failed stream is recovered from that saved audio instead of being lost (see When transcription fails below). That saved audio and its note are encrypted at rest with the same machine-bound key the app uses for saved credentials, so a profile folder copied to another machine or account discloses neither the speech nor the words.
When Omniscio itself is frontmost the text lands in Omniscio's focused composer (session or Team Chat, whichever is active) through the clipboard too: it is written to the clipboard and pasted by the app's own Paste command (pasteIntoWebContents, no PowerShell/osascript hop). The trade is that a paste replaces whatever is selected in the composer. Send automatically (autoSubmitInAmc, default OFF) submits it through Omniscio's real send path (honoring submit-key mode, and the after-sending setting — which, in a project view, keeps you on a session that was not waiting on you, so dictating into a running session never moves you off it), never an OS-level keystroke. Left off, a dictation into the message box waits there for you to read it and press Enter — and only when the text actually landed in a session's message box: dictating into the search box or a notes editor pastes there and sends nothing, and a dictation that finishes after you switched to another app is pasted at that app's cursor, unsent. The same holds the other way round: a dictation that began in another app and finishes while you are in Omniscio lands in Omniscio's focused message box through the in-app paste (no macOS permission needed) and follows Send automatically like any Omniscio dictation — unless a newer dictation has started meanwhile, which is never sent for you. FlowVoice never brings back the app a dictation began in: until 2026-10-19 macOS re-activated it before pasting, so a user who started dictating in Safari and switched to Omniscio to send was pulled back to Safari, where the paste then failed (deliver-transcript.test.ts, dictation-paste-target.test.ts). Which app is frontmost is read via lsappinfo (LaunchServices), which needs no macOS permission — deliberately, because that answer decides WHERE the text goes. Omniscio recognises its own window under every name it can be reported as — the bundle display name Omniscio, the lowercase app.getName() value omniscio, and Electron in dev — compared case-insensitively (isSelfAppName in context.ts). Those names differ by one capital letter, and matching only app.getName() once classified every in-app dictation as another app — so it took the osascript paste macOS refused without Automation consent instead of the permission-free in-app one. If the frontmost app genuinely cannot be identified, the target is unknown, which is NOT treated as "Omniscio": the transcript is pasted at the OS cursor and never auto-submitted — that distinction once collapsed, and every dictation was pasted into the composer and auto-sent while the user was typing in another app entirely. The FlowVoice server URL + token are resolved AT RUNTIME (config.ts, cloud-credential.ts), and only while the hosted engine is selected: a signed-in fetch held in memory and re-fetched on a short TTL, renewed ten minutes before it expires and whenever the computer wakes or unlocks, so the first press after a long break does not wait for a new one. Nothing is baked into a shipped build — the release guard fails a build that carries a real credential. Env vars AMC_FLOWVOICE_API_URL/_TOKEN (or a gitignored dev credentials file) cover npm run dev and self-hosting. A self-hoster must also set AMC_FLOWVOICE_USD_PER_MIN to their own server's real per-minute GPU + model rate (dictation/cost.ts reads it): the built-in $0.10/min is a deliberately conservative placeholder, so without it the FlowVoice daily spend cap meters against fictional dollars and trips at a point unrelated to what the backend actually costs. Setting it to 0 is honoured literally — dictation then meters at zero cost and never trips the daily spend cap — while a negative, blank or unreadable value falls back to the built-in rate. Either way a default user configures no API keys.
Smart spacing and capitals. Just before the paste, FlowVoice reads at most the two characters immediately before the cursor in the field it is about to paste into, and adjusts only the edges of the dictation: it adds one leading space when the character before the cursor is a letter, a digit, or sentence, clause or closing punctuation (including a comma, a semicolon and a colon), and it capitalises the first letter when the field is empty there, or the text before it ends a sentence (., !, ?) or a line. Nothing is ever lower-cased and nothing inside the dictation changes. The read is Windows-only, is refused in a password field, and has a hard 30 ms budget — if it times out, cannot be read, or the field offers no text, the transcript is pasted exactly as it was produced. The characters it reads are never logged.
With no text box under the cursor, nothing is pasted or sent: the words stay on the clipboard and the pill says so (Where the text goes if you move on).
If a key is left down. The synthetic Ctrl+V is sent as one batch and then checked. On the rare press where the chord stopped short and its recovery key-up never reached the system — a busy machine, or an app that outranks Omniscio in the input queue — you get one notice saying a key may be stuck and which key to press and release: Ctrl alone, or Ctrl and V when the chord stopped before V came up (paste-stuck-keys.ts). The notice never claims the paste landed, because on some of those paths it did not. That is the only thing that happens: nothing sends a key-up of its own after a normal paste, because you may be holding Ctrl deliberately. The same notice covers the clipboard picker, Instant Fix and the clipboard feature's own Ctrl+C capture, whichever road left the key down.
A dictation is delivered whole — or its audio is kept, never both lost
Three promises: the first two were added 2026-09-30 after a 53-second dictation delivered 285 characters and its audio was then deleted as a success, and the third on 2026-10-12 after the owner reported his last words being cut off and the audio showed the engine had simply stopped reading.
What the engine heard is delivered, even when it never finalized it. Speech engines stream a dictation on two channels: the committed text, and the in-progress read of the sentence still being spoken. The in-progress channel is not a preview — measured against Google's Gemini Live model, a dictation's last sentences can exist ONLY there, with the committed text stopping mid-thought. FlowVoice now takes whatever the in-progress channel carries that the committed text does not, so the words arrive instead of being dropped. Nothing is ever repeated: text the committed channel already delivered is recognised and skipped — including a last word the two channels heard differently, so a dictation ending "log into Canva." arrives with that word once rather than as "Canva. Canvas." (Fixed 2026-10-16.)
A transcript that cannot match its audio keeps that audio. Once a dictation's text is safely in history the recording is normally deleted — it has done its job. But text far too short for the audio it came from is not a success worth being certain about, so the recording is kept instead and appears under Saved recordings as Transcription may be incomplete — retry for the rest, with the same Transcribe again action as any other kept recording. Ordinary dictation is unaffected, twice over: only dictations of twenty seconds or more are judged at all (a nine-second sentence is too brief for the rate to mean anything), and every long dictation on record reads 15–21 characters per second of capture against an incident reading of 5.3. A long recording that was mostly silence is not judged either — a dictation held for a minute while only a few seconds were spoken has a short transcript for an honest reason, so it is only judged once at least half of it was speech. That half is measured from the recording's own audio and against the recording itself rather than a fixed level, so the same dictation gives the same answer on a quiet microphone as on a loud one; an engine whose audio the app does not measure falls back to judging on length alone. And when the engine itself says it stopped reading — see the third promise below — that is a fact rather than a rate, so it opens this notice on its own, ahead of the twenty-second and half-speech thresholds. It has to: one of the owner's own lost dictations read 11.1 characters per second, comfortably ABOVE the floor, so no rate this check compares against could ever have caught it. (Added 2026-10-12.)
A dictation is read again from its own audio when the engine stops reading it part-way. Gemini can decide a turn has ended while you are still speaking, and after that it transcribes nothing further — the words after that point are never read, and only a little of what you said arrives. Measured on real dictations: one lost about 5.5 seconds of speech out of 22.5, another about 4. Waiting does not help, because the engine is not slow, it has stopped. Your audio, though, is on disk from the very first frame, so FlowVoice notices the silence while you are still talking and reads that stretch again from the recording; anything still missing is recovered the same way once you let go. The words are then joined on with nothing repeated — what the first pass already delivered is recognised and skipped. (Added 2026-10-12.)
If a dictation ever comes back looking short, the pill says so — "Some of that dictation may be missing — your recording is saved. Click to transcribe it again." — and clicking it re-transcribes that recording rather than starting a new one.
There is no cleanup wait any more
There used to be a whole pipeline here to keep the post-speech wait from growing with how long you talked: a chunker that cut the transcript at sentence boundaries, background LLM calls while you kept speaking, a bounded-concurrency gate, and an 8-second deadline after you stopped. All of it is gone with the pass it served. On the Gemini path nothing runs after the engine hands back its transcript, so the wait between letting go of the key and seeing your words is the engine's flush and nothing else.
Delivery is unchanged in shape: ONE complete block at the cursor, never partial text and never text that visibly rewrites itself.
Where the text goes if you move on, or something new pops up
Each dictation is delivered by the app it began in, fixed at the moment you pressed the hotkey. Pressing the hotkey again to start another dictation never redirects one that is still being transcribed. Earlier builds could: a dictation begun in Notepad was pasted into Omniscio's message box — and sent, if Send automatically was on — the moment you started another one inside Omniscio.
If you switch to a different app that was already open while the dictation is being transcribed, the words are pasted there, as before. If a window from a program that was not running when you pressed the key takes over the screen instead — a console, an installer, a pop-up from an app you just launched — the dictation is not pasted into it, whichever app you were dictating into. It stays on your clipboard and in your dictation history, and the pill says it could not paste. (Earlier builds guarded only a dictation begun in Omniscio.) If you started another dictation meanwhile, the older one's words wait the same way, but only the newest dictation shows the pill.
Inside Omniscio, the words arrive even while the app is busy. When you dictate into an Omniscio window, the words are typed straight into the box you are in by the dictation process itself, so they no longer wait for the rest of the app when it is busy with your agents. Your clipboard is left alone on this path, and the words still appear in clipboard history and in your dictation history. If that window cannot take them — no text box has the cursor, the cursor is in an embedded page, or Send automatically is on — the words are pasted the usual way below. (Added 2026-11-09.)
Inside Omniscio, the words are pasted only where they can land. If nothing that takes text has the cursor when the words are ready (you clicked a session in the list, the transcript, a button, or a page with no text box), the dictation is not pasted into nothing: it stays on your clipboard and in your dictation history, the pill says "Couldn't paste your dictation — it's on your clipboard and in your history.", nothing is sent, and Ctrl+V puts it wherever you want it. A text box inside an embedded page, such as Supermail or the in-app browser, works as before. Earlier builds reported such a dictation as pasted while it went nowhere, then put what you had copied before back over it. (Added 2026-10-16.)
What it cannot tell: a dialog opened by a program that was already running looks like any other window of that program, so it can still receive the words. This is Windows behaviour; on macOS FlowVoice still names only the application.
Two dictations at once, and Cancel
You can start the next dictation while the last one is still being finished and pasted. Each dictation is delivered to the window it began in — one you started in your editor lands in the editor even if you pressed again from Omniscio while it was still working — and the floating pill follows only the newest one. (Previously the app kept a single "where am I dictating" record that the next press overwrote, so the earlier text could be pasted, or auto-sent, into the wrong place.)
- Pressing again. A press while the previous key is still held is ignored, so a double tap never leaves a second recording behind. A press after you let go, while the previous dictation is still starting up or finishing, starts its own dictation; up to three presses can be in line at once (the one starting plus two behind it), and the microphone is never opened twice at once.
- Cancel works at every stage — the pill's ✕, or
POST /flowvoice/cancel. A dictation that is still waiting on its sign-in and health checks, or opening the microphone, simply stops: the microphone is never opened and nothing is transcribed. While you are recording it discards the audio, as before. After you let go, during the last moments of capture or while the words are being produced, nothing is typed and nothing is added to history, but the recording is kept in Dictations in case you want those words back. A dictation that is already pasting has finished. With nothing to cancel, the ✕ takes down an error the pill is still showing. - When an earlier dictation could not be pasted — the paste failed, or a newer dictation had already pasted — the pill stays with the newer one, and you get a short notice as soon as nothing is recording or processing and no error is on screen: "An earlier dictation was copied, not pasted. It's on your clipboard and in your history." or "An earlier dictation wasn't pasted. It's saved in your history." Several at once make one line. A dictation you cancelled says nothing.
- Turning it off.
AMC_DISABLE_FLOWVOICE_LIFECYCLE=1puts cancel-before-the-microphone, cancel-after-you-let-go and the waiting press back to "ignored". The delivery, pill and notice fixes above are not switchable.
The floating pill
The pill is a small overlay at the bottom of the screen — a transparent always-on-top HUD (FlowVoiceHud.tsx, rendered in the flowvoice-hud.html overlay window) that appears while you dictate and on an error. It is hidden when idle by default (showIdleHud, off since 2026-10-29), and while you dictate it shows a live waveform with Cancel and Accept. Turn on Show floating pill in the FlowVoice settings — also reachable from the pill's right-click menu — to keep it on screen all the time; a choice you saved is kept across updates.
Point at the pill and it widens into a row of controls: Dictate in the middle, History and Settings beside it, and an Options button at the right edge that opens the same menu as a right-click. Clicking the pill itself starts dictation. From the instant a dictation starts until its transcript lands, the pill carries a Cancel ✕ — while it is starting, while you are recording and while it is processing — so a dictation begun by mistake never has to be waited out.
Right-click the pill, or point at it and use the Options button at the right of its hover row, to open a small menu drawn inside the pill itself:
- Keep pill on screen — a switch showing the saved setting; clicking it turns the idle pill on or off (the same setting as Show floating pill). It stays greyed out for the moment it takes to read the saved value, and if that read fails it greys out with a line beneath it saying the settings could not be read — the menu never shows a definite "off" it did not actually read. If the save is refused the row keeps its old value and the menu says the setting could not be saved, instead of closing as though it had worked.
- FlowVoice settings — brings the main window forward on the FlowVoice settings page.
The menu closes when the mouse moves off the pill, and choosing an item never starts a dictation. It is drawn inside the pill rather than as a system pop-up because a pop-up can take keyboard focus from the app you are dictating into. The pill window never takes keyboard focus, so the menu has no keyboard shortcut; the settings page carries the same switch.
It follows your theme — surfaces, accent, body font and app text size all come from the same tokens as the rest of Omniscio, like the recording and meeting HUDs (until 2026-09-15 it kept FlowVoice's own warm-dark + amber palette and its own font, so it looked like a different product parked on top of the app). The pill shows: an idle pill (hover reveals Dictate / History / Settings; clicking it starts dictation), the accent-coloured sweep the instant you press the hotkey (until the microphone is open, so a slow start never looks like a dead hotkey), a live waveform with Cancel and Accept while recording, the same sweep while processing, and an error card carrying the alert glyph, the message and a quiet ✕. Both message cards share one width — 18.25rem, hard-capped at 320px so it can never leave the 340px window — sized so a full sentence reads in two lines at 13px rather than four at 12px in a 198px box; the error card and the saving card are alike, so the two can never drift apart again; the error card wears a status-error border so it reads as a failure rather than as the neutral hover menu, and its ✕ is transparent at rest (painting only on hover/focus) so the message leads. Everything in the pill follows the app text size. Its boxes are measured in rem, so the pill, its controls, its waveform and its six glyphs grow with the Text size setting the way the rest of Omniscio does — a px box would silently stay put (the one rule the design tokens state as "rem, NEVER px"). The recording pill is 8rem by 1.75rem with 1.25rem circular controls, so the Cancel and Accept discs sit inside the capsule instead of filling it, and the pill's stylesheet owns their padding — without that, the padding carried by the shared Button primitive leaves a fixed-width button no content box at all and squeezes the Accept tick to nothing, which is exactly how a blank blue disc shipped once. Two values stay in px on purpose: the 12px gutter at the bottom of the window, which is window chrome and is also the number the renderer adds to the height it reports, and hairline borders. No control in the pill carries the app's 44px mobile tap floor. That floor comes from the shared Button and IconButton primitives, which restore the compact geometry only under md: — 768px — and this window is a fixed 340px, so md: never matched and the floor always won: the Accept check drew 24×44 as a blue oval and the Cancel ✕ 44×44, eating 68px of the 198px saving card — 44px of it the ✕ alone, the only one of the two that carries a width floor and crushing its sentence into seven wrapped lines. Every pill control passes noMobileTouchFloor, the primitives' own opt-out, exactly as the right-click menu already did. The window's height floor is 96px and its cap 360px, so every animated state fits without resizing the window frame by frame and the tallest message card at the largest text size is never clipped off its top edge. If the engine connection drops mid-dictation, the waveform is replaced by one line saying so — "Reconnecting. What you say is still being saved on this computer." while a repair is under way, or "Still saving on this computer. It will be transcribed when you stop." once this dictation is coming off its recording instead — with Cancel and Accept exactly where they were. It is a state, not an error: the pill takes no focus, nothing is announced as a failure, and the dictation keeps recording to disk throughout, so the words spoken after the drop still reach you.
The error pill and the refusals it shows
The error pill clears itself after about 8 seconds, clicking it retries, and its ✕ closes it straight away without retrying — it deliberately floats even for a hidden-pill user, because dictation is driven by a global hotkey from inside other apps, so an in-app surface would not reach you at the moment a dictation fails. (It used to have no way down at all: the pre-flight failures — signed out, no Gemini key, daily cap reached — stop before dictation starts, so "Dictation is unavailable — sign in to enable it." stayed on screen until some later dictation happened to succeed.) A fourth refusal joined them, covering both things the recorded reading can already tell us: when it says the engine is unreachable, or that the server refused our credential, the start re-probes once with a deliberately short ceiling (you are holding a key down) and refuses before the microphone opens only when that re-probe is evidence — the server answered the same way, or the connection itself was refused — so you are not left speaking a whole dictation into a session that was never going to work. A reading that says down refuses as an outage; a credential the server has turned away refuses with the sign-in copy and drops the cached credential, so the "try again" it asks for genuinely re-fetches rather than replaying the token that was just rejected. A server that has come back, a server that simply did not answer in time, and a fresh boot whose first read has not landed all still start. And when the server refuses the stream upgrade itself, that refusal's own HTTP status now picks the copy — a limit on your allowance says so and says it clears on its own (naming no time, because the server answers the same status both for a daily budget and for one that frees up in seconds), an expired dictation sign-in says so and tells you to try again to refresh it — instead of every refusal arriving as the same connection-error line. A refused sign-in drops the cached credential on every road a refusal can reach you by, including the replay behind the pill's try-again, so a retry genuinely re-fetches instead of looping on the token the server just rejected — and it says so on every one of those roads: a refusal that happens before any request is made (a dead sign-in, an engine known to be down, the daily cap, a signed-out token) now shows you its own reason instead of the generic "your recording is saved, click to try again", which used to invite exactly the retry that would fail the same way.
Sound cues
Sound cues (playSoundFeedback, default on) plays a soft chime at the recording start and stop boundaries, synthesised in the recorder-host window. The stop chime sounds on the key-up itself — not when the mic actually closes — so the confirmation never lags half a second behind the release while the stop tail (described above under How dictation works) runs. The start chime is the honest "you may speak now" signal, and it is worth waiting for: the mic cannot open instantly (opening the OS capture device measured 49-196 ms on a dev box, occasionally seconds), and the chime is only dispatched once capture is genuinely live. Words spoken before it are not clipped or buffered — there is no audio yet, so they never existed.
"Genuinely live" means the first audio FRAME, not the device reporting open — and until 2026-10-12 those were a quarter of a second apart. The recorder host reports the capture device open the instant it is attached, and the chime went out on that report; but the PCM worklet that feeds the Gemini engine accumulates a whole batch before it posts anything, which was 4096 samples (256 ms at 16 kHz) until it was shortened to 1024 (64 ms), so on every press the sound landed ahead of the first audio it was announcing. The owner heard exactly that and said so: "It makes a sound before the microphone is live." FlowVoice's own capture graph now asks that worklet for one short first batch (512 samples, ~32 ms), and the cue is armed at the start line and fired on that first frame, so it cannot precede the audio by construction. The nine other users of the same worklet — wake word, voice commands, meetings, mobile walk, quick launch — pass no first-batch size and keep the 4096-sample batching they always had. The batch width is a per-caller option too (processorOptions.batchSamples), and only FlowVoice's dictation capture asks for a narrower one (1024 samples = 64 ms) — the others' rate budgets are counted in frames, so handing them a narrower batch would rate-limit their audio. Every dictation logs the pairing on one line, [flowvoice] delivery cueToFirstFrameMs=… firstFrameAfterAttachMs=… streamChars=… pastedChars=… pasteChunks=…, where the first number shows the cue sitting with the audio rather than ahead of it and the last three are what separate "the engine never produced the words" from "the words were lost on the way to the cursor". After a dictation the microphone stays open for 30 seconds, so a second dictation in that window starts with no device-open wait at all (the system's microphone-in-use light stays on for those 30 seconds). Everything that does NOT need the microphone is already built ahead of the press (flowvoice.contract.md nothing-sits-ahead-of-the-microphone), so that wait is the device open and nothing else; startDictation logs the measured gap ([flowvoice] mic live Nms after start) on every dictation.
The composer mic button
The session composer, the council panel, and the Team Chat composer each get a FlowVoice mic button in their left tool zone (FlowVoiceMicButton.tsx): click to start, click again to stop, a small pulsing red dot while recording; right-click — or the Menu key / Shift+F10 on the focused button — opens the FlowVoice settings in a dialog over the composer, and there is no separate settings button beside the mic because the microphone itself carries that route — you tune dictation where you are, never bounced out of the session to the Settings page (flowvoice.contract.md settings-open-where-the-user-is) — and the tooltip shows both configured hotkeys. The dialog hosts the same settings card the Settings page shows, imported rather than forked — arranged as a sidebar of sections there and stacked on the Settings page, both drawn from one section list — and it is a SIBLING of the button rather than nested inside it, so switching FlowVoice off from within the card hides the button without slamming the dialog shut. It focuses its own composer textarea on every press — start and stop — so the OS-level paste at stop has a guaranteed sink. Both presses need it: delivery is a paste, which lands wherever focus is, so pressing the mic before clicking the text box — or clicking away mid-recording — sent the transcript to the wrong place, or nowhere. The button sits inside one composer and a press on it means "put the words here", so both presses take focus back there (within the app's focused window — a press cannot drag OS window focus back from another app, and the OS-wide hotkey path never routes through the button). The button self-hides when FlowVoice is disabled or on mobile (FlowVoice is desktop-only), and the Show mic button in the message box toggle (showComposerMicButton, default on) hides it for a user who drives dictation from the hotkeys — dictation stays live, only the button goes. That opt-out hides the IDLE button only — a live dictation shows it, since the button carries the recording dot (flowvoice.contract.md a-live-dictation-outranks-the-mic-opt-out). Together with showIdleHud that means every always-visible FlowVoice affordance can be dismissed WITHOUT turning the feature off (flowvoice.contract.md every-visible-affordance-has-its-own-opt-out); both are presentation-only and are read at the RENDER site, never on a start/stop path. Visibility reaches the button by being mirrored into FlowVoiceState and fed to the renderer's flowvoice-store by one app-level FLOWVOICE_STATE_CHANGED listener — there is one button per keep-alive SessionPanel, so none of them subscribe individually.
When the app you are dictating into is running as administrator
Windows refuses to let one program type into a window that belongs to a higher-privilege process (a protection called UIPI). A paste into an app you launched with Run as administrator is therefore refused by the operating system, and the app on the receiving end never sees a keystroke. Omniscio detects that before it presses paste and tells you plainly: the dictation is on your clipboard, so press Ctrl+V in that window to put it where you want it. Nothing is lost — the words are also in the dictation history — and an app Omniscio cannot measure is never blamed for it.
If a paste is interrupted, the keyboard keeps working
A paste on Windows presses Ctrl and V, and a paste that is cut off part-way could otherwise leave Ctrl held down — which on a keyboard reads as typing having stopped everywhere, because every letter becomes a Ctrl shortcut instead of a letter. So whenever a paste does not finish, Omniscio gives both keys back before it reports that the paste failed, by whichever route the machine allows: the direct one, or a short PowerShell script when the direct one cannot load on that PC. Your keyboard is never left in a state you have to fix by hand. (Added 2026-10-30.)
Where the dictation runs, and how to switch it off
With the cloud engine selected, a dictation now runs in its own small background process — the dictation core — instead of inside the app. That matters on a busy computer: when the app freezes for 9-12 seconds (an export, a sync, a large file read), an in-app dictation loses its engine connection and its text has to be replayed from the recording, which made some stops take up to 8.8 seconds; one in the core keeps every byte and the full text through the same freeze. Measured under a virtual display with the real recorder window and a stand-in router: a 12-second freeze dropped the in-app session and left the core's complete, and the two start equally fast (microphone live in about 2 ms of median press-to-live time on both).
There is nothing to set up. The core starts when dictation is enabled with the cloud engine chosen, and the other engines (Gemini, hosted, on this computer) stay in the app for now.
The finished words never wait on the window read. The release that carries a transcript back from the core is what becomes the paste, so it is forwarded the moment the core answers it: the frontmost-app labels that ride on it are only the history row's app name and window title, and a read that has still not answered by then is given CORE_LABELS_AT_STOP_MS (150 ms) and no more. When it does not answer in that time the words go through with an unlabelled row rather than late, which costs a history label and nothing else. That wait used to be a full second, on the one road every cloud dictation's text travels.
It can never break a dictation. If the core's program file is missing, the core will not start, it keeps dying, or it refuses a start before it has bound anything, that dictation runs in the app instead and exactly one line is logged saying why — "the entry file is missing: … — dictation runs in the app", "AMC_DISABLE_FLOWVOICE_CORE=1 is set", and so on. The same happens when the core asks the recorder window for the microphone and nothing answers within 3 s — an app that booted beside an older recorder page which does not understand the request — or the core dies before any audio was bound: the dictation is re-run in the app and the line names the cause (window-silent for a window that never answered, core-silent for a core that never opened the session). Once the microphone has actually been bound to the core the dictation is never re-run (that would record it twice); it fails plainly instead, and the recording on disk is kept for "Transcribe again". The swap is never silent any more: a dictation that ran in the app because the core was unavailable or refused the start also raises one inbox card ("Dictation switched to the built-in engine"), once per cause rather than once per press, and the log line is written again after a reset instead of only the first time in the run. The wait for the core is bounded too — if it has not reported itself ready within 6 s, that dictation goes to the app rather than leaving the pill on "starting" — and a cancel pressed during that wait ends the dictation at once instead of queueing behind the start. A message from the core the app cannot read is never silently dropped: the dictation it belongs to ends with the ordinary error instead of waiting on a reply that will never come, and the core is restarted so the next press starts a fresh process rather than sending commands to one this version cannot talk to. One log line names it, with the decoder's own detail.
To turn the core off entirely: AMC_DISABLE_FLOWVOICE_CORE=1. Every dictation then runs in the app, exactly as before this change.
Which road a dictation took is on its timing line. Each dictation still logs one [flowvoice] stop-to-paste <N>ms outcome=<x> line, and it now carries releaseToEndOfAudio, endOfAudioToLastFinal, finalToPaste, chosenRoad=core|in-app and fallbackCause=<token|none> — real numbers on the cloud engine (they used to read none there), so a slow stop can be split between the app, the relay and the engine instead of guessed at. The fallback cause is always one token from a closed set — switched-off, entry-missing, spawn-failed, crash-loop, shutting-down, or start-refused for a start the core refused — so the reasons can be counted. The words a refusal gave stay on the log line that names it, never in the field.
If dictation does not start
When dictation is switched on but its runtime fails to come up at launch, you get a card in the inbox saying "Dictation did not start" — the hotkey would otherwise just do nothing for the rest of the session, with no sign why. The card carries a Restart now button that relaunches Omniscio for you, which is the remedy its copy describes; it clears itself the next time dictation starts normally. Its type (flowvoice-dictation-start-failed) is a delivered alert, unlike the generic "Startup task failed" type, which ships muted because it covers the app's own background jobs rather than a feature you use.
A start that cannot get going gives up and says so. Everything before the microphone opens — waiting for the previous dictation to finish arming, and resolving the engine session — is bounded at 5 s (START_BEFORE_MIC_BUDGET_MS in dictation/start.ts), so the pill can never sit on "starting" with no error and no way out: the start ends with the ordinary "Dictation timed out. Please try again." error and the dictation is retired.
There is no cleanup level any more — there is one, and it is Light (see The AI tidy-up): on the Gemini engine the speech model strips fillers and false starts itself. The picker was removed rather than left showing a single option. On the cloud and hosted engines a separate switch, Tidy dictation with AI (aiCleanup, on by default), removes fillers and stray repeated words before the text is typed; it shows only for English, and the card says plainly that your dictated words are sent to an AI model. Pick another language and the card says the switch is English-only in words instead of silently going quiet, and the runtime says the same once in its log for each language it skips. Language is selectable (10 choices, default English) and the microphone is pickable (microphoneId, default system default).
Speech engine — cloud (default), Gemini, hosted or on this computer
sttEngine (src/shared/flowvoice/types.ts, default cloud) chooses which engine transcribes dictation. The picker is in the FlowVoice card for every user; it is no longer behind an in-development flag. Every read honours a saved engine — a read never rewrites what you chose, so going back to hosted sticks. An install that has never saved an engine simply follows the shipped default, and nothing is written for it: the default was Gemini until 2026-10-16 and is cloud speech since, so such an install moved with it, while an engine you picked yourself is never replaced.
An install that had hosted saved was moved to Gemini ONCE. Older builds wrote the whole settings object on every save, so enabling FlowVoice was enough to store "sttEngine": "hosted" — the default then — even though the picker was behind a Lab flag and most of those users never saw it. On the first start after this shipped, any install with hosted on disk was switched to Gemini in a single write that also records that the move happened. That is a one-time move, not a rule: if you then pick hosted again in the card, it stays — the marker is what stops the move from running twice. Installs that never had an engine stored are not stamped with one. Dictation after the move draws your own company-AI allowance instead of the shared credential, which is the point of the decision.
You are told about it, once. A moved install gets a single inbox card — "Your dictation moved to Gemini" — with a Switch back to hosted button that puts the engine back. Dismissing it means keep Gemini, and it does not come back. If dictation is off the card waits — owed and unspent until you turn it on.
gemini(selectable, not the default; it was the default until 2026-10-16): Google Gemini 3.5 Transcribe Live, reusing the sameGeminiLiveSttProvideras the in-app mic (src/main/services/voice/stt-providers/gemini.ts) wrapped in a StreamSession adapter (flowvoice/gemini-stream.ts). Which credential it runs on is decided per dictation (flowvoice/gemini-credential-resolution.ts):- You have your own Gemini key → the socket goes DIRECT to Google on your key, billed to you under
stt-gemini, and it respects the shared per-install STT daily cap (sttDailyCapUSD, $5 default). Your key always wins; the company path never overrides it. - You do not → the socket goes to our own gateway relay (Omniscio's
/v1/stt/geminiroute), which holds the company Gemini key server-side and proxies to Google. You must be signed in, because the relay bills that dictation to your identity against the company's caps. The company key is never sent to your machine in any form. - Neither → dictation refuses with the message that fits: signed out ("Sign in to use Gemini dictation without your own key — or add your Gemini API key in Settings → Accounts → Gemini"), or no key.
- You have your own Gemini key → the socket goes DIRECT to Google on your key, billed to you under
hosted(selectable, not the default): the first-party hosted/streamservice — streaming STT on the company's own server, which streams your audio on to Deepgram (a company key; the picker note and the privacy statement say so), with no cleanup of its own (the optional AI tidy-up below may run after it), company-funded (metered under theflowvoicecost source atFLOWVOICE_USD_PER_MIN). The service's source lives in this repo atflowvoice-server/, and a change to it reaches production only when the deploy workflow (.github/workflows/flowvoice-backend-deploy.yml) is started by hand (workflow_dispatchfrom Omnisciomaster); nothing else starts it, and it used to live in its own repository. It runs on a shared company credential — and since 2026-10-05 that credential is minted for paid plans only: a Free-tier account is refused one (hosted-requires-paid), because a shared credential with no per-user cap is what the hosted engine used to hand every signed-in user. The picker still SHOWS the hosted option to a Free user, labelled as a paid-plan engine, with the two ways forward (switch to Gemini, which is free, or see plans) — a plan they cannot see is a plan they cannot buy. The app never switches engines for them: the engine decides where their audio goes, so that call is theirs.cloud(the default; the picker calls it "cloud speech"): the company's own speech router on the gateway (Omniscio's/v1/stt/streamroute,flowvoice/cloud-router-stream.ts). Your audio goes through the company's cloud to its speech provider — currently Soniox — and the provider can change without an app update, because the router, not the app, chooses it; the picker says so in plain words beside the option. If that provider refuses the stream or fails before any words come back, the router continues the same dictation on the next engine — currently Inworld, then Meta Muse Voice Transcribe, and Deepgram as a further step only where it is configured — instead of losing it, and you see an ordinary dictation either way. You must be signed in. No key of yours is in the path and none of the company's ever reaches your machine. It draws on the same monthly dictation allowance as the other engines, and the gateway bills it (the desktop writes no local row). A dead connection is never silent: if the router stops answering for about two and a half seconds the pill says "Reconnecting" within three and keeps the connection, so a stall of a few seconds ends with the dictation intact. Only after eight seconds of silence does it switch to saving, and the words come from the saved recording, where the on-device model and a second pass through the router run side by side and the first words back are used. A refusal reads exactly as it does on the other engines: the allowance sentence at the press, and "Couldn't reach the dictation service" for a lost link. An engine this version of the app does not know — one saved by a newer version — is kept untouched and refused with one plain sentence; it is never run as a different engine, because the engine decides where your audio goes.local-fluid(selectable, not the default; the picker calls it "Fluid Speech Mini — on this computer"): a speech model that runs entirely on your own computer, on the processor (flowvoice/local-fluid/). Nothing is sent anywhere while you dictate, it needs no sign-in and costs nothing, and it understands English only (the card warns beside a different language). Picking it starts a one-time download of about 300 MB from Hugging Face — one pinned revision, every file checked against a fixed fingerprint — and the card shows the download and setup progress, then "Ready". The app converts the model once so its own speech runtime can read it, and runs it in a separate process so the app never freezes; the first load after the app starts can take a minute on a busy computer, and a dictation made meanwhile is held, not lost. The audio is kept and transcribed in one go when you release the key, so there are no live partial words: on a busy computer with other work running, a 12-second dictation appears about 4 seconds after release and a 39-second one about 9. A failure — no disk space, offline, a damaged download — shows as one plain sentence with a Try again button under the picker, and the recording is kept. The model's authors are credited under the picker (FluidVoice's Fluid Speech Mini, built on NVIDIA Parakeet TDT 0.6B v3 and Moondream Parakeet Ultra, CC BY 4.0) and in Settings → Diagnostics → Open-source licenses, and after a quiet hour the model unloads to give its memory back.
Why cloud is the default. The company, not an app release, decides which speech provider transcribes, and nobody needs a key of their own. The cost of one router is one vendor: if the router is down, default users are down. One company key allows only ten dictations at once across all users, and since 2026-10-19 the eleventh is continued on the backup provider instead of being told the engine is busy. Gemini, which was the default from 2026-10-04 to 2026-10-16, stays selectable as the other cloud path.
Only ONE side ever bills a dictation. On the relay path the gateway bills it, and the desktop deliberately writes no local stt-gemini row — billing it in both places would charge the same audio twice and throttle you against your own cap for spend you never made. Neither Gemini path touches the company flowvoice meter, which belongs to the hosted engine.
The shared hosted credential is fetched only while it is needed, as the pipeline above describes: every health check runs only on the hosted engine — the startup probe, and the settings card's Recheck, which also re-reads your OS permissions and does that on any engine. Before that gate landed (2026-10-04) the boot health check resolved it unconditionally, so every signed-in user was handed the shared company credential whether or not they used the hosted engine. Switching engines also clears the stored Server verdict, so the card never shows the previous engine's result for the one you just picked. While a permission grant is still pending, the card (and the onboarding Permissions step) re-reads your OS permissions every 2 seconds; that poll is local only and never calls the hosted service ({ permissionsOnly: true }, 2026-10-12).
Worth knowing before a long session. Relayed dictation draws on the same company AI allowance as every other company-funded feature, so roughly half an hour in a day can exhaust a user's daily allowance and pause their other company-funded AI until midnight; adding your own Gemini key removes that entirely. A single relayed dictation is bounded by the app's own ten-minute maximum, not by the relay — the relay's ceiling sits a minute above it — so the auto-stop you can see is always the one that ends a dictation.
Two engine-specific mechanics: (1) Audio format — Gemini, the cloud engine and the on-computer engine consume raw PCM16 16 kHz mono, so when any of them is selected the recorder-host captures via the shared AudioWorklet at a forced 16 kHz AudioContext (voice-audio-capture.ts) instead of the WebM/Opus MediaRecorder the hosted path uses. (2) Cleanup — on Gemini it is settled AT THE ENGINE: Gemini is asked for mode: SMART, where Google itself removes fillers, stutters and false starts, resolves self-corrections, and punctuates — and what it returns is what gets typed, word for word. The cloud (Soniox) and hosted (Deepgram) engines punctuate and capitalise but leave fillers and stray repeats in, so on those two the optional AI tidy-up below runs before the text is typed. The on-computer engine is never tidied: its words never leave the computer. Delivery (paste/insert at the cursor) is identical for every engine.
The AI tidy-up (cloud and hosted engines, English)
Since 2026-10-31 a dictation on the cloud or hosted engine can be tidied before it is typed. What it does, and what it is not allowed to do, is pinned in the tidy-up contract:
- What changes: filler words ("um", "uh", "you know") and false starts are removed, a word repeated by mistake ("the the") is collapsed, and a word the engine clearly misheard may be corrected. Punctuation is already right from the engine (measured across 159 stored dictations: every one started with a capital, 99.4 % ended with punctuation); fillers were in 74 % of them.
- What never changes: nothing is reworded, reordered or answered. Swearing is your content — swear words are lifted out before the text is sent and put back after, and a reply that loses one is refused. Every negation ("not", "can't", "no") and every number must come back exactly as spoken. At most one word may be corrected per dictation, within one letter on a word under four letters or two on a longer one.
- It can never cost you a dictation. The call has a 1.5-second ceiling; past it, or on any refusal, error or doubtful reply, your exact spoken words are typed. The raw transcript is always kept beside the tidied one in history. A tidy-up that never answers inside the app's own wait is said rather than passed off as an ordinary result: the pill tells you the words were inserted as you spoke them.
- Where the words go: the text (never the audio) goes to OpenRouter — through Omniscio's company gateway, or, when you have your own OpenRouter key in Omniscio, straight to OpenRouter on that key (a refusal there pauses only the tidy-up, rechecked after 30 seconds; your old legacy AI key is a Groq key and is never sent) — which runs
openai/gpt-oss-120bon Cerebras with data collection refused. Measured on the production request: 20 of 20 calls served by Cerebras, typically 254 ms. It is metered under its ownflowvoice-cleanupsource, with a per-person daily cap, and that spend also counts toward the FlowVoice daily cap described below. - When it is skipped: the switch is off; the engine is Gemini or on-computer; the dictation language is not English; a newer dictation has already replaced this one, or it was cancelled; a free plan (the company lane serves no call); or the lane has refused your account once this run.
- When it stops, the settings card says so. The tidy-up can stop on its own for two reasons, and they read differently because they end differently: the day's tidy-up allowance is spent (it starts again tomorrow with nothing to do), or the tidy-up isn't available for this account (it does not come back until something changes on the account). A quiet line under the switch says which of the two is happening, and both say dictation itself is unaffected and the words are typed exactly as spoken. Until 2026-11-15 that stop lived only in a log line, so a switch that was plainly on appeared to do nothing.
- Who pays — open decision. The feature is on the company lane's allow-list but no plan funds it yet, so until the owner decides, the gateway refuses it for ordinary accounts and their words are typed as spoken. The gateway must also be redeployed from
masterbefore the lane serves the model at all. - Tuning without a rebuild: every knob (prompt, model, provider, timeout, swear list, thresholds, daily cap) lives in one defaults object;
flowvoice-cleanup.jsonin the app's data folder holds overrides only, andflowvoice-cleanup.defaults.jsonbeside it shows the defaults. An edit takes effect on the next dictation; a broken file is ignored. The file is first read in the background when dictation loads at start-up; if the data folder cannot be read then, the built-in defaults stand and a warning is logged, never an error.
Polish dictation with Instant Fix (optional, every engine but on-computer)
Since 2026-11-04 a second, opt-in step can run after the tidy-up: Polish dictation with Instant
Fix (instantFixDictation, off by default) in the speech engine card. It sends each finished
dictation through Instant Fix with your Instant Fix cleanup level, writing style
and learned words, so a dictation can come out as polished as a manual fix. The owner chose to allow
it on 2026-11-03; its rules sit in the tidy-up contract
under instant-fix-polish-is-opt-in:
- It is never offered on the on-computer engine and never sends its words, whatever the dictation path reports. It works on cloud, hosted and Gemini, in any language (Instant Fix never translates).
- Meaning is protected. Swear words are hidden from the AI and must all come back; every negation and every number must survive. If not, the tidied (or spoken) text is typed instead.
- It cannot hold a dictation. It has a 3-second ceiling; the separate dictation process waits that much longer only while the switch is on. A slow, refused or doubtful reply types your words as they were, and the raw transcript is always kept in history.
- Where the words go and who pays: the same place as an Instant Fix — its text model through
your Omniscio AI account, under the
instant-fixcost label and its daily cap.
Why the old second AI pass was removed
The Gemini path used to run a local LLM pass over the transcript at the Strong level — add punctuation, fix casing, split into paragraphs — and it was removed on 2026-10-11: a model handed your words back and asked to improve them can do something you never asked for. The transcript was passed as an ordinary user message under a prompt that described a formatting task and never said the text was data, so a dictated question read exactly like a question from the user and the model answered it — a customer dictated "How would I level my tailoring?" and the reply was pasted into his document, 3 times in 12 dictations, with the Gemini transcript right every time. The Off level went the same day: a setting whose only other option is "do nothing" is not worth maintaining. Cleanup is now Light, always.
The tidy-up above is built against exactly that failure: the transcript is marked as data, the reply is checked word by word against what was said, and anything that is not the same words is thrown away for the raw text. Crash recovery still has no pass of its own, and its old one was removed rather than reworded: the class of bug is the pass, not its prompt. What that costs, plainly: a dictation recovered after a crash is transcribed by the local speech model, which does no tidying, so it arrives unpunctuated and still carrying its filler words. Every word is there — just rougher than a live dictation, whose cleaning is done by Gemini. The alternative is a model sitting between you and the cursor, which is what went wrong in the first place.
What dictation costs, and where you see it
The FlowVoice card (Settings → Voice Control → Dictation) carries a Usage & spend block. It deliberately shows two figures that are not the same figure, side by side and labelled as such, because dictation is billed on two different ledgers depending on which engine ran it:
Today's metered dictation — your machine's own ledger. The block shows the daily cap that actually stops dictation for the engine you are on (fixed 2026-10-15 — it used to show the hosted engine's cap whatever engine ran, so on Gemini, the number on screen stopped nothing):
- Hosted engine — its own daily cap, editable right in the block next to the number it limits (a meter you can see but not adjust would be a dead end). It limits the WHOLE feature, not just the speech: the figures summed are the dictation meter (
flowvoice) and the tidy-up model (flowvoice-cleanup), which stay separate rows in the ledger so the two are still attributable. Setting it to 0 turns the cap off; the block then says so rather than painting a full red bar at a user who simply disabled it. - Gemini on your own key — the shared speech-to-text cap ($5 a day by default), the same ceiling in-app voice input spends against, summed over every paid speech-to-text source. It is not editable here: the block says so and links to Settings → Voice Control, where it lives.
- Gemini on the company relay — no local cap at all; the block says the dictation is billed against your plan's allowance instead of showing a $0 meter.
readFlowVoiceSpend()(src/main/services/flowvoice/spend.ts) reports which of the three applies asbinding(hosted-cap·shared-stt-cap·no-local-cap), read from the same sources the dictation gate indictation/engine-session.tschecks, so the meter and the ceiling can never disagree. The figure is an estimate, and the block says so, showing the per-minute rate it meters at — nothing here is a bill.- Hosted engine — its own daily cap, editable right in the block next to the number it limits (a meter you can see but not adjust would be a dead end). It limits the WHOLE feature, not just the speech: the figures summed are the dictation meter (
Company-funded relay — our cost, not yours. Dictation that runs on Omniscio's own key (the relay path used when you have no Gemini key of your own) is billed to the company, recorded on the gateway, and shown here as covered by Omniscio. It never touches your bill and it is not what the daily cap meters. This one is a monthly figure, unlike the daily one above it — the block states each period rather than implying a single window.
An unreadable figure is never rendered as $0.00. If the gateway is unreachable, you are signed out, or the reply carries no figure for dictation, the line reads "Unknown — we could not read this from your account right now." Zero because nothing was used and "we could not find out" are different facts, and only one of them is honest. The same rule governs the history list below: a row shows a cost only where the local ledger metered one, and duration only otherwise — an unmetered row (any Gemini dictation, which bills elsewhere by design) carries no cost field at all, so nothing mistakes absence for a zero.
A history row's cost is what the ledger actually billed for that recording (fixed 2026-10-15). A dictation is billed once for the live capture and again for every replay a recovery or "Transcribe again" streams, and the ledger skips a duplicate (ON CONFLICT DO NOTHING on the operation id) or can fail to write — so the row cannot copy the live estimate, nor add every attempt:
trackApiCostRawreturns whether a row was really inserted;recordFlowVoiceCost(durationMs, keyParts, recordingId)adds the estimate to the recording only then.- The running total lives on the recording's sidecar as
pendingBilledMicroUsd— an INTEGER micro-USD, per the money contract — so it survives a restart and never drifts. - When a transcript's history row is written, the finalize reads that total, sets it on the row (
setHistoryCost), and only after the row update is confirmed deducts exactly that amount. Each row therefore shows what was billed since the recording's previous row, and a recording's rows sum to what the ledger holds for it. A recording that was never billed (Gemini) has no total, so its row keeps no cost field rather than showing $0.00. - Known ledger gap, not changed here: when a recovery hears silence it does not bump the recording's
attempts, so a second replay can reuse the first replay's operation id and the ledger itself skips it. The row follows the ledger, so it never over-counts.
The monthly dictation allowance
The plan's own dictation allowance (2026-10-05). Separate again from the two figures above: each plan includes a number of dictation MINUTES per UTC calendar month — Free 15 minutes, and Pro, Team, Enterprise and Developer 5 hours (Team's is per seat; Enterprise and Developer are deliberately the same as Pro, not unlimited). The card shows minutes used of that total, under Dictation allowance, and an unreadable figure renders as unknown rather than as zero for the same reason as those figures.
ONE pool covers every engine. The relay, the hosted engine and the cloud router spend the same monthly minutes, so switching engines cannot mint a second allowance; a dictation on your OWN Google key is not metered at all, because it costs us nothing. Recording captions made in the cloud draw on this same allowance — a screen recording transcribed in the cloud spends the same minutes as dictation (Captions for new recordings). The figures live in one place (FLOW_LIMITS.dictation_minutes in src/shared/paid-offering.ts), which is text-copied verbatim into the gateway and the Firebase functions, and an unknown tier — a claim that is absent, empty, or outside the known set — resolves to the FREE figure, never to unlimited. A tier the gateway could not READ is a third answer, and it is not the free figure (fixed 2026-10-10): the hosted service's usage endpoint used to answer Free whenever reading the claim failed, so a single Identity-Toolkit blip metered a PAYING user at 15 minutes until the blip cleared, while the credential mint — reading the tier from the VERIFIED token claim, which no such blip can break — kept issuing credentials and let them keep dictating. The two halves disagreed and the customer was refused a plan they had bought. An unreadable tier now answers the hosted service with a 503 carrying no allowance at all, and the service lets the session run rather than capping it: an outage costs a few unmetered minutes instead of metering a paying customer at Free, which was the wrong direction, or refusing them entirely, which would have been worse.
Enforcement is server-side on both legs, and it happens BEFORE the microphone opens, so a dictation is never cut mid-sentence: the relay verifies the tier and refuses a new capture with its own close code (4009 ALLOWANCE_REACHED, distinct from 4002 rate-limited, 4003 company money cap, and 4012 CREDITS_EMPTY for a spent plan whose wallet is empty too), and the hosted credential mint refuses with a machine-readable scope (monthly-allowance, hosted-requires-paid, allowance-unavailable, or dictation-credits-empty). The hosted half of that held only on the road that FETCHES a credential, not on the one that REUSES a cached copy (fixed 2026-10-10): the desktop holds the hosted credential in memory for up to an hour and serves it without asking the mint — the one pre-flight that knows the month is spent — so a refusal that arrived mid-session left the copy in place and the next press went straight past the check, opened the microphone and was refused only when the user stopped speaking. A refusal the plan answers now retires the cached copy in the same place a refused sign-in does, so the next press is refused by the mint before any audio. All three route through ONE humanizer (src/shared/voice-mic-error.ts), so servers saying different things cannot tell the user different stories. The desktop's mapping of the relay close codes, and of the mint's scopes, is held to the deployed values by two guards that read the other deployable as text (tests/unit/lint/3d/stt-close-code-parity.test.ts, tests/unit/flowvoice-dictation-refusal-copy.test.ts) — the gateway and the functions each have their own package.json and cannot import src/shared. An unreadable money ledger is not a ceiling (2026-11-15): when the gateway cannot read the cap store it decides on, it now closes with its own 4013 STORE_UNAVAILABLE instead of reusing the customer-facing 4003, so a few seconds of Firestore trouble reads as "temporarily unavailable, try again" rather than "your limit is reached, upgrade" — and the gateway's own metrics can still tell a real ceiling from an outage.
Past the plan's minutes, dictation keeps working and pays for itself (2026-11-14). When the month's allowance is spent, the extra audio is billed to the user's own prepaid credit balance instead of stopping: the gateway holds the seconds that balance can cover, the session is bounded to exactly those seconds, and the real audio is charged at settle. Every engine charges the SAME rate — one constant in src/shared/paid-offering.ts, generated into both deployables — so the bill does not change with whichever engine the router picked. The card says so while it is happening, under Dictation allowance: the minutes over the plan and what is left in the wallet. When the wallet cannot buy another second, the refusal is its own: close code 4012 CREDITS_EMPTY on the socket and the dictation-credits-empty scope from the mint, with copy that says to add credits — never the monthly-allowance sentence, which would send someone to upgrade a plan that is not the problem.
A spent plan with nothing behind it still takes you somewhere. If credits cannot cover the session, the mic pill says the minutes are used, when they reset, and offers both roads — the plan link opens Settings → Plan & Usage, because a sentence that names a destination has to be able to reach it.
The month's seconds are recorded as a dictationSeconds field on the EXISTING per-user monthly document the relay already reads (gateway_company_user_monthly_spend, <uid>_<YYYY-MM>), so there is no extra read on admission and no new data destination — the consent record is unchanged.
A spent allowance ends the dictation at the press — and keeps the recording
When the reason a dictation cannot be transcribed is your plan's own monthly allowance, the app does not wait for you to finish speaking. Every engine refuses an exhausted allowance when the dictation's session starts — a beat after you press the key — so the capture is ended there and then: the microphone closes, and the pill shows the allowance sentence with its Click here to see plans. link at once, instead of after a whole dictation spoken into a session that could never transcribe it. Whatever the microphone had already caught is kept exactly like every other recording, listed under Saved recordings — a refusal stops the capture, it never deletes audio.
The one dictation that is not cut short is the one that runs the month out: the check happens when a session starts, so the press that crosses the line finishes normally, and the NEXT press is the one told immediately. Nothing is guessed ahead of time to make that press cheaper — the refusal you see is the server's own answer to this press, never a verdict the app cached for you.
The same refusal ends a replay the same way. Transcribing a saved recording again — automatically after a dictation that failed, or by Transcribe again in History — opens one fresh session first, and if the server refuses that one (a spent monthly allowance, an engine your plan does not include, a sign-in that has expired) the app stops there rather than re-sending the whole recording to a session that can no longer take it. You read the same refusal sentence you would have read live, your recording is kept exactly as it was, and the replay is not charged to your plan: only a replay that actually got its audio to the engine is billed.
Your recording is kept — nothing about the dictation deletes it
Every dictation keeps its audio on your machine, not just the ones that went wrong. A transcript is what the speech engine heard, and engines drop words — so the recording, which is the only copy of what you actually said, outlives the dictation that produced it. Every dictation appears under Saved recordings with its audio, ready to re-transcribe or delete.
What a dictation's own outcome can never do is delete its audio: not a successful transcription, not an empty one, not a silent one, not a start that failed. A recording goes away only when you say so — ✕ Cancel on the pill mid-dictation, Delete or Clear all in the list, erasing your data, or signing out — or when your data-retention window passes (Settings → Data & Storage, 30 days by default). That window is the natural cleanup: it is far longer than noticing a dictation that came back short takes, and you can lengthen or shorten it whenever you like.
When transcription fails — your recording is saved
Every dictation is saved to disk while you speak (saved-recordings.ts, under userData/flowvoice-recordings/), so no failure can lose what you said. And it is put on the PHYSICAL disk, not just handed to Windows, every couple of seconds while you are still speaking — so even a power cut or a blue screen costs you the last second or two of speech rather than the whole dictation. That periodic write never delays your microphone or your paste:
- The connection drops mid-dictation, or the result comes back broken or empty. On release, the app transcribes the saved audio again by itself: first a fresh session of the same engine (the audio replayed at 8× real time), then the built-in offline transcriber (free, no network, English only, for the Gemini engine's audio). The recovered text is pasted where you were, like a normal dictation. A transcript from a stream that errored part-way is never pasted as if it were complete. A connection that is merely slow, rather than broken, is not treated as a drop: if the machine stalls long enough to hold up the app's own timers, the live connection is still given a bounded moment to finish before the fallback runs, so a busy moment no longer turns a working dictation into a recovered one.
- Nothing could transcribe it right now (for example, you're offline and the offline model isn't available). The recording is kept. The pill says "Couldn't transcribe right now — your recording is saved. Click to try again.", and clicking it retries that recording and pastes at your cursor.
- Nothing was transcribed at all — you spoke, and both transcribers answered silence. The recording is kept, and the pill now SAYS so instead of settling back to idle in silence (until 2026-10-06 it said nothing anywhere, so "the app ignored me" and "nothing was said" looked identical). A press too short to hold a spoken word is the one ending that stays quiet: it is kept, but an accidental tap of the hotkey is not announced. Which line you read comes from what the capture actually held: "No speech was heard — nothing was transcribed." when the room was silent; "No speech was heard — your microphone was very quiet. Check the input device." when the capture carried real but very quiet audio (something like 26 dB below an ordinary dictation); and "No speech was heard — your microphone sent pure silence. Another app (such as Teams or Zoom) may be holding it, or it may be muted." when the microphone delivered no sound at all — an exact digital silence a real microphone never produces, which is what Windows hands an app when another application has taken the device exclusively (the 2026-11-04 report: Teams held the microphone, and quitting Teams fixed it) and what a muted input sends too. None carries a click-to-retry, because re-transcribing the same audio would fail the same way.
- Saved recordings list. Settings → Voice Control → Dictation (FlowVoice) → History shows a Saved recordings group: by default only the recordings that need a look — failed, possibly incomplete, or recovered — each with Transcribe again (the text goes into history and is copied to your clipboard) and Delete. Every other dictation's audio is kept too, behind a Show all recordings toggle, so the list is not one row per dictation. An Open Dictations button at the top opens the Dictations hub, which shows every recording beside the words it produced — see dictations.md.
- Quitting or crashing mid-dictation no longer throws the recording away. On the next start the app transcribes each cut-off recording for you and raises one inbox card per recording, saying either that it was recovered or that its audio is saved and can be tried again. The card also says how long that dictation ran, measured from the saved audio itself, so you can see how much was cut off. When the length genuinely cannot be measured from the file — the hosted engine's format has no fixed bytes-per-second — the card simply leaves the length out rather than claiming a 0-second dictation. The card's Open dictations button opens the Dictations hub focused on that recording, highlighted; the dictated words never ride on the card itself, because an inbox alert can be forwarded. Pressing ✕ Cancel still discards the recording.
- Out of free dictation is a final answer, and the app treats it as one. When the month's dictation allowance is spent, that automatic pass stops at the FIRST refused recording instead of trying every one — retrying it cannot help until the allowance resets, and one night it retried two dozen times in a minute and tripped the service's own rate limit and alert. The rest of the recordings are kept, still listed, and are tried on a later start; each one's card says dictation isn't available on your plan right now rather than inviting a transcription that would be refused again. The same sentence — and a click that opens your plan — is what you see when a saved recording's Transcribe again is refused, instead of the old "your recording is saved". That card's own button is See Plans & Usage, which is where the plan that refused the dictation is read and changed, with Open dictations beside it for the recording itself: the card used to offer only the untranscribed recording, so it told the person their dictation was blocked and left them no way to unblock it.
- The paste itself fails after a good transcript: the pill says the text is on your clipboard and in your history.
- A window pops up while you dictate into Omniscio (Windows: a console window flashing up, for example): it never receives your words. Omniscio tells it apart from an app you switched to yourself by when its program started - after your dictation began means it appeared on its own - takes the focus back and pastes into Omniscio. If it cannot get the focus back, the pill says the text is on your clipboard. An app you deliberately switched to still gets the dictation at its cursor, unsent.
- The offline transcriber narrates silence ("[BLANK_AUDIO]", "(music)"): those markers are stripped before anything is delivered, so a silent recording comes back as silence rather than as that text in your message box.
- Privacy: a dictation's audio is kept on your machine until your data-retention window passes (Settings → Data & Storage, 30 days by default) — that window is the only automatic cleanup, and it is one you control. A dictation's own outcome never deletes it; nor does anything else, except the deletions you ask for: delete it, clear all, erase your data, or sign out.
When the microphone drops out mid-sentence — and when the pill says so
A dead microphone used to cost the rest of the sentence; a second stream now covers the gap (2026-11-03). A USB audio interface can stop handing over sound while Windows still reports it open and working: every sample it delivers is exactly zero, so the rest of the dictation is silent and nothing is transcribed. A track can stay live, unmuted and enabled while it delivers exact digital silence. The capture notices that: a second stream on the same device, with echo cancellation off so the computer treats it as a separate stream, keeps listening while the dead one is replaced, so what you said in the gap still reaches the text. A moment later it moves back to an echo-cancelled stream, so sound from your speakers is not picked up for the rest of the dictation. When that second stream is silent too, it falls back to stopping the source and reopening it, which still costs the audio it takes, and the app says so. Measured, a dropout now costs about a hundredth of a second instead of nearly a second, and the second stream costs a fraction of a percent of one processor core. Nothing is sent from the second stream while the first one works.
- A second stream on the SAME settings cannot replace a dead one. A second
getUserMediawith the same constraints attaches to the SAME source, so the "fresh" stream would be just as silent. A second stream that differs in one setting — echo cancellation off — does get its own source, which is what covers the gap. - When both streams are silent, the microphone is reopened. After about a second and a half of exact silence — sooner if the microphone itself reports it has stopped — FlowVoice stops every track of the dead source, lets the device go, waits a quarter of a second and opens it again, carrying on in the same dictation so the words after the gap arrive. That fallback still costs real audio: in a real dictation roughly 1088 ms passed between the source going dead and audio being captured again — 250 ms of that is the deliberate settle that makes reopening the device fast rather than taking 1.5–3.1 s, and the rest is the device open. The stretch while the microphone was dead cannot be recovered, because nothing was heard. A headset that goes quiet between sentences on its own is left alone, and a microphone left open from the last dictation is not reused if that dictation ended in silence. This watch covers every engine except the hosted one, whose recorder is unchanged. (Added 2026-10-17.)
- So a fallback recovery costs the audio it takes. The capture counts it — the zero run it detected plus everything from the teardown to the install — and reports it when the dictation ends.
- Past 500 ms of lost audio the pill says so, with the existing line "Your microphone stopped sending sound — some of what you said wasn't captured." Below that floor it stays quiet, so one brief patch never raises a notice over a complete transcript. That is the change that matters: before this, a dictation that lost audio pasted a short transcript and said nothing at all. When the microphone cannot be reopened, or reports itself stopped or unplugged, the pill says so instead of pasting a short text as if it were complete. If the microphone reports itself muted, the pill says it seems muted instead and asks you to unmute it or check that no other app is using it.
- Your chosen microphone is the one that records. If it can't be opened, the dictation uses your default microphone so nothing is lost, and the pill tells you afterwards. (Fixed 2026-11-02: the choice used to be treated as a preference, so the Windows default opened every time.)
- A recovery that finishes after the dictation has ended releases nothing. It used to be able to retire whatever capture the controller held by then — which by that point could be the NEXT dictation's microphone, switching it off mid-sentence and saying nothing about it.
- The count comes from the recorder, not from scanning the audio in the app. It has to: on the dictation-core road the raw frames are diverted to the core and never reach the app at all, so a scan there would see nothing. And a microphone that gates itself to digital silence between words looks identical to a dead one in raw audio, which is why the app has always treated a long zero-run that ends by itself as a gating source rather than a fault. Counting only the gaps the recovery itself classified avoids both traps.
History (inline in the settings card)
The standalone FlowVoice sidebar tile + FlowVoiceView panel were retired; FLOWVOICE_PROJECT_ID (__flowvoice__) survives in src/shared/virtual-project-ids.ts only so stored references still resolve. History now renders inline in the settings card: the 20 most recent dictations (the store caps at 50 in flowvoice-history.json under userData, history-store.ts), each showing target app, window title, relative time, and duration, plus the transcript, a raw-transcript disclosure when it differs (a dictation recorded before the cleanup pass was removed still carries a separately cleaned text), per-row Copy / Remove, and a Clear all action. The list live-updates on the flowvoice:result push.
History is age-purged as well as capped. The 50-record cap is only the first limit — what is kept is also deleted once it is older than your data-retention window (30 days by default, set at Settings → Data & Storage), so a dictation you made months ago is gone whether or not the 50 slots filled up. The purge covers everything a dictation record holds: the raw transcript, the cleaned text, and the app and window title you dictated into — that last one is why the window matters if you dictate into something sensitive. It runs on the app's periodic retention sweep rather than on a timer of its own, and the Clear all action and the per-row Remove clear a record immediately if you would rather not wait. There is a kill switch for the sweep (AMC_DISABLE_FLOWVOICE_HISTORY_PURGE=1).
Where a kept recording's words live
History keeps the newest 50 transcripts; kept recordings are kept until the retention purge. Until 2026-10-15 a recording got its words ONLY from its history row, so once 50 newer dictations pushed that row out the Dictations hub showed the recording blank and flagged it.
- Each kept recording now carries its own transcript on its sidecar (
rawTranscript,cleanedText) together withtranscriptHistoryId, the history row that wrote it. The finalize writes it in the same un-awaited step that decides the recording's fate, so the paste never waits on it. - The hub (
listDictations) shows a live history row when one exists; a recording whose row is gone is shown from its own copy. - The plain recordings list stays word-free.
listSavedRecordings(served to a scoped CLI token byGET /flowvoice/recordings) projects through an explicit field list that never includes the transcript; only the hub, the export and the erasure paths read it. - Deleting a history row (Settings or
DELETE /flowvoice/history/:id) also clears the words from its recording — only when that row is the one that wrote them, so deleting an older row never wipes a newer retry's text. Clear all clears every recording's words; the recordings themselves stay. - A per-contact erase deletes each recording whose words, app name or window title mention the subject, using the same matcher as history. Clearing only the words would let "Transcribe again" rebuild them from the audio. Erase-all and sign-out still delete every recording.
- The data export includes
flowvoice/recording-transcripts.json. It is not counted in the manifest'scounts, because an import never restores it. - Upgrade: at startup, after the interrupted-recording sweep, recordings with no words of their own copy them from the newest live history row that names them. It only fills an empty recording, so a second run changes nothing.
Your own list (custom words)
Under Settings → Voice Control → FlowVoice, Words to recognize is a list of the names, brands and jargon dictation keeps getting wrong. The list is sent with every dictation to whichever speech engine you have chosen, as words to expect, so the engine spells them right at the source instead of the app patching the text afterwards: the hosted engine (Omniscio's own server, which passes each word to Deepgram as a keyterm, at most 100), the cloud engine (the company's speech router — Soniox, or its Meta Muse backup when Soniox refuses or fails before the first word) and Gemini (as its custom vocabulary, at most 100). A word added there is in force on the very next dictation. Fluid Speech Mini, the engine that runs on this computer, has no way to take word hints, so the list changes nothing while you use it; Voice settings and the add-word message say so plainly. Choosing a list never changes which engine you use. If an engine ever refuses the list, that dictation goes on without it. Deepgram charges a little more per minute when words are attached (about $0.0013 a minute).
The list starts filled from your own past dictations on this computer: a one-time local pass reads the transcripts already saved for your dictations and proposes the names and jargon that recur in them. Nothing leaves the machine for it and no model is called. Everything proposed is yours to edit or remove, and the pass never runs again — a list you change stays exactly as you left it. Blank entries, duplicates that differ only in case, and words over 64 characters are dropped, and the list holds up to 200 words and 4,000 characters in total. If a list is ever too long or malformed the dictation still runs; only the words are dropped. The list is never written to a log.
The app's own names
Every dictation on an engine that takes the list also tells it to expect Omniscio and Omni (the AI assistant's name), even on a fresh install with an empty list, so the product's own names come back spelled right instead of as "Omnisio" or "Omnis Yo". They are sent after your own words and the learned ones, and never appear on or change either list. If you already list one of them, it is sent once, in your spelling. When your lists already fill the engine's 200-word or 4,000-character limit, your words win and the two names are left out. Other engines (Gemini and the on-device engine) take no word list, so they do not get these names either.
Omniscio is always typed right, on every engine. Telling the engine is not always enough, so every dictation is also checked before it is typed: any misspelling of the product's name ("Omnicio", "Onision", "Omnitio", "Onitio", "Omniceo", "Omnis Yo" and the rest of that family) becomes Omniscio, in the text typed at your cursor and in your dictation history alike. Nothing else changes: "Omni" on its own, real words such as "omission", "omniscient" or "onion", and web addresses, emails and file paths are left exactly as heard. A misspelled form of the name on your Words to recognise or learned list is never sent to the engine (your list itself is left as you wrote it), and the one-time pre-fill never adds one.
Learned from your corrections
When you dictate into a session's message box in Omniscio, fix a name the engine got wrong (say "initial" or "omniscient" to "Omniscio") and send the message, straight away or queued, the name you typed is remembered. It goes on a separate Learned from your corrections list under Words to recognise, and from then on it is sent to the cloud engine as a word to expect, right after your own words. Learning only ever adds expected words: it never changes what a dictation types, never edits your own list, calls no AI model, and never reads another app.
- What it learns. Only a short replacement that looks like a name, brand or acronym: a word capitalised mid-sentence ("Omniscio"), one with a capital inside it ("GitHub"), a short acronym of up to five capitals and digits that replaced a different word ("sequel" to "SQL"), or a name carrying a digit that starts with a letter ("S3"). At most five words from one message.
- What it ignores. Rewording to ordinary words, a capital at the start of a sentence, an ordinary word written in capitals ("OK"), a word written in capitals for emphasis ("FAILED", "NEVER"), a dictated word you only shouted, numbers such as "2nd" or "5pm", a word you only added or deleted, and a message that does not contain most of the dictation. One limit remains: a short word in capitals typed over a different word ("big" to "HUGE") can still be learned — remove it and it stays gone.
- Where it looks. Only a dictation pasted into one of Omniscio's own windows, compared with the message you then send from a session's message box. A quick reply never teaches, and fixes made in another app, Team Chat or the search box are not seen.
- Removing a word. Each learned word has a remove button. A removed word is never learned again on its own — you can still add it to your own list.
- The switch. Learn from my corrections, on by default, stops all learning and forgets the dictations it was holding. The learned list stays visible and removable.
- Room. Your own words and the learned ones share the engine's 200-word, 4,000-character limit, your own words first. A word is learned only when there is room for it, and when your own list grows, the learned words that no longer fit leave the learned list (the newest first), so the list on screen is exactly what the engine receives. A learned word you add to your own list leaves the learned list too.
- Privacy and speed. At most your last five dictations are kept for the comparison, in memory only, and each is dropped fifteen minutes after it was pasted. No dictation, message or learned word is ever written to a log or telemetry — a learned word is counted, never named. The comparison runs only after your send has been answered and is strictly bounded, so it never slows or fails a send.
Related
The in-app microphone — talking to a session instead of typing at the OS cursor — is a different feature on the Voice and TTS page. Language and accent handling for both is on Language support, the cost surfaces FlowVoice meters into are described on Cost control, and every recording beside the words it produced is on Dictations.
Last verified 2026-11-18