* Stage clipboard-preserving capture insertion for Paste Last on Mac
* Update Rune and its Nix source hash for the picker work
* Select the latest ready paste by owner identity and revalidate it
* Exercise a held mixed paste picker with real bundles and a private Mac pasteboard
* Publish ready Annotate identity and queue owner-specific paste requests
* Wire the existing Mac paste shortcut and controls to the opt-in mixed picker
* Recheck the selected field and cover Paste Last with a disposable Mac receiver
* Refresh the Rune revision for the unified History pane
* Unify Mac History and keep only spoken words after a deliberate dictation cancel
* History and Paste Last call a Hex capture an annotation (t1612)
A finished Hex capture is an Annotation in History, its details and the
Paste Last picker, and the type filter is Annotations. The Captures pane no
longer rewrites its own label when the unified History is on, and the search
index drops the old synonym. Scrawl stays only as Scrawl.app and the on-disk
.scrawl format; a Hex-owned format is separate file and engine work.
* Gate the unified History behind a Labs toggle and give it one row shape (t1612)
Labs › Paste Last picker (labs.paste_last_picker; macOS, Dev audience, off by
default) replaces HEX_EXPERIMENTAL_PASTE_LAST and is read where the work
starts: the picker and its gesture, History's unified list, and the cancel
path's word writer. Off, Paste Last and History behave exactly as before.
History's rows now share one shape for dictations, annotations, screenshots
and recordings; a capture's detail card carries its picture, words, facts and
actions; a search or the type filter never leaves a stale card open; an empty
History has one empty state; and the type filter shows only when there is more
than one kind to filter.
The picker's rows sit on its title's left edge.
* Show the Paste Last picker card on macOS only (t1612)
* Refresh the Labs goldens for the Paste Last picker card (t1612)
* Keep the unified History's capture helpers to macOS builds (t1612)
* Keep the unified History's fixture pictures behind the Mac capture gate (t1612)
* Point the docs at the Paste Last picker lab (t1612)
* make the labs card copy plain
Rewrite the Labs card titles and lines in words a regular user understands:
YOLO mode says the message sends itself, Live text and Failure notices name
the small recording indicator, Vocabulary help says which speech models it
affects, and the key-side cards name Option, Command, Shift, and Control.
Audit every other card, updating the CLI descriptions, all nine translated
languages, the website lab catalog, the feature docs, and the render goldens.
* fix labs copy review findings
Restore the ISO qualifier on the section-key card, spell out that
double-tap and hold-through shortcuts contain no letter or number key,
cover all Global mode stages in the API text card, and name the print
command in the print-start copy. Restore the developer API card titles,
fix the Annotate capture wording, and retranslate the affected strings.
Remove every replaced translation key and stale lab-name reference.
* fix second labs copy review
Update the live typing test and YOLO goldens. Add a Windows variant of the
hold-through-keys copy naming Ctrl, Alt, Shift, and the Windows key. Remove
the last unused rewrite-by-voice translation key, keep Annotate untranslated
in the replay title, and clean the remaining old lab-name comments.
* use the Polish Annotate pane name in its replay title
Polish calls the Annotate pane Adnotacje, so the Annotate last 15 seconds
title says Ostatnie 15 sekund w Adnotacjach again. Other languages keep
Annotate because their pane name is Annotate.
* capture: stream audio to disk so long captures keep all of it
A capture's timeline now writes 16 kHz mono PCM16 to its bundle's
audio.wav as it records, with the leading offset and gaps as silence, so
memory stays flat and the 20-minute drop is gone. An 8-hour guard bounds
disk use only; past it the rest is one recorded gap.
A finished capture is transcribed from the WAV in 30 s pieces, the
reader hex transcribe already used (lifted to transcription/pieces.rs),
and each piece's words move onto the capture clock. The Parakeet, Apple
(path-based), and GGUF paths keep every word without holding the
session. The pipeline never rewrites a streamed audio.wav from empty
samples, an iPhone narration is read back where it must be re-based,
and a cancelled capture closes and removes its file.
* capture: say where a capture's audio stopped
A streamed capture keeps all of its audio, but the 8-hour disk guard (or
a failed audio write) still stops it early, and only the process log
said so. The timeline now carries the stop point onto RecordedAudio,
the bundle stores it as audioStoppedAtMs (serde default, so old bundles
load unchanged), and three places say it plainly: summary.md, `hex
capture show`, and `hex capture status`.
The guard records its point at a 1 s test limit, and the summary line is
tested at 12:34 and 8:00:00 so both clock shapes are covered.
* capture: fill the replay's stop point from its bundle
The 15 s replay builds Written too, on macOS only, so the new field
broke the macOS clippy job while Linux never compiled that function.
* capture: keep a recording out of recovery until it stops
Review fixes for the streamed timeline.
A capture now streams to `audio.wav.partial` and renames it to `audio.wav`
in `Timeline::finish`, so a bundle with a movie and an in-progress audio
file is never mistaken for a capture whose build never ran (recover's
orphan rule, Scrawl.app's `scrawl recover`) and retention cleans a crashed
one like any other bundle. Cancel and discard remove the partial; a failed
publish reads it back into memory rather than pointing at a missing file.
Also: a write failure's stop point is the last sample that reached the
file, not the end of the failed chunk; a trim failure counts every written
sample; the capture's words keep one running frame total instead of
adding truncated per-piece millis; an iPhone narration's `since` drains the
decoded samples instead of copying them and treats a missing file as no
audio; the phone and replay paths carry the audio stop point into their
bundles; and empty audio answers `source: "none"`, as `transcribe_with`
does.
Tests: a movie plus partial audio is never owed, retention trashes a
crashed bundle's media, a write failure records its stop point, a missing
streamed file shifts to no samples, and the replay shift moves the stop
point with the clock.
* capture: publish audio.wav only once its build journals the capture
Follow-ups from review.
A capture now streams to audio.wav.partial and keeps that name after it
stops: the partial is renamed to audio.wav right after the build writes
unfinished.json, so audio.wav never exists without a journal, and a
stopped capture waiting in the finish queue no longer looks like an
orphan to Scrawl.app's recover. A partial that cannot take the name is
read back and written by the build, and its partial name removed; the
replay removes the unshifted partial once the narration is read for
shifting.
Also: a periodic header flush error is now a write failure (the rest of
the capture is a gap) rather than a log line; the midpoint of a failed
write records where the file stopped; and the words test cuts pieces at
odd sample counts and computes offsets from the running frame total, so
per-piece millisecond drift would fail it.
Tests: a streamed audio takes its final name only when the build settles
it (and falls back when it cannot), a capture that has not been
journaled is never owed a rebuild, a mid-capture write failure stops
where the file stopped, and the word offsets are exact at odd piece
lengths.
* capture: consume a streamed recording's partial when it is read
Follow-ups from review.
`RecordedAudio::since` and `into_memory` now remove the partial once its
samples are read: an iPhone narration (capture.rs's `host_narration`
path) used to leave the whole streamed file in the finished bundle. The
replay relies on the same path instead of removing it by hand, and the
light zip leaves `audio.wav.partial` out defensively. A read that fails
is an error to `into_memory` (so a build keeps the only copy) while
`since` still treats a missing file as no audio for an iPhone.
A failed publish now reads the audio back only when it produced the
samples the recording had; a failed read keeps the partial and removes
any half-copied `audio.wav`. `publish_audio` takes `&mut self` and points
the recording at the published file.
A journaled bundle whose `audio.wav` is missing adopts `audio.wav.partial`
before rebuilding. Docs say the guarantee is a streamed capture's, and
that a crash while recording or queued is retention's job, not
recovery's.
Tests: reading a streamed recording consumes the partial; a finished
iPhone bundle keeps none; a streamed audio is published only when its
build settles it, including the read-back and unreadable-partial cases; a
journaled capture adopts its partial.
* capture: keep a failed audio publish recoverable
Follow-ups from review.
The publish fallback read the partial with `into_memory`, which deletes
it, and then ignored whether its own write landed: a failed write left
the audio nowhere. It now reads through `read_streamed` (no deletion),
writes `audio.wav` and checks the result, and removes the partial only
once that write succeeded. A failed read or write removes any half
`audio.wav` and fails the build, which is the pipeline's existing failed
path: `recover::finished` runs only for an `Ok` build, so `unfinished.json`
stays and the next launch's recovery adopts the partial instead of the
capture quietly finishing without its audio.
`publish_audio` also treats a landed copy as success even when deleting
the partial fails, logging it rather than reporting failure and letting
the fallback overwrite a good `audio.wav`.
Tests: a blocked target keeps the partial and fails the build; a
fallback write that lands consumes the partial and writes `audio.wav`;
an unreadable partial is kept.
* Graduate six meeting labs, move four into Meetings settings, and throw capsules into corners (t1532)
* Regenerate goldens and count call rows from the provider list (t1532)
* Trace a recording pill hover and reversal offscreen (t1571)
* Keep the recording meter anchored and show each audio track (t1571)
* Keep light and dark recording snapshots from Linux (t1571)
* Draw dictation’s listening field inside the meeting pill (t1571)
* Refresh meeting pill goldens with the listening field (t1571)
* Paint just the listening dots on the meeting surface (t1571)
* Keep dots-only recording goldens in light and dark (t1571)
* Keep recording controls and the dictation HUD dark on light desktops (t1571)
* Refresh the dark overlays on light-host goldens (t1571)
* Keep the finished meeting in its corner and let Close dismiss it (t1571)
* Refresh finished summary goldens with the close control (t1571)
* Open shipped features from What’s new (t1574)
* Keep release-specific links distinct from feature navigation (t1574)
* Document and translate the feature feed (t1574)
* Verify dark and light navigation to both controls (t1574)
* Show feature icons and calendar-day headings in What’s new (t1574)
* Verify local-day boundaries and refresh both feed goldens (t1574)
* Separate What's new navigation from build details (t1574)
* Check What’s new selection through accessibility (t1574)
* Refresh only the lower sidebar in the Linux goldens (t1574)
* Drop the graduated labs from the Labs card and catalog (t1532)
* Keep the merged meeting files inside the source cap (t1532)
* Regenerate the Labs and Meetings goldens for the cleanup (t1532)
* Drop the graduated labs from the website catalog (t1532)
* Keep the throw's frame hook on every capsule (t1532)
* use OpenCode's default model for meeting summaries
Meeting titles, summaries, and live chapters with no meetings.opencode_model
post one request with no model field, so OpenCode answers with its own default
and the transcript never reaches a provider the person didn't pick. The ranked
fast models stay for dictation rewrites and voice prompts.
The summary model picker's automatic entry and its invalid-value note say so,
with translations, and the meeting docs follow.
Move the one-shot generation transport into dictation/processor/generation.rs
to keep processor.rs under the 1,500-line cap.
* docs: cover OpenCode's default model in notes and rewrites
The meeting notes footer list now names the case with no chosen summary
model: "Written by OpenCode's default model" (#1125).
The dictation map carries the #1123 fallback the meeting map no longer
describes: the ranked rewrite models are cached per service, any one failing
drops the cache, and when all of them fail OpenCode's default answers.
GENERATE_ENDPOINTS stays inside its module; nothing outside it names the
routes.
* fix(cli): transcribe long files in pieces (#1769)
* fix(cli): skip silent pieces and refuse truncated files up front
* fix(cli): unique test files, honest read refusals, no detector download
* cli: hex dictation start --print keeps a dictation from pasting (labs)
A client that starts a dictation to insert the text itself loses it when
the person finishes the locked recording with the shortcut, or when a
microphone loss salvages it: Hex pastes or copies into the focused app.
`hex dictation start --print` (macOS, behind Labs › Print-only CLI
dictation / `labs.print_start`) blocks and answers with the transcript
however the recording ends, so nothing is pasted or copied. It is busy
while a dictation records, a plain `stop` answers done, `stop --print`
joins the same transcript, no speech exits 4, a cancel or failure exits
1, and it waits at most 31 minutes. Linux and Windows answer
unsupported; CONTROL_VERSION stays 4.
# Conflicts:
# src/labs.rs
# src/rune_ui/labs.rs
# tests/golden/rune-mac-labs-dark.png
# tests/golden/rune-mac-labs-light.png
# tests/golden/rune-mac-labs-link-dark.png
# tests/golden/rune-mac-labs-link-light.png
* cli: harden hex dictation start --print's endings
# Conflicts:
# src/labs.rs
* cli: bind the printing-start test's shortcut to Option
* labs: regenerate the Labs goldens for both new cards
* labs: keep the microphone open after dictating
With Release microphone while idle on, a capture that ends now leaves the
microphone open for a Labs window (`labs.keep_microphone_open` +
`labs.keep_microphone_open_seconds`: 30 s, 1, 3, 5, or 30 minutes, default
1 minute), so the next dictation takes the warm path with its pre-roll
instead of the cold open's asynchronous start. Off, every listener closes
exactly as before, and with the release setting off the lab does nothing.
One `audio::linger::MicrophoneLinger` decides it for macOS, Windows, and
Linux: the first idle pass after a capture arms the window, a capture clears
it, and only a later idle pass past the window closes, once nothing records,
no client dictates, no release tail runs, and no capture copies the
microphone. Windows and Linux move their repeated `release_while_idle &&
!wants_audio()` closes into that one check; macOS reconciles through it. The
switch takes the Labs state word's last free bit; the window has no room
there, so it lives in its own atomic, both written by `labs::apply`.
Also moves Linux's Live typing glue into `linux/dictation/typing.rs`, since
`linux/dictation.rs` was at the source cap, and regenerates the Labs goldens
for the new card.
* labs: release the lingering microphone where the old sites did
Review fixes for keep-microphone-open:
* macOS reconcile_input keeps origin/dev's branches: with a capture sink
open and an inactive input, recovery is still requested, and the lab's
window is cleared while a sink holds the microphone.
* A digital-silence finish closes a lingering microphone instead of
skipping recovery, so the next press opens a fresh stream. macOS does it
in reopen_silent_stream; Linux's moved to linux/dictation/silence.rs
(which also keeps linux/dictation.rs under the source cap). Windows has
no digital-silence path.
* Windows and Linux run the release check at the old event sites (a
submitted finish, a cancel, a discard before the open, a client's end)
through one small macro, so a press handled in the same pass still sees
a closed microphone when the lab is off. That check also releases a
microphone an interrupted recording left open, which the old
latch-based sites never did.
* Docs: drop the "exactly as before" claims, describe the extra close, the
Annotate capture-sink and local-API windows, macOS ending the window on
a stream interruption, and the Linux poll rather than an idle wait.
* clear() is real code now (the silence close); state()/apply() say why
the switch bit and the window atomic are written separately.
* labs: keep the lab's windows and spots exact
Follow-ups from review:
* Windows releases the microphone when a pending client dictation's start
gives up at the first chunk, which the old site closed too.
* macOS leaves a lingering microphone alone when a digital-silence finish
lands while a capture sink copies it, so Annotate gets no gap.
* The Linux silence test's released case opens the input first, so it really
covers "lab off, release while idle: no reopen, stream stays open".
* Docs say where a digital-silence finish ends the window (macOS and Linux,
not with a capture sink on macOS) and that Windows can linger on a
zero-only stream.
* more dictation shortcuts: up to four extras, each with its own mode
Labs › More dictation shortcuts (macOS) adds up to four more dictation
shortcuts beside the main one. Each saved row keeps its own binding and
activation mode, registers only while the Lab is on, and shares no key
with another active shortcut. Settings records, clears, and rebinds each
row; the listener runs every press through the same capture pipeline, so
each shortcut finishes with the mode it was pressed with.
* more dictation shortcuts: review fixes
* more dictation shortcuts: follow lone-modifier double-tap, narrow globe check
* more dictation shortcuts: doc nits
* more dictation shortcuts: rebase fixes
Moves the recorded-shortcut checks beside the rest of the shortcut text in
`control/settings/hotkeys.rs` so `control/settings.rs` stays under the
1,500-line ceiling, drops the `labs.rs` size exception now that dev moved the
Feature registry into `labs/feature.rs`, and counts Meeting notes file
alongside More dictation shortcuts in `Feature::ALL`.
* add hex transcribe for saved wav files (labs)
`hex transcribe <file> [--model] [--language]` prints a WAV recording's
transcript from Labs › Transcribe files, off by default. A running Hex
transcribes it on its dictation engine over the local API; with Hex stopped,
Linux and Windows load the model here and macOS answers not-running.
* fix hex transcribe refusals, read cap, and docs (labs)
- name a failed POST /transcriptions by the code in Hex's JSON body,
with one message per server code and status only as a fallback
- say the lab is managed instead of naming `hex labs on` under a lock
- read through the 64 MiB cap and reuse those bytes offline
- document that clips up to 30 s use the engine's model and longer
ones the service's own copy
- cover an early refusal during a large upload with a loopback test
* cli: select the model after an offline `model install`
With Hex stopped, `hex model install` downloaded and verified the model but
never wrote the selection, so `model status`, `check`, and `transcribe` kept
using the previous one, and no message said so.
The offline branch now selects it as the app's own switch would: a Hex that
started while the download ran takes the choice over `model use`, otherwise
the selection is saved under the Linux service lock `settings apply` uses,
so a starting Hex is never written behind. An already selected model is left
alone, so login-time installs don't rewrite settings.json.
Docs say the offline install selects now, and a new app_settings test covers
the persisted round trip keeping unrelated settings.
* cli: wait for a starting Hex before selecting an installed model
`model install` with no Hex running saved the selection under the
service lock, and failed at once when a Hex already held it. Wait for
that Hex to answer instead, as `settings apply` does, through one
shared hand-off so the two paths can't drift. An unchanged selection
answers without taking the lock.
* feat(linux): labs transform typed text shortcut (#1519)
* fix(linux): harden typed-text clipboard handling
* fix(linux): keep dictation clipboard fallback, sync typed-text keybinding
* refactor(control): keep shortcut text in its own settings module
settings.rs crossed the 1,500-line limit when Labs added the typed-text
key; the shortcut text parsing and formatting is the one self-contained
concern, so it moves to settings/hotkeys.rs unchanged.
* meetings: expire audio separately (labs)
Add a Labs › Expire meeting audio separately toggle, off by default. When on, Meetings › Settings shows Keep audio under Keep meetings and meetings.audio_retention can move only system.wav and microphone.wav to the Trash for completed meetings, keeping transcripts, notes, summaries, and the exported Markdown. The whole-meeting retention pass is unchanged and still runs first.
* tests: match words, not digits, in the event log redaction check
The assertion searched the whole log for "4321", which a millisecond
timestamp can contain.
* i18n: keep the string table under the source cap
Move the Rune Meetings pane and Apple Intelligence rows beside the main
table, joined when the per-language maps are built.
* meetings: keep renames during audio expiry
Re-read the manifest after moving WAVs so a concurrent rename and its export hash survive; use each track's manifest file name. Cover the race with a regression test.
Build every i18n table and completeness check from all_translations so the Meetings rows no longer fall back to English, and use the serial comma in the Keep audio description across languages. Document that a Keep audio window at or beyond Keep meetings has no effect and list the pane test.
* Meetings: one Summaries picker (Off, On this Mac, OpenCode)
* Widen the Summaries menu so both second lines fit
* Tap the Summaries trigger in tests and update goldens
* Fix the labs count after rebasing onto the platform icons graduation
* Update the Labs goldens
* Labs: Voice Filter and Playground are dev-only; cards show their settings inline, no drawer
* Labs: regenerate mac-labs-link goldens; drop an unused test helper
* Windows: ship hex.com, a console entry point beside the GUI hex.exe, on PATH
* lock, fmt, legacy adoption
* clippy
* build hex-console in its own cargo run: -p hex is ambiguous with the hex crate
* hex.com returns once the app starts; Ctrl+C only; install script and Setup replace a running hex.com; hex-console checks in Compile
* fmt
* installer test: exit 0 once every check passed
hex.exe is now a GUI program. Commands run from a terminal join it
(AttachConsole) and print there; the app leaves it after startup errors
have had their chance to print. Rune 31dbcad cloaks a window until its
first frame presents. Release checks assert the GUI subsystem.
* feat(annotate): prototype 15 s rolling replay buffer on macOS 27 (t1289)
* fix(capture): gate macOS-only replay imports and helpers on non-macOS (t1289)
* Labs: ⌘⇧4 screenshots on macOS (t1300)
* Fix the thumbnail golden's render (t1300)
* Round the thumbnail's size; list its scene in the playground (t1300)
* Keep rune_ui.rs under the size limit (t1300)
* Thumbnail goldens (t1300)
* Allow macOS-only re-exports elsewhere (t1300)
* Use speech models already on this computer (#594)
* Keep found-model state together
* CLI copy for found models
* Docs and onboarding hold test for models found on this computer
* Remove dictation cancel: Escape ends nothing (#786)
* Format and refresh the sound sets and commands goldens
* Release Escape before finishing in the held-capture test
* wip: import your own speech model (Labs)
* fix debug
* Show the imported file's name
* clippy
* Say why an import can't be used
* Golden for the picker's Add model file
* Docs, feature map, AGENTS.md for imported speech models
* Arm Remove before removing an import
* Merge recognition hints into the shared vocabulary
* Drop the unused text field helper
* Drop unused imports
* Cohere stands in for a model that ignores the vocabulary
* Update the picker golden for the Uses vocabulary badge
Records like the dictation shortcut and pastes the transcript as heard,
skipping replacements, corrections, transformations, and rewriting. Unbound
by default; set in the Output pane, raw_dictation_hotkey, or
hex dictation start|toggle --raw. History keeps it as Raw.
Suggested by @ksajan.
Linux and Windows now hand the local API's POST /control to the shared
control host, so the CLI reaches every OS through local-api.json and
call_control. The Linux socket's Request::Control and the Windows named
pipe (windows_control) are gone.
* One hex control CLI and protocol on every OS
One command tree (control::cli) on macOS, Linux, and Windows, carried by
each OS's owner-only transport: the macOS local API, the Linux socket's
Request::Control, and a new Windows named pipe (windows_control) that only
this user's SID can open and whose server the client verifies. Linux and
Windows share one host (control::host) through thin adapters; what an OS
can't do answers unsupported at runtime.
Windows gains dictation (with stop --print), paste-last, quit, restart,
start, a live status, and every annotate command; Linux and Windows gain
settings, model, window, vocabulary, history clear, check-for-updates,
launch-at-login, onboarding reset, logs, commands init|check, and annotate
status. hex status reports the OS's capabilities, settings name the
capability they need (set refuses, list marks), and a parity test requires
a recorded reason for every capability that differs across OSes.
* Windows control pipe: always hold an unconnected instance; check the client's user
* Shared control: meetings, history, and mcp on every OS now that the meetings store does
System audio from a PipeWire monitor (Linux) and WASAPI loopback (Windows),
call detection from PipeWire capture streams and Windows audio sessions,
the shared controller, capsules, pane, and tray items, and notes and live
chapters through OpenCode where Apple Intelligence isn't available.
Meetings stays in Labs, off by default.
* Lower audio, idle-sleep prevention and Bluetooth-mic avoidance on Linux and Windows
* fix
* fmt
* Ducking test covers every OS
* Linux idle-sleep falls back to an idle inhibitor outside the seat session
* fix borrow
* Docs: Lower audio, idle-sleep prevention and Bluetooth avoidance on every OS