Commit Graph
938 Commits
Author SHA1 Message Date
Dax 8a9f9f82ac Meetings: name the real notes writer in the finished capsule (#2065)
The ready panel always said Apple Intelligence while notes were being
written, even where OpenCode writes them. Share the pane's writer rule
through rune_ui::notes_writer so the pane and capsule use one label.
2026-11-20 12:01:14 -05:00
Dax 1f43fcac68 fix meeting capsule cursors over actions (#2068) 2026-11-20 11:55:04 -05:00
Dax 3fc14b5ec9 labs: neutral voice for chosen modes (#2043) (#2049)
* labs: neutral voice for chosen modes (#2043)

* labs: tighten neutral voice guard and reuse cleanup helpers

* labs: share neutral voice quote and fallback helpers

* labs: keep folder paths protected in neutral voice
2026-11-20 11:51:08 -05:00
Kit Langton 9f078b9a40 feat(history): find dictations and captures together on Mac (#1932)
* 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)
2026-11-19 19:52:09 -08:00
Dax 90cca52748 windows: don't paste into the desktop or taskbar, keep the dictation on the clipboard (#2016)
* windows: don't paste into the desktop or taskbar, keep the dictation on the clipboard (#2009)

* windows: keep the shell fallback plain and unmarked, and accept a copy in practice (#2009)
2026-11-19 19:10:26 -05:00
Kit Langton ec5e7282ca fix(labs): Switch model with app matches a picked app under its Finder name too (#2018)
The app picker saves the name Finder shows for the bundle's file, but Switch model with app looked modes up by the running app's own name only, so a mode picked as "Rex Beta" (Rex Beta.app runs as Rex) never switched the model. The frontmost read used by the switcher now shares capture_frontmost's name read and passes Finder's name alongside, and the mode lookup accepts either, as Modes and YOLO mode already do. Windows keeps matching its process name.
2026-11-19 15:17:36 -08:00
Kit Langton 07ba1f27d8 Count a HUD re-home only once a later tick confirms it, with backoff (t1618) (#2019) 2026-11-19 15:10:39 -08:00
Kit Langton b9a19735a4 Remove meeting capsule frame-dump debug switches (#2017) 2026-11-19 14:58:20 -08:00
Dax 643563378d windows: re-arm a silenced keyboard hook and heal a lost shortcut release (#2006)
* windows: re-arm a silenced keyboard hook and heal a lost shortcut release

A Toggle dictation could keep recording for 50 minutes while every
shortcut press and Escape did nothing and nothing was logged: Windows had
stopped calling the low-level keyboard hook and the lost chord release
left the capture reading as held.

Add a 1 s watchdog on the hook thread that re-installs the keyboard hook
when session input keeps arriving but neither hook has seen an event for
3 s, and on the same tick releases a keyless chord whose keys read up as
its lost release would. Log the escape cancel, an ignored escape while
recording, and each watchdog re-arm.

* windows: keep hook-side logging off the hook path, re-arm both hooks with back-off

* windows: gate the release heal on keyboard silence and back off on keyboard events only
2026-11-19 16:41:53 -05:00
Dax 4d28a692d8 add fluid speech pro to the speech model catalog (#2007)
* add fluid speech pro to the speech model catalog

FluidVoice's Fluid Speech Pro, a Parakeet TDT 0.6B v3 retrain that also
declares Moondream's Parakeet Ultra as a base, for the same 25 European
languages. TalkMate converted it to a Q8_0 transcribe.cpp GGUF at d59dc79
(741,819,456 bytes, sha256 c3848e98...); the file says
parakeet/tdt-0.6b-fluid-speech-pro and announces its extra pre-Conformer
block as stt.parakeet.encoder.pre_block_kernel, so it needs a transcribe.cpp
that reads enc.pre_block.

Like Parakeet v3 it takes no language hint, detects the language under Auto,
does not stream, and is never recommended or badged. Its card publishes no
LibriSpeech test-clean figure, so it carries no single word error rate and no
benchmark record; its per-language FLEURS figures and the CC BY 4.0 credit
are in its details.

* bump(transcribe.cpp): 295c7e6, fluid speech pro's pre-conformer block

Fluid Speech Pro's GGUF announces stt.parakeet.encoder.pre_block_kernel and
carries eight enc.pre_block.* tensors: a residual FrameCleaner block between
the subsampler and Conformer layer 0. The old pin's graph never read them, so
the model loaded as plain Parakeet v3 and its encoder was wrong.

Both transcribe-cpp crates move to 295c7e601 on hex/combined-fluid, a
fast-forward of bcb639f that runs the block on pre_encode before xscaling
when the KV is present, and fails the load rather than skipping tensors when
it is only partly there. Cargo.lock changes only those two sources
(`getrandom`'s tempfile pointer was reverted to what it was), and
nix/package.nix carries the hash from a failed `nix build .#hex`, then a full
one whose check phase passed.

`hex model install fluid-speech-pro` followed by `hex model transcribe` on
whisper.cpp's jfk.wav prints the expected sentence, as does Parakeet v3 on
the same clip.

* fluid speech pro: snake_case id, FLEURS-only figures, blurb, notices
2026-11-19 15:19:06 -05:00
Dax 2747e34e2e bump(rune): c853811c, a settle lands before the frame's input (#1994) (#2002)
* bump(rune): c853811c, a settle lands before the frame's input (#1994)

Rune's catch-up settle (an uncover, a restore, a shown window) forced the
next frame's whole commit to land, so a dialog closed by that frame's press
or key was unmounted without its exit. Rune now commits the pre-input tree
with the settle and runs the input as an animated commit
(anomalyco/rune#1241).

All Rune git revs move to c853811c8e0e60a632eaa2e72992f871225737ef;
Cargo.lock changes only Rune-hosted crates, and nix/package.nix carries the
hash computed by a full `nix build .#hex`.

The replay test opens the vocabulary sheet, settles, and presses outside:
both layers exit mid-fade and are gone after settling.

* docs(vocabulary): list the settle-frame replay check

It covers an outside press on the first frame after the window comes back
still playing the sheet's exit.
2026-11-19 13:28:14 -05:00
Kit Langton 998131ef82 fix(modes): match a picked app under its Finder name too (#2001)
The app picker saves the name Finder shows for the bundle's file, but the frontmost read reports the running app's own name, so a picked app whose file is named differently (Rex Beta.app runs as Rex, Visual Studio Code.app as Code) never activated its Mode and Labs › YOLO mode never pressed Return in it. The macOS frontmost read now also keeps Finder's name for the bundle when it differs, and application matching accepts either, so existing saved lists start working without re-picking.
2026-11-19 09:34:33 -08:00
Kit Langton a33f207f96 fix(labs): YOLO mode pastes and sends through Copy dictation only (#2000)
With Copy dictation only on, a dictation went to the clipboard unpasted, so YOLO mode never pressed Return and looked broken. In YOLO mode's apps (or every app with none chosen) the dictation now pastes and sends; elsewhere Copy dictation only still just copies, and a rescued microphone-loss dictation on macOS is still only copied.
2026-11-19 09:22:59 -08:00
Dax b33db219c9 fix annotate pen stopping short on gnome at fractional scale (#1995) (#1996)
The Annotate ink overlay on GNOME Wayland is Rune's XWayland window, which
lays out in its own points (X11 pixels over Xft.dpi). capture_host::draw sized
the engine's target frame from the ScreenCast portal's stream `size` instead,
the desktop's logical layout: 1536x960 for a 1920x1200 screen at 125%. Every
pointer past 1536 was outside the target, so the pen stopped at 1536/1920 of
the screen (and 960/1200 down); at 100% the two spaces coincide.

The XWayland target is now the overlay's own size in points, read from its
laid-out root element (Cx::layout_size), so it covers the whole screen whether
a compositor scales XWayland natively or traditionally. Native Wayland layer
surfaces keep the portal/named-output logical size unchanged, and the recorded
pixels over the overlay's scale stand in until the view has laid it out.

Known gap, recorded in the map: on XWayland the ink is one full-screen
primary-monitor window, so it cannot follow a named output.
2026-11-19 10:18:13 -05:00
Kit Langton baeb1e9ec8 Merge pull request #1993 from anomalyco/meeting-hud-motion
feat(meetings): land the meeting capsule's motion surface and filled pill
2026-11-19 03:12:51 -08:00
Dax 002b575c95 Add KB-Whisper Medium for Swedish (#1991) (#1992) 2026-11-19 05:44:56 -05:00
Kit Langton 9ba5d207b8 Merge remote-tracking branch 'origin/dev' into meeting-hud-motion
# ------------------------ >8 ------------------------
# Do not modify or remove the line above.
# Everything below it will be ignored.
#
# Conflicts:
#	tests/golden/meeting-capsule-ready-dark.png
#	tests/golden/meeting-capsule-ready-light.png
#	tests/golden/meeting-capsule-recording-open-dark.png
#	tests/golden/meeting-capsule-recording-open-light.png
2026-11-19 02:26:23 -08:00
Dax a9f992004f linux: round a Wayland window's bottom corners (#1981)
* linux: round a Wayland window's bottom corners

Bump Rune to 431469b999268a56ef7fbc60ed55975753ee22df. Under GNOME Wayland
winit draws the client-side frame, whose headerbar rounds the top corners and
whose shadow cuts a 10-point rounded window, but the content's surface stayed
square: the bottom corners showed past the frame's border and the border's
straight bands crossed the shadow's cut-out (#1779).

Rune (#1188) rounds the content's bottom corners with the frame while the
window floats, and keeps them square when it is maximized, tiled or
fullscreen; a compositor that draws the decorations itself (KDE, sway,
Hyprland) keeps the surface it had. Patch sctk-adwaita from the same rev as
winit, since Rune's winit calls the vendored frame's
`AdwaitaFrame::content_corner_radius`.

The rev also carries Rune's macOS/iOS/Linux build fix after the crate
extractions (#1203), and its wheel fix (#1214): a wheel over a scroll bar now
scrolls the viewport it follows, so Hex's wheel-over-the-right-edge tests keep
their positions.

The bump brings the type-erased `window::Host` and window/ reorganisation,
the rune-core/rune-gpu/rune-image/rune-spell extraction, then rune-text,
rune-media and rune-edit, the non-generic `RuntimeCore`, windows-sys 0.61,
deep Taffy stack segments, one flatten and one detached-table prune, the new
wheel distance and chaining, and text, markdown and scroll fixes. No Hex call
sites changed.

Goldens are refreshed for Rune's visuals: the OpenCode icon catalog's marks
(terminal, search, keyboard, globe) in every pane and overlay, and the
shortcut-mode bars from Rune's border-over-fill change.

cargo check --all-targets, cargo test (2811 passed), cargo clippy
--all-targets --all-features, cargo fmt --check, code-shape.py,
check-nix-git-pins.py and its tests, nix build of the cargoDeps, and
cargo test rune_ui all pass.

* history: read Dictation stats from the window's settings

The pane closed its stats dialog and reloaded the rollup from the
process-wide labs switch. A test that applies another LabsSettings (as
several do) flips that mirror under it, so the dialog vanished mid-test.
Take the window's own `settings.labs.history_stats` instead, as the Stats
button and the dialog already do.

* nix: vendor Rune's fonts for rune-text, and run the suite serially

Rune's crates/rune-text includes crates/rune/assets/Inter-*.ttf by a path
relative to the workspace root; a vendored crate sits in git/ beside
rune-0.0.1, so link git/rune to it for the include.

The package check also runs plain cargo test, which shares Hex's
process-global lab switches and model-download state. nextest isolates
each test everywhere else, so run this one test at a time.

* goldens: refresh the meeting capsules on Rune's icons

Dev's capsule layout moved the time and close button above the title; with
Rune's icon catalog the copy-agent-prompt mark is the boxed terminal. Only
those four renders change.

* nix: run the package check one test at a time the hook's way

`preCheck` runs before cargoCheckHook, which then sets
RUST_TEST_THREADS=$NIX_BUILD_CORES, so the export there was a no-op and the
suite still raced on its process-global state. Set
dontUseCargoParallelTests instead, and take the rune vendor directory's name
from its cargoGitDependencies key, failing loudly if its assets are missing.
Drop the link once Rune moves the fonts into rune-text.
2026-11-19 05:18:55 -05:00
Kit Langton 3c925a1bd1 Merge remote-tracking branch 'origin/dev' into meeting-hud-motion
# ------------------------ >8 ------------------------
# Do not modify or remove the line above.
# Everything below it will be ignored.
#
# Conflicts:
#	src/rune_ui/meeting_capsules.rs
#	src/rune_ui/meeting_capsules/motion_fixture.rs
#	src/rune_ui/meeting_capsules/offer.rs
#	src/rune_ui/meeting_capsules/offer/proof.rs
#	src/rune_ui/meeting_capsules/offer/surface.rs
#	src/rune_ui/meeting_capsules/panel.rs
#	src/rune_ui/meeting_capsules/replay_fixture.rs
#	src/rune_ui/meeting_capsules/stage.rs
#	src/rune_ui/meeting_capsules/waveform.rs
2026-11-19 01:13:39 -08:00
Kit Langton 4ef40636c9 fix(meetings): fill the open header with the field in left corners too
In a left corner the open field kept its resting 78 pt and left 101 pt
of the header empty beside the time. It now fills the header as it does
on the right, held at the anchored wall: its free end is the wall's
motion, and the time rides that wall 14 pt inside it, through the
opening, the closing, and a capture that ends with the pill at rest.

The finished panel keeps the time where the recording left it, so a left
corner's header now matches the right's: ✕ sits before the time, which
ends at the inset. A header notice keeps its words and its cut while the
time wipes over them, and has gone by the time the field is halfway.

Three left-corner replays cover it: open and close then capture ending
at rest, Stop from the open panel, and a notice.
2026-11-19 00:16:24 -08:00
Kit Langton b43d43710e Merge pull request #1905 from anomalyco/meeting-stop-motion
fix(meetings): make Stop easier to hit and keep the pill through transcription
2026-11-18 23:42:23 -08:00
Dax 538d16f668 windows: sign the setup engine so smart app control can run setup (#1987)
* windows: sign the setup engine so smart app control can run setup

Setup extracts a copy of its engine to %TEMP% at launch and writes the
installed uninstaller from the same bytes. Signing only the outer
hex-setup-*.exe left both unsigned, and Windows 11 Smart App Control
blocked the extracted copy ("Unable to execute file in the temporary
directory", error 4551).

SignedUninstaller embeds the engine's signature, but the signature has to
exist before the compile that uses it, and the compile job holds no
credentials. So the release signs it in two passes: the new
windows-setup-engine.yml compiles once with SignedUninstaller=yes and keeps
the unsigned uninst-*.e32 ISCC asks to be signed (ISCC leaves it and aborts
as a compile failure, exit 2); sign-windows-engine signs and verifies it in
the release environment; windows-installers.yml then compiles with the
signed engine and asserts the installed uninstaller's signature.

Test builds and runs without the Azure values keep the unsigned single
compile. Inno Setup is pinned to 6.7.1, read from the compiler's own banner
(ISCC.exe's version resource is 0.0.0), so both passes use one compiler.

* windows: harden the setup engine passes

Review fixes for the signed setup engine:

- sign-windows-engine requires sign-windows to have succeeded, and its
  steps are unguarded like sign-windows-installers, so it can never upload
  an empty digest.
- setup-engine runs only when Windows is signed (it waits for
  sign-windows), so unsigned runs really do a single compile with no
  engine pass at all.
- the Inno re-pin uses choco upgrade --allow-downgrade, because choco
  install --version treats a preinstalled package as already installed.
- Invoke-Iscc collects native stderr safely under Windows PowerShell 5.1
  and pwsh with $PSNativeCommandUseErrorActionPreference on, and echoes
  the compiler's lines so build logs stay readable.
- the version probe compiles a minimal script from standard input into a
  throwaway OutputDir, so it never touches the caller's -OutDir.
- only .e32 exists for the engine; drop the unused .e64 handling.
- the uninstaller signature test also checks the release publisher, and
  the test-builds doc warns that Smart App Control cannot be turned back
  on without resetting Windows.

* windows: correct the setup engine comments
2026-11-19 02:38:03 -05:00
Kit Langton b1eb2f16ed Merge dev (with the Record draft's surface model) into meeting-stop-motion
The Stop draft and the Record draft each grew a handoff; they meet as
one surface model, as resolved once before at cb2dedd4b. Dev's drag
snapping (screen, scale) carries through.
2026-11-18 22:01:53 -08:00
Dax 8d3ea95f91 show why speech engine fell back to the cpu after a gpu out-of-memory failure (#1984) (#1985) 2026-11-19 01:01:37 -05:00
Kit Langton 46bff360df Merge remote-tracking branch 'origin/dev' into t1609 2026-11-18 20:53:41 -08:00
Dax 648ec4725a labs: transcribe dropped audio files (#1798)
* labs: transcribe dropped audio files

Add Labs › Transcribe dropped audio (off by default) and its backend:
WAV and MP3 on every OS, M4A/AIFF/CAF on macOS through the meeting import
bridge, decoded in 30 s pieces, transcribed in-process with the selected
model, and written as <stem>.txt beside the file with a Downloads fallback,
collision numbering, atomic writes, cancellation, and progress. Move the
shared pieces reader out of the transcribe CLI so both use it.

The window's drop target lands in a later change.

* labs: drop audio files on the window to save a transcript

The window root takes files with the extensions this build reads while
Labs › Transcribe dropped audio is on: a file drag shows "Drop to save a
transcript" over the window, a drag Hex can't read says what it reads, and
a drop queues one job per file behind the one running, all at the dictation
model and language in use. A worker transcribes each file and the toast
shows its name, a progress ring and percentage, how many wait behind it,
and Cancel; a saved file shows its name, the whole path, and Show in folder
(meeting::reveal), and a failure shows the backend's own words. The lab's
card offers Transcribe a file…, which opens the same queue's native file
dialog, for Wayland, where nothing can be dropped.

file_transcript exposes its extension table for the drop filter and dialog,
and finds every format from that one list. New goldens cover the hint and
the transcribing toast, and the drop-transcribe card now leads with a wave.

* meeting: use the renamed bridge in the import test

* transcription: find a temp folder through a symlinked path

* transcription: finish the audio file drop's review fixes

A drop right after Cancel (or the lab turned off and on) started a second
worker and a second transcription service while the first was still loading
or running. The running job now stays tracked as cancelling, its toast says
Cancelling… with no Cancel, and the next queued file starts only when its
worker reports Done or its channel closes. A cancel before the save also
stops a cancelled file from writing a transcript.

Also: validate a WAV whole before a model loads, report an unknown MP3 length
as indeterminate progress, map a bridge decode failure to Unreadable, keep a
writable source folder's transcript beside it without Downloads, name this
build's formats in the Labs card, use the kit's 16 pt toast lead, route Show
in folder through the host, derive the Audio folder through app_paths, and
correct the stale comments and feature map.

* transcription: read dropped files through the shared pieces reader

The rebased tree already decodes every container through Pieces, so the
dropped-file backend now opens, validates and reads one Pieces instance
instead of its own WAV, rodio MP3 and macOS bridge readers. Progress comes
from the reader's position and duration, and a compressed file with no
header duration reports no fraction. The retired Labs › Expire meeting audio
gate and the removed Transcribe files lab leave the tree too.

* labs: refresh the goldens for the dropped audio card

The card's row and the drop hint and toast change the Labs images and the
two drop scenes; only those eight goldens changed.

* labs: finish the dropped audio card's translations and goldens

The string tables already translate Audio files and Transcription stopped,
so the lab reuses them; the card's English line gains translations, the
website catalog lists the lab, and the what's new goldens show it.

* labs: offer every audio format the shared reader decodes

the dropped audio lab offered wav and mp3 everywhere, and the old macOS decoder's extras only on macOS, though every OS reads through the shared pieces reader. it now offers one list: wav, mp3, m4a, mp4, aiff/aif, caf, flac, ogg/oga/opus, webm, and mkv. every copy, translation, and golden names it, and a fixture proves the reader takes each one. also names the codec or missing track on a failure, keeps a late cancel's saved toast, and waits for a cancelled worker before the next file.

* labs: offer raw AAC and MOV files too

* labs: offer the reader's other common extensions

the shared pieces reader detects formats by content, so m4b, m4v, 3gp,
aifc, mka, weba, and wave decode too. the extension list is now described
as the common names it offers rather than an exhaustive set, empty files
and unreadable wavs say why, and a lab-off poll drains the worker's
channel instead of reading one event.

* transcription: free the audio slot before a result is sent

A long file is transcribed one piece after another, and each piece admits
the slot as soon as the previous result arrives. The worker released the
slot only after sending that result, so the next admit could see it busy
and fail mid-file with "Another transcription is running".

Also fixes the codec refusal's grammar and two stale comments.

* transcription: say where a damaged file stopped

a compressed file that stops decoding partway now says where it stopped
("talk.m4a is damaged at 12:34") instead of only that it is corrupt; a wav
refused up front keeps the old words. the slot-order test uses a rendezvous
response channel and waits for the slot to read free before receiving, so
sending before the admission drops fails every time instead of occasionally.
a locked drop-transcribe card keeps the lock's words instead of replacing
them with its formats line.
2026-11-18 20:49:59 -05:00
Kit Langton 5306fe65f1 fix(meetings): wipe the header's notice with the widening field
With a notice the resting pill is already the panel's width, so the field
widened across the notice while it was still fading, dots over words, and
on the way back the words were cut again at every width. The notice now
keeps its place and its cut inside a lane that ends where the field
begins, with a soft edge, and has gone by the time the field is halfway
across the header.

The overlay now steps the surface before the field samples, so the trace
is drawn once a frame at the width the wall has just reached instead of
at last frame's width and then again at this one's.
2026-11-18 17:23:19 -08:00
Dax e4d85b44aa windows: join back-to-back dictations with a space (#1980)
* windows: join back-to-back dictations with a space

move the input-activity revision, continuation join and its tests into a
platform-neutral continuation module. windows now invalidates it on real
keys and clicks from the low-level hooks and on foreground-window changes,
and the paster joins dictation and paste last the way macos does.

* windows: end continuations on real input and skip hex's own trigger

injected input from other tools and the auxiliary mouse buttons end a paste
continuation as on macOS, while Hex's own synthetic events and a dictation
trigger that Labs › Share shortcut lets through do not. A standalone macOS
paste clears the continuation only where dev did: at the start of typing, or
after the clipboard is preserved and checked.

* windows: a bare trigger key press ends the paste continuation

Labs › Share shortcut lets the dictation trigger's key reach the app in
front, and the hook treated every event for that key as hex's own. A
plain Space while Ctrl+Space is bound then kept the continuation, so the
next dictation joined with a space for no reason. Mark the press as the
shortcut's only once it claims the capture, and drive the hook's own
state machine in a test.
2026-11-18 19:28:07 -05:00
Dax 9a00e8e944 fix(meetings): snap a dragged capsule to the new corner on windows and linux x11 (#1978)
* fix(meetings): snap a dragged capsule on Windows and Linux X11

The recording pill (and a panel capsule) followed the pointer but always
came back to the corner it started in off macOS: primary_screen_size
returned None there, so a release had no screen to measure the throw
against. It moves to meeting_capsules/screen.rs and gains a Windows
implementation (the primary monitor over its DPI scale) and an X11 one
(the primary RandR monitor over Xft.dpi, the root window without RandR).
Wayland still reports no screen, so a capsule there returns to its corner.

* fix(meetings): measure a capsule's screen in Rune's own points

Windows places a capsule's top and bottom edges inside the primary
monitor's work area, so its height is the work area's, while its x uses
the whole monitor. The scale now comes from the view's Cx::env(), the
same scale Rune divides pointer pixels by, instead of a copy of winit's
Xft.dpi rules; a capsule floating on XWayland keeps the X11 path, since
Rune places it by RandR there. The screen lookup is a field on the
capsule, so the drag tests stub it and assert the exact corners they
always did, and a new test covers a release that lands in another corner.

* docs(meetings): name where a capsule drag snaps

A capsule snaps on Windows, on X11 desktops, and floated on XWayland
with the GNOME call-recording Labs option; only a native Wayland capsule
still returns to its corner, so the docs say that instead of blaming
Wayland as a whole. The test runtime's missing screen is named for what
it is, and its scale starts where Rune's own starts.
2026-11-18 18:36:40 -05:00
Dax 52811a7f9b skip agent-harness providers in automatic rewrite model pick (#1954) (#1959) 2026-11-18 13:17:42 -05:00
Dax 85e7e3f3bd meeting notes: write titles and summaries in the transcript's language (#1968) (#1970)
English instructions and no language rule let the notes model answer in another language. Ask for the title, summary, and chapter names in the language spoken in the transcript, on both backends.
2026-11-18 12:59:47 -05:00
Dax 84ed9a52c8 labs: fold yearly stats into dictation stats (#1976)
* labs: fold yearly stats into dictation stats

* labs: strip retired yearly_stats key and keep it under a lock
2026-11-18 12:22:38 -05:00
Kit Langton 56532c11e4 docs(meetings): name the checks for the other capsules and the four corners 2026-11-18 09:19:38 -08:00
Kit Langton 3efb656d8a docs(meetings): record how a capsule leaves and a title changes 2026-11-18 08:41:15 -08:00
Dax 49ae4d8b14 meetings: add select all calendars lab (#1973)
* meetings: add select all calendars lab

* meetings: tidy select all calendars lab
2026-11-18 09:57:54 -05:00
Dax 0ec0438c22 history: yearly stats heatmap, time saved and busiest hour (#1971)
* history: add yearly stats rollup, time saved, and busiest hour

* history: fix clearing and seeding the usage rollup
2026-11-18 07:08:05 -05:00
Dax 7460e7aa50 windows: let altgr type its character over a ctrl+alt shortcut (#1964) (#1967) 2026-11-18 05:04:51 -05:00
Dax 1ea0136047 fix(macos): keep ggml's metal tensor kernels off on m5-class gpus (#1966) 2026-11-18 04:31:09 -05:00
Dax a2a583b95f history: chart the dictation stats dialog (#1962)
* history: chart the dictation stats dialog

The Lab's Stats dialog now leads with four headline tiles (dictations, words,
words per minute, and the daily streak), then charts dictations per local day
over the last 30 days with empty days left at zero and today's bar in the
accent colour, lists the top apps as bars against the busiest one, meters
Output's share of the text, and names each rewrite profile's median and
slowest latency. A section with nothing to show stays out.

HistoryStats gains the daily series and per-profile latency, both additive in
hex history stats --json. The dialog moves to rune_ui/history/stats.rs so
history.rs keeps its headroom, the big number is controls::STATS_NUMBER, and
the History strings live in desktop/i18n/history.rs.

Docs cover the new contents and JSON fields, and the scene fixture shows every
section.

* history: make the stats dialog honest about Output time and fit small windows

Output time now names each mode's whole Output processing, rewrite plus any
transformations, and leaves out runs that fell back (a failure or a deadline)
and runs that only applied the person's transformations, whose profile is the
processor's `CUSTOM_TRANSFORMATIONS` constant. The field and its JSON are
`output_time`, renamed from the unreleased `rewrite_latency`.

The dialog's body scrolls inside the window (never past the minimum 860×560),
keeping the title and Close put, and sizes to its content otherwise. Tile
numbers group their thousands, truncate instead of spilling, and use tabular
figures; profile names match app names; decimal seconds use a comma where the
language writes one. The chart's accessible label names today's and the
busiest day's counts.

The scene fixture is the worst case: five apps, four modes, long names, and a
six-digit word count. Docs and translations follow, and tests cover fallback
and transformation-only runs, the JSON field names, and the smallest window.

* history: group stats numbers by language and fit the dialog to its content

Number grouping and the decimal comma now live together in
desktop/i18n/numbers.rs, keyed on the interface language: thousands are "."
in German, Spanish, and Portuguese, a narrow no-break space in French,
Polish, Russian, and Ukrainian, and "," in English, Chinese, and Japanese,
while the decimal comma covers Polish and Spanish too. Stats numbers and
latency seconds call them instead of the English-only helpers, and the
numbers tests cover every language Hex ships.

When the sections fit, the dialog now draws no scroll body at all: no bar, no
edge-fade padding, and the counts and timings end on the Close button's edge.
The title and footer are measured rather than assumed, so the body's room
follows their real heights, and only a short window gets the scrolling body.
2026-11-18 03:38:56 -05:00
Dax 717932b905 fix: label an unset OpenCode rewrite model as automatic and log the model that answered (#1961)
* fix: label an unset OpenCode rewrite model as automatic and log the model that answered (#1955)

* fix: initialize the processing model on the macOS cleanup pass

* fix: gate the unranked model fixture to the Linux tests

* fix: don't log a failed automatic rewrite as opencode's default

* docs: describe where the rewrite model is recorded
2026-11-18 02:40:37 -05:00
Dax 10d103ff8c labs: bring the Modes editor back behind a lab (#1963)
* labs: bring the Modes editor back behind a lab

The read-only Output pane replaced the per-app Modes editor, so there was
no UI left to turn a mode's OpenCode rewrite on or off or pick its model
(#1960).

Labs › Modes editor (off by default, every OS) shows the old editor as a
main pane right after Output, adds it to the Command-number order, and
makes the Modes destination (the menu bar and `hex window show --pane
modes`) open it instead of Output. Off, the sidebar, `--pane modes`, and
every scene render exactly as before; turning it off while the editor
shows leaves that pane for Output.

The card, its translations, site/src/labs.json, the `hex settings` key,
and the Labs docs come with it.

* labs: flesh out the Modes editor lab's copy and docs

Say what the Modes editor actually edits (apps and websites, corrections,
OpenCode rewrite on or off and its model, transformations) in the CLI and
`hex settings` descriptions, keep the card line and its translations as
they are, note Modes in the sidebar and hex://settings/<pane> docs, align
the Labs table row, and exercise the off-while-Modes fallback by pulling
it out of poll into one tested helper.
2026-11-18 02:40:22 -05:00
Dax ebdd971ce1 fix(dictation): release the warm mic while the display sleeps or the screen is locked (#1956)
* fix(dictation): release the warm mic while the display sleeps or the screen is locked (#1953)

* fix(dictation): address review on warm mic away release

* docs: fix hex microphone resume wording
2026-11-18 02:34:47 -05:00
Kit Langton 2149e6c9ad feat(meetings): keep the recording surface continuous through every state
The meter is one node from its first frame to the finished meeting, Stop
says Stopping… in the row it was pressed in and leaves from there, the
waveform releases and fades when capture ends, the panel's actions show
only as far as the outline has uncovered them, and Reduce Motion lands
the outline and fades only what arrives.

replay_fixture.rs plays the whole path on one runtime (offer, Record,
live pill, panel, Stop, finished meeting) plus a quick start, a slow
start, an interrupted panel, a refused start and Reduce Motion, checks
each, and writes every frame with HEX_HUD_REPLAY.
2026-11-17 22:17:05 -08:00
Kit Langton cb2dedd4b6 Merge the Stop draft into the Record draft with one surface model
Integration of the two meeting HUD drafts, for review of the whole path:
t1609 at 776efee1e (Record handoff) and meeting-stop-motion at 6b11440f9
(Stop to finished). Neither draft is replaced by this branch.

Beyond resolving the two conflicted files this adds the recording host's
surface model (meeting_capsules/stage.rs): the outline and each layer are
tracks stepped every frame from their own position and speed, so a change
of state bends the motion instead of restarting it.
2026-11-17 21:45:04 -08:00
Dax 536cffef8d windows: let right alt alone fire on altgr layouts (#1950) (#1951)
AltGr layouts send a synthesized Left Ctrl (scan code 0x21D) before the
Right Alt, and GetAsyncKeyState reports it as a real Ctrl, so a modifier-only
Right Alt shortcut never matched there.

The listener's hook and the settings recorder's own hook leave that Ctrl out
of chord state and matching, and both feed one shared atomic, because the
recorder's hook runs even when Hex isn't listening. The recorder reads the
key state once per poll: a chord with a key keeps the Ctrl (AltGr+Q is
Ctrl+Alt+Q, never Alt+Q), and only a modifier-only chord drops it.

Modifier-only matching accepts either the view without AltGr's Ctrl or the
same read with it counted, so the `control+option` an AltGr-layout recording
made before this still fires, while a real Left Ctrl plus Right Alt doesn't
match Right Alt alone.

Left Ctrl bits are settled before each hook event, keyboard and mouse, from
GetAsyncKeyState, so a release that landed on another desktop heals on the
next event. AltGr's Ctrl-up keeps its bit until that settle, so a recorder
poll in the gap cannot count that Ctrl as a real one, and a real Left Ctrl
pressed right after still clears it and sets REAL.
2026-11-18 00:13:47 -05:00
Kit Langton 434acbdf6b fix(annotate): show Paste and ask before sending suggestions (#1945)
* Separate local annotation paste from a routed send

* Render the Paste chip with the capsule theme

* Exercise the ready capsule fixtures on the Linux golden runner

* Keep the displayed result on handoff and test pointer and keyboard selection

* Preserve matched rules through finalization and update checked capsule goldens

* Give the ready annotation one named action and a quiet search control

* Check the two ready surfaces, their accessible names and delivery states

* Put the ready line and its list on shared edges, with Paste a 28 pt button

The preview sat 12 pt from the wall while the list's header and names sat
16 pt in, and Paste was a 32 pt fill 4 pt from the top and bottom beside
28 pt icon boxes. The preview now starts on the list's edge, and Paste,
Search, Inspect and the close button are one row of 28 pt boxes 6 pt apart
and 6 pt from the walls. Paste's 32 pt chip still takes the click.

* Update the Linux references for the ready capsule's shared edges

* Nest the annotation preview in the capsule's left corners

The preview sat 16 pt from the left wall and 10 pt from the top and bottom,
so its 4 pt corners turned about a point 6 pt from where the shell's 14 pt
corners do. It now clears all three walls by 10 pt, the shell's radius less
its own, and the list's 16 pt margin stays for words. The guard that held
the preview on that margin now checks the corner centres instead.

* Update the Linux references for the nested annotation preview
2026-11-17 20:35:10 -08:00
Dax dc9401189f Fix #1947: hex restart waits for the old Hex to exit before relaunching (#1949)
* Fix #1947: hex restart waits for the old Hex to exit before relaunching

* hex restart: watch the old process from before the quit, and keep a forwarder's wait

- `ExitWatch` takes the Windows SYNCHRONIZE handle while the old Hex still
  runs, before the restart is sent, and closes it on drop; Unix keeps the pid
  and polls liveness. `wait(timeout)` covers both, and `hex restart` waits on
  it instead of on the local API, whose discovery file is retracted earlier in
  the drain.
- `hex start` no longer treats an exited child as failure by itself: a Linux
  `hex app` forwards to the systemd unit (or a 2.3.1 install's handoff) and
  exits once the forward is accepted, so a successful forwarder keeps the
  ordinary 20 s wait. Any other exit gets a 2 s grace for a successor to
  answer, then fails with a message that fits why the child exited.
- docs: the pid-wait test is Unix only, and the Windows path is compiled in
  CI without one.

* the restart watch's test is Linux only

macOS never takes an ExitWatch (it relaunches itself), so the test must not
name one there; Windows waits on a process handle and is compiled only.

* start: treat a 2.3.1 install's handoff as a start in progress

A Windows `hex app` from a legacy layout starts the managed copy in the
background and exits, so that exit is not a failure. `legacy::will_take_over`
is the predicate `take_over` already uses, checked here before the spawn, so a
successful child keeps the ordinary 20 s wait instead of only the 2 s grace.

The comments now say where a handoff actually exits: Windows, since Linux's
legacy relaunch execs and never returns; Linux's forwarder is the systemd
unit.

* restart's watch: refuse pid 0, clamp the Windows timeout, and test it everywhere

- `ExitWatch::new` refuses pid 0 (on Unix `kill(0, …)` means the process
  group), and the Windows wait clamps to `u32::MAX - 1` so a huge timeout can
  never become INFINITE.
- The wait's test moves out of the Unix-only module and runs on Linux and
  Windows, with the child halves taken from this same test binary by `--exact`
  and an environment variable, as `desktop::process_exit` does. Check Windows
  runs it under nextest.
- The docs now name `control/cli/launch.rs` and say where the discovery file,
  Linux's service lock, and Windows' instance event really go relative to the
  process, and the wait test's Linux-and-Windows reach.
- `will_take_over` is Windows-only and asked before the spawn, which is the
  launch it describes.

* comments: spell out when the old Hex's locks and files go, per OS

On Linux the host worker's drop of the service Server joins before
LocalApi::shutdown removes the discovery file, so the lock goes first; on
Windows the file goes first, then the tray, and the instance event last, at
process exit. The test comment also names the parent's wait_with_output as the
reap.

* restart's watch: loop the Windows wait on a clock, and gate the child on a pipe

`WaitForSingleObject` timeouts are tick-quantized and can report a timeout
before the requested interval has passed, which made the test's elapsed-time
assertion flaky. The Windows branch now loops against an `Instant` deadline,
asks once more with no timeout when the clock says the time is up, and returns
false on `WAIT_FAILED`.

The test's child no longer sleeps: it blocks on one byte of stdin, which the
parent holds open while it takes the watch and closes to end it, so neither
case races the clock. It also asserts pid 0 is refused.
2026-11-17 23:14:08 -05:00
Dax b5b5a27158 linux: send portal paste chords as evdev keycodes (#1941)
* linux: send portal paste chords as evdev keycodes (#1939)

KWin looks a keysym up in the desktop's active layout group. With a
non-Latin layout (Russian) active it can't find Latin `v` there, and its
fallback to a scratch keymap lost the held Ctrl: the app received a bare
`v` and Ctrl stayed down in the compositor.

NotifyKeyboardKeycode takes Linux evdev keycodes (KEY_LEFTCTRL 29,
KEY_LEFTSHIFT 42, KEY_A 30, KEY_C 46, KEY_V 47, KEY_ENTER 28), which name
the physical key, so the chord is the same in every layout. The session
already asks for the KEYBOARD device type, which keycode notifications
require, so only the method and its numbers change.

Not observed on a real KDE session.

* linux: resolve paste keycodes from the desktop keymap (#1939)

A fixed evdev code is wrong on a non-QWERTY Latin layout: Dvorak puts `v`
on KEY_DOT, so Ctrl+V would arrive as Ctrl+K, and AZERTY puts `a` on
KEY_Q, so select-all would be Ctrl+Q, which quits apps.

Paste now reads the compositor's keymap from a one-shot wl_seat keyboard
(bounded at 250 ms, the fd read through a File with a size cap, no
unsafe), parses it with xkbcommon, and resolves `a`, `c`, and `v` at level
1 across every layout group. A chord goes out as NotifyKeyboardKeycode
only when every group that has the letter agrees on one evdev code (the
xkb keycode minus 8); disagreeing groups such as `us,us(dvorak)`, an
ambiguous group, a missing letter, or no keymap at all send the whole
chord as keysyms, as before. Ctrl (29), Shift (42), and Enter (28) are
fixed codes, and Return never reads the keymap.

KWin 6.8's fake input answered a Latin `v` under a Russian layout from a
scratch keymap that lost the held Ctrl: the app got a bare `v` and Ctrl
stayed stuck (#1939). Mutter's keysym path drops the `v` the same way.

The keymap is read per chord because a portal session can outlive the
keymap it started under, and a layout or variant change replaces it.

Not observed on a real KDE or GNOME session.

* linux: read the shared keymap safely and check every fixed key (#1939)

Compositors hand every client the same keymap fd, and an fd's offset is
shared, so the sequential read left it at EOF: every later paste's read
came back empty, silently falling back to keysyms, and other clients
reading the same fd saw nothing. Read positionally instead
(`FileExt::read_exact_at`, never moving the offset) and strip the NUL the
desktop ends the keymap with.

Ctrl, Shift, and Return are only where the keymap says they are. Options
move them (`ctrl:swapcaps` puts Caps_Lock on 29, `ctrl:nocaps` leaves
Control_L on two keys), so keycode mode now requires Control_L on 29,
Shift_L on 42 when the chord holds shift, and Return on 28, each in every
layout group; otherwise the whole chord is keysyms. Return without a
keymap is a keysym again, as it was before.

The wait no longer spins: `guard.read()` returns Ok(0) when nothing is
ready, so the old loop retried without ever yielding. It now asks for a
wl_display sync once the keyboard exists and stops when that answers
(the keymap comes before it), stops at once when the seat has no
keyboard, and polls the Wayland fd with a deadline like `linux/clipboard`
does. The registry roundtrip before it keeps the comment saying what it
is: Wayland's unbounded startup roundtrip, as in `linux/paste.rs`.

Tests parse a self-contained inline keymap through xkbcommon (no
xkeyboard-config), read it twice through one fd, and cover the moved
modifier and Return fallbacks. The Cyrillic fixtures use the legacy
keysyms xkbcommon reports, in `ru,us` order.

Not observed on a real KDE or GNOME session.

* docs(linux): correct the keymap comments (#1939)

KEY_CAPSLOCK is 58, where `ctrl:swapcaps` puts Control_L, not a key no
keyboard has. The map now says what each key actually requires: a letter
needs one code across every group that has it, while Ctrl, Shift, and
Enter must be on 29, 42, and 28 in every group.

Mutter loses a keysym outside the active group, not `v` specifically.
The wtype paragraph keeps its original wrapping, and a paste that cannot
read the keymap says so at debug level.
2026-11-17 13:23:38 -05:00
Dax 919f726add sort language menus alphabetically (#1937)
* sort language menus alphabetically

* open language menus on their chosen language

Whisper's list is longer than its menu shows, so sorting it by name can
push the saved language's check below the edge. A select's press now
reveals the chosen row through Rune's scroll request, in the kit's
Select and Menu alike, and the map names the menu's order where it
still described the catalog's.

* docs: note language menus open on the chosen language
2026-11-17 11:31:28 -05:00
Dax 94cbe24733 fall back to the whole clip when a unified english stream drops its closing mark (#1934)
* fall back to the whole clip when a unified english stream drops its closing mark (#1933)

* tighten closing-mark check and cover the model gate
2026-11-17 06:02:10 -05:00