* reload personal config when imported .js files change
* watch and load the same config file kinds
the watcher skipped foo.d.js, foo.d.mjs, and foo.d.json because it treated
every .d stem as a declaration file, while the loader ran any file imported
by its exact name as javascript even though edits to it never reloaded.
both now use one predicate: ts, js, mjs, mts, and json in any case, excluding
only .d.ts and .d.mts declarations. the loader refuses other extensions when
a config imports them.
* ci: read release secrets from aws secrets manager
* ci: read the linux signing key from hex/release/RELEASE_SIGNING_KEY
* ci: hex's own aur and homebrew keys; the signing cert has no password
* ci: the signing certificate has no password
* ci: use the shared aur and homebrew keys
* docs: the shared homebrew deploy key is anomaly-release
* docs: the shared homebrew deploy key is anomaly-release
* site: own /hex/files, drop the r2 write credential (#1611)
* site: own /hex/files for installers, appcast, and dev notes
The site build now copies install-linux.sh, install-windows.ps1, and
packaging/macos/legacy-appcast.xml into its Worker assets, so the same
Worker serves them at /hex/files with the Content-Type and Cache-Control
the bucket objects had. The Installers and Legacy appcast workflows,
r2-put.sh, and their R2 write credential are gone.
The dev notes move to the one-commit dev-notes branch, published by
Release's dev-notes job with GITHUB_TOKEN only; the Worker proxies that
file at /hex/files/dev-notes.json (falling back to the bucket copy until
the first dev release creates the branch) and renders /hex/dev from it.
Both site Workers now bind hex-production-files, read-only in code, for
the frozen 2.3.1 feeds and artifacts, which lets hex-dev-files go. The
Site build runs the installer test and appcast check the removed
workflows ran, and the verify job compares the served bytes.
* docs: the site owns /hex/files and needs no R2 write credential
Hosting, secrets, old clients, and Linux packages describe the built
installers and appcast, the dev-notes branch, and the read-only bucket.
* 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.
The Rune 7d3ee6ca bump updated the Nix pin but not its output hash, so
nix build failed with a fixed-output mismatch.
cargoGitDependencies now records each Git dependency's revision beside its
output hash, and scripts/check-nix-git-pins.py fails when Cargo.lock names a
different revision. compile.yml runs it for Cargo.lock and nix changes.
Fixes#1397.
* 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
* fix(macos): clear stale permission rows and offer one-click recovery
* test(rune_ui): add Linux goldens for stale permission rows
* refactor(rune_ui): keep rune_ui.rs under code-shape ceiling
* Lowercase release file names; README downloads by channel (#456)
Release builds and the GitHub release mirror now name files hex-<version>-macos-arm64.{zip,dmg}, hex-<version>-windows-<arch>.exe and hex-setup-<version>-windows-<arch>.exe (Linux was already lowercase), as @vixalien asked in #456. Already-published files and the frozen 2.3.1 feeds keep their names; the release service's published names (hex, Hex.dmg, Hex.zip, hex.exe, HexSetup.exe) and the bundle (Hex.app) are unchanged, so the updater, installers, Homebrew cask, AUR and Nix are unaffected.
The README downloads table has Stable and Dev columns for every target, including the updater files. The site Worker serves /hex/download/dev/<target> (the dev alias) beside /hex/download/<target> (stable, or dev while there is none), and both now cover the bare updater files.
* Lowercase names in two remaining examples
* Lowercase the Windows executable in the CPU check step
From the 2026-10-29 security review:
- H1: Release signs each Linux executable with Anomaly's ed25519 key (HEX_RELEASE_SIGNING_KEY, .github/release/sign-linux.sh, which refuses a key that does not match linux-signing.pub) and publishes the signature as the linux-<arch>-sig target. The updater (updater/linux.rs SIGNING_KEY) and install-linux.sh refuse an executable without a valid signature over its SHA-256, before downloading it. Installed builds that predate this ignore the extra target, so the transition needs nothing from them.
- H3: the installers move to the locked .github/release/ (CODEOWNERS @thdxr); the Installers workflow publishes them from a sparse checkout of that directory.
- M1: the release service client is vendored as .github/release/release-client.sh instead of piping anoma.ly/release/client.sh into bash.
- M2: check-windows.yml gets permissions: contents: read; every third-party action is pinned by SHA.
- M3: resolve_url accepts only URLs on the manifest's host.
Ukrainian joins the Interface language picker on every OS, and every string
in the translation table has a Ukrainian column. macOS permission and
System Settings names follow Apple's Ukrainian labels so users can find them,
and "Voice Action" stays in English as in the other languages.
Co-authored-by: Dax Raad <d@ironbay.co>
The release service now counts running installs from the updater's User-Agent. Requests send hex/<build channel>/<version> (e.g. hex/dev/0.0.0-dev-171, hex/stable/2.3.1) instead of hex-updater, and failed checks back off at most to the hourly interval instead of six hours.
* Drop Input Monitoring: Accessibility covers the shortcut taps (t496)
* Regenerate goldens without the Input Monitoring row (t496)
* Regenerate the permissions golden after merging dev (t496)
* Run personal commands in embedded QuickJS instead of Bun
Hex now runs ~/.config/hex/hex.config.ts in-process: rquickjs on one worker
thread, TypeScript erased to same-position JavaScript with oxc's parser,
per-call time limits and a runtime memory limit, and no filesystem, network,
process, or timer API. Handlers return actions that Hex validates and runs on
its native executor. The Bun host, managed SDK provisioning, bun update, the
sdk/commands workspace, and their scripts and CI steps are gone; Hex writes
hex.d.ts typings instead, and hex commands check replaces bun run check.
Plan and measurements: docs/plans/quickjs.md.
* Spell out a range check that a new dependency's impls made ambiguous
* Rename voice-control to hex everywhere, without migrations
The Cargo package and binary are now hex, every OS keeps its data in a
hex folder, and VOICE_CONTROL_* variables are HEX_*. Hex is a fresh
app: the macOS voice-control rename, its symlink, and the Windows and
Linux beta settings imports are gone. The Windows installer gets a new
AppId so it never takes over an old voice-control install's entry.
* Format
* Drop the Windows paste-last default only the beta import used
Hex registers a StatusNotifierItem (with a dbusmenu: Show Hex, Quit Hex)
whenever the desktop has a tray host, so closing the window leaves an icon
like Slack or Discord. Clicking it opens the window. It re-registers when
the tray host restarts, and without one Hex runs unchanged.
* Linux ARM64, .deb, and .rpm releases
Both Linux architectures build natively on Ubuntu 24.04 runners (glibc 2.39
floor, Vulkan on both), publish linux-arm64 plus linux-<arch>-deb and -rpm
(hex.deb, hex.rpm) built with nfpm and installed on Ubuntu and Fedora in the
build job. hex-bin gains aarch64. Package installs report deb-<arch> or
rpm-<arch> through dpkg/rpm ownership and get the stable update command.
* build-linux.sh prints only the executable's path
* Linux releases link no system BLAS, as the Arch build shipped
* Linux build: keep libopenblas-dev for build.rs's dropped -lopenblas
* Local API wakes on the next connection; plan the shared engine service
The accept loop slept 10 ms whenever no connection was waiting, so every
loopback request paid up to 10 ms. Polling the listener instead (plus
TCP_NODELAY) took GET /health from 12.5 ms to 0.12 ms and a /streams
audio push from 7.4 ms to 0.28 ms.
* Engine plan: one engine process in Hex.app, the engine owns the models
The release service stores each file at files/<sha256>/<name> and serves it as an attachment named <name>, so names need no version or target: linux-x64 is hex, macos-arm64-dmg Hex.dmg, macos-arm64 Hex.zip, windows-x64/arm64 hex.exe, and the Windows installers HexSetup.exe (the service's names allow no spaces). Targets reference {file, sha256}, so the two Windows architectures may share a name. Builds and the GitHub release mirror keep versioned names; release-service.sh maps them. The updater, installers, and AUR PKGBUILD (hex-<pkgver>-linux-x64::<url>) take the URL from the manifest; the AUR and Homebrew renderers accept the new URLs, and the cask URL no longer interpolates the version.
Release no longer runs on tag pushes; stable is a dispatch from production only and refuses a version already tagged v<version> or app-v<version>. After every platform and the release service published, a tag job pushes v<version> on the released commit with the release deploy key (HEX_RELEASE_TAG_KEY, admitted by the new v* tag ruleset), then the GitHub release mirrors the files on that tag; a failed run leaves no tag. A check run pushes and deletes a throwaway v0.0.0-test-<run> tag to prove the ruleset admits the key. The release environment now admits only dev and production.
download-artifact unpacks a single matching artifact straight into the download folder; verify-artifacts.sh now files it under the name whose reported digest its SHA256SUMS has. The Windows build checks out into source/ because the Vulkan SDK installs into the workspace. verify-macos runs only after sign-macos succeeds. .github/CODEOWNERS names @thdxr; docs describe the split release.
Build jobs (Linux, Windows x64/ARM64, macOS, Windows installers, AUR and Homebrew staging) run repository code with no environment, secret, or id-token and produce unsigned files. Sign and publish jobs run in the release environment, check out only .github/release/, and run only those scripts and SHA-pinned actions on artifacts treated as data: macOS Developer ID signing, notarization, and stapling (from APPLE_SIGNING_CERTIFICATE, APPLE_NOTARY_KEY, and the APPLE_NOTARY_KEY_ID/ISSUER_ID variables), Azure Authenticode, the release service, the GitHub release, and the AUR and Homebrew pushes. Every artifact carries a SHA256SUMS whose digest its job reports; every job that downloads it checks that digest. Signed macOS builds are verified and launched in a job without secrets. macos-signed.yml is gone (a check run covers it); the site deploy is no longer part of Release.
Dev and check runs stamp 0.0.0-dev-$GITHUB_RUN_NUMBER with no tag lookup; versions are display text that the release service and the updater never compare, so builds numbered below 2.3.1 are fine. macOS dev builds take the run number as CFBundleVersion. The Linux and Windows installers and the Windows Setup.exe no longer refuse to install a lower version than the one installed. Docs describe following the channel's current release, required releases, rollbacks, and confirmed channel switches. Also drops an unused import that failed Check macOS.
dev.anoma.ly/release only tests the release service itself. The staging channel is gone: channel=check builds, signs, and verifies without publishing, and builds are tested before stable on anoma.ly/release's dev channel. The site (both environments), the Windows installer test, and the publish script read only anoma.ly/release. The installers take HEX_INSTALL_CHANNEL=dev to install the newest dev build onto the Dev update channel.
Release runs on pushes to dev (not docs- or site-only ones) in the new release-dev environment, which needs no approval and which the release service lets publish only the dev channel; a newer push cancels a dev run in progress, and the nightly schedule is gone. Dev builds publish only signed platforms: macOS and Windows targets wait for their signing values in release-dev. Stable stays in release, behind Dax's approval. The updater checks the Dev channel every 10 minutes and when the window gains focus (at most once a minute).
The commit could delete a subagent result or a turn that arrived after the
revert was staged, and a failed commit left the revert staged while
reporting it reverted, so the next prompt deleted everything after it.
Undo now looks again after staging and commits only if nothing came in.
Anything else, including a busy or failed commit (never retried), clears
the staged revert (DELETE /revert) and then disowns, since a prompt commits
a staged revert. If even the clear fails it says nothing more and reports
`unfinished`, unsaved so it can be tried again. Files go back only when the
turn ran an edit tool, so editor edits made meanwhile survive. Stage
retries stop at the caller's deadline.
A staged revert still showed in the Rune desktop, which ignores
session.revert, and the next prompt into the session committed it.
Undo now stages and commits, retrying while busy, and leaves it staged
only if the commit can't be made.
* Bump transcribe-cpp to 0.4.1
Adapts to the 0.4 API with behavior unchanged: capabilities() now returns a Result, ModelOptions takes the new defaults (weights are mmap'd), and a decode that 0.4 stops for repeating still returns its text. Same 69/69 transcripts on the vocabulary corpus; peak footprint about 0.9 GB to 0.15 GB on Metal.
* Keep Windows model delete, update and failed swaps working with mapped weights
* Allow Linux to ignore the failed swap's selections
CaptureTarget and CaptureCommand::{Start, Discard} through
RecognitionControl::CaptureCommand; a discarded capture leaves no outcome and
never counts against MAX_FINISHING. The snapshot's recording gains target and
worked, settled captures an error. begin_picking hands the picker the capture
shortcut and Escape from Hex's tap. The shortcut arms on press and records
once a modifier comes up; Esc before then records nothing.
Against Apple's SpeechAnalyzer on 36 real captures, Parakeet Unified
English's word times run late (starts +280 ms median, about +520 ms after
a pause; ends +180 ms), with no drift and no seam cost. HexTranscriber now
moves starts earlier by 280 ms, or 520 ms after a gap of 250 ms or more,
and ends by 195 ms, clamped at 0, start <= end, and never backwards. The
constants are keyed to the pinned model file, so another model or a new
pin keeps raw times until measured again; a test says so. The capture's
words and model now come from one transcription selection.
Every change to a capture (started, the screen recording, stopped, the
engine's stages, settled) publishes a CaptureSnapshot; snapshot() reads
it and watch() wakes on changes, coalescing to the latest. Engine progress
moves a capture on but never settles it. The capsule, the router, and
hex capture list read this instead of reaching into the host.
The capture shortcut (default ⌥⇧S) is a third target in suppression:
a fresh press starts a capture and the next stops it. While a capture
records, the session tap also reports pointer events and Shift to
Capture::input(); Escape cancels a recording capture before any
dictation job. Settings › Experiments › Scrawl (capture builds, with
the experiment on) holds the opt-in, shortcut, Screen Recording,
transcriber, captures folder, and retention, defers to a running
Scrawl.app until "Use Hex for captures", and Hex imports Scrawl's
settings once, read-only. Every capture.* setting has a hex settings
key.
Copy Scrawl's `crates/capture` from kitlangton/scrawl, branch
`engine/split`, commit e351ddb28be47c77481cb6821cc72d7f8fe7c769 (e351ddb),
without history, keeping the package name `scrawl-capture`, and its
`docs/app-handover-spec.md` as `docs/plans/capture-handover-spec.md`. Hex
depends on it by path instead of the Git pin at 86d7d6c; the Nix
`outputHashes."scrawl-capture-0.3.13"` entry goes.
Workspace: `crates/capture` is in `[workspace] exclude`, so `cargo build`,
`cargo test`, and `--workspace` never build it (Linux, Windows, and Nix
included). It compiles only as the `capture` feature's macOS dependency,
sharing the root Cargo.lock and target/. The root package stays a member
without being listed, since listing "." defeats `exclude`. On macOS
`scripts/check` and the macOS workflow name it (`-p voice-control
-p scrawl-capture --features capture`) to lint and test its 257 tests.
API adaptations in capture_host:
- `Finished` gains `gaps` and `missing_transcript`; the host records them
and `hex capture status` (human and JSON `last`) shows them.
- `Engine::new` bridges the crate's log to `Host::log` when no sink is
set, so Hex's own `TracingLog` sink goes and each line is logged once.
- Scrawl now writes its bundle files 0600; Hex still tightens
recording.mp4, the window log, and folders.
- Nothing on Hex's path reads ~/.config/scrawl or writes under
Application Support/scrawl: the crate does that only after
`enable_scrawl_host_defaults`/`enable_file_log`, which Hex never calls.
Scrubbed (synthetic values): a file:///Users/<name> path in ax.rs, the
com.kitlangton.UpDown / dev.kitlangton.UpDown test bundle IDs in
handoff.rs and phone.rs (now com.example.UpDown), and a personal device
name in a phone.rs test. Kept: Scrawl's own product IDs
(dev.kitlangton.scrawl, .helper) and its public GitHub releases URL.
fmt and clippy -D warnings, no behaviour change: `cargo fmt` on five
files; `chunks_exact(N)` to `as_chunks::<N>()` (19 sites); collapsed
`if let` chains in capture/macos.rs and pipeline.rs and a `match` in
page.rs; `type` aliases for a drag start and two ingest hooks; explicit
lower bounds on two test `match` range arms in keyframes.rs;
`slice::from_ref` for two one-element slices; `and_then` for
`map().flatten()`; a dropped `to_owned`; `#[allow]` for one
`too_many_arguments` and one `single_range_in_vec_init`.
cfg(hex_capture) is now a macOS build with the capture feature, debug or
release, so Kit can run captures in a release Hex. Builds without the
feature are unchanged: no experiment, scrawl-capture refused unsupported,
the crate not compiled. hex dev capture-replay stays debug-only.
HEX_CAPTURE=1 scripts/build-app.sh builds with the feature and signs
scrawl-helper into Contents/MacOS, where the engine looks for it, with
Hex's identity (embedded plist anomaly.hex.scrawl-helper), hardened
runtime, and no entitlements, before the app. release-app.sh refuses
HEX_CAPTURE, and validate-app.sh refuses a bundle with scrawl-helper or
the capture host in hex.
Pin scrawl-capture to 86d7d6c. The capture-audio thread now calls
Capture::stop the moment a capture is sealed, so the screen, window log,
and input stop at once; the finisher gets only the SealedCapture. This
restores one capture recording at a time, one writer, at most two
waiting, and busy beyond that.
Engine::new no longer touches TIS, so prepare_on_main_thread is gone;
CaptureHost::start installs the tracing log sink before building the
engine. HexConfig sets autocrop on and agentContext off deliberately,
and nothing on Hex's path reads ~/.config/scrawl/config.json.
Replace capture_host's stand-in engine and bundle writer with the
scrawl-capture crate (kitlangton/scrawl engine/split @ ce741ee), features
screen + helper only. Hex owns the audio (AudioIn::External with the
dictation timeline's start offset and gaps), transcribes on the dictation
engine's loaded model, runs the engine with SharedResources::none(), routes
its log to tracing, and writes owner-only .scrawl bundles to its own
captures folder.
One capture exists at a time, including its finish: Scrawl's engine stops
recording the screen only inside Capture::finish and shares its input
telemetry across captures, so a start while the previous capture is
starting, writing, or cancelling is refused `busy`. Every capture is
tracked from its start until its collector or the finisher settles it, so
a failed start raced by stop can't leak and wedge later starts. The
engine's log sink and keyboard-layout map (TIS, read by Engine::new) are
claimed on the main thread before any engine is built.
The dependency is optional and macOS-only behind a new `capture` Cargo
feature; build.rs sets cfg(hex_capture) only for macOS debug builds with
the feature, so release, Linux, Windows and Nix never compile the crate.
scripts/check and macOS CI test with the feature.
- Word chunks wait while dictation records or transcribes and run as
engine Foreground work, which an open live stream defers until it ends.
- CaptureSink trims only against the capture start and keeps every
frame through timestamp jitter.
- Gap padding stops at the 20 minute limit.
- One capture-finish thread writes stopped captures; at most two wait and
later starts are refused busy. Outcomes are recorded directly, the engine
is held weakly, and shutdown joins capture threads within 2 s.
- Capture folders are 0700 and files 0600; captures_dir errors propagate.
- capture_host and its call sites compile only in debug macOS builds.
- CONTROL_VERSION back to 1: a new command is not a breaking change.
Step 3 of folding Scrawl into Hex, ahead of the scrawl-capture crate: a
debug-only `capture` experiment, a bounded capture sink on the dictation
timeline, word-timestamped foreground transcription on the shared engine, a
stand-in engine that writes a bundle, and `hex capture start|stop|cancel|status`
over POST /control (CONTROL_VERSION 2). `hex dev capture-replay` runs the
same host on WAV files.
Work lands on dev, the default branch. production holds what was released
(app-v2.3.1) and moves only by a fast-forward from dev. Pushes to dev run the
checks, test builds, and the dev site deploy; stable releases run only from
production or an app-v tag, and the TypeScript SDK's version pull request
targets dev while publishing waits for production.