---
title: "Command lines"
description: "Every command-line tool in the repo: the ctl adapters and helpers (Python, Swift, TypeScript) and the Rust binaries. The description and usage come from each tool's own header; a Swift one's build: line names the recipe that builds it."
type: "generated"
source: "docs/reference/cli.md"
---

> **Generated** from the code

## ac2_bridge

The STT worker wire in front of an audio.cpp Nemotron 3.5 streaming session.

- source: `benchmarks/audio-cpp-rs/bridge/src/bin/ac2_bridge.rs`

## admin-popout

`admin-popout`: the Admin's event timeline in a GPUI window (BS12 of), the first of the Admin's hot views under shell option B ("the Admin stays Tauri React inside the one app; high-rate views open as GPUI sidecar windows").

- source: `apps/admin-popout/src/main.rs`

## admin-sessions-popout

`admin-sessions-popout`: the Admin's Live sessions in a GPUI window (BT6 of), the Admin's second hot view under shell option B ("the Admin stays Tauri React inside the one app; high-rate views open as GPUI sidecar windows").

- source: `apps/admin-sessions-popout/src/main.rs`

## admin-shadow

`admin-shadow`: the GPUI Admin (ADR 0060). The ask: migrate the Admin from TypeScript to GPUI one panel at a time; keep the TS Admin as it is and build a shadow beside it, so the two can be reviewed side by side.

- source: `apps/admin-shadow/src/main.rs`

## approvalctl

Ask the operator for an approval through fox9's owner-local approval socket (the opskat shape), from a shell.

- source: `tools/approvals/approvalctl.py`

```
approvalctl.py request --type exec --asset "web-01" --command "systemctl restart nginx"
approvalctl.py request --type update --asset "the fleet manifest" --field hosts --field budgets
approvalctl.py batch --items '[{"type":"exec","asset":"web-01","command":"…"}, …]'
approvalctl.py status
approvalctl.py ask --question "Which branch should I base this on?" --option main --option release
approvalctl.py status | fox9grants approve sign --words amber falcon | approvalctl.py redeem
```

## audioctl

The Mac's audio OUTPUT devices as typed JSON, and one typed action to change the default (audioctl before; the mechanism behind two future `pi_mac_control` actions, `output_devices` / `output_set`). CoreAudio only, no TCC grant of any kind, one `swiftc` file;

- source: `runtime/audioctl/audioctl.swift`
- build: `just adapters::build-audioctl`

```
vulpine-audio list                          every output device, the default marked
vulpine-audio get                           the default output + its volume
vulpine-audio set --device <uid|name>       make it the default output
vulpine-audio volume --level 0.0..1.0       set the default output's volume
vulpine-audio watch                         one JSON line per default-output change (
```

## callctl

Is the operator in a call? One bounded JSON receipt from what the OS already knows (callctl before): which processes hold the microphone (CoreAudio process objects, macOS 14+) and whether any camera is running anywhere (CoreMediaIO).

- source: `runtime/calls/callctl.swift`
- build: `just adapters::build-callctl`

```
vulpine-call status [--exclude <bundle-id,…>] [--no-ax] [--state <path>|--no-state]   one receipt now
vulpine-call watch  [--interval 2] [--exclude …] [--no-ax] [--poll]                   a receipt on every change
```

## capture_record_ctl

`vulpine-glyphctl capture --record` (CC2): records a window or a region with narration and ⇧ marks through `capture_record::record` (the entry the conversation window's Capture button calls), then makes the capture.v1 bundle in the Glyph's private store and prints one JSON line of counts (never words, never pixels).

- source: `apps/glyph/src-tauri/src/capture_record_ctl.rs`

## convo-freya

`convo-freya`: the conversation window, each turn with its tool chips, jobs and panels, replayed from a fixture (`--replay`) or observed live and read only from a gateway (`--observe`).

- source: `apps/convo-freya/src/main.rs`

## convo-gpui

`convo-gpui`: the conversation window in GPUI (BS2 of; the streaming transcript). The Glyph's sidecar under ADR 0046 as amended 2026-10-18: the Glyph looks for `convo-gpui` first and falls back to the frozen `convo-freya` (`apps/glyph/src-tauri/src/convo_sidecar.rs`).

- source: `apps/convo-gpui/src/main.rs`

## daf-rs

`daf-rs`: run the DAF front-end over a mic/reference WAV pair (16 kHz mono, PCM16 or float) for parity against LocalVQE's `daf_cli` and for archive replays.

- source: `crates/aec_daf/src/bin/daf_rs/main.rs`

## decidectl

`decidectl` — the ADR 0034 adapter over the decision client: one JSON line per request on stdin, one per outcome on stdout, answered as they finish (so identical concurrent lines share one request). stderr carries only usage errors; a request's state (the utterance) is never logged.

- source: `crates/decidectl/src/main.rs`

## denoisectl

The streaming GTCRN speech enhancer as a fox9 adapter (ADR 0034 shape, pure Swift, one swiftc file). A WAV in, a denoised WAV out, one JSON receipt on stdout with the per-frame cost and where Core ML put the graph.

- source: `tools/denoise/denoisectl.swift`
- build: `just adapters::build-denoisectl`

```
denoisectl status [--model <GTCRN.mlpackage>] [--compute all|cpu|cpu-gpu|cpu-ane]
denoisectl run    --in <a.wav> --out <b.wav> [--model …] [--compute …]
denoisectl batch  --in-dir <dir> --out-dir <dir> [--model …] [--compute …]
```

## doorctl

The gateway's headless door from a shell on the gateway's host.

- source: `tools/gateway/doorctl.py`

```
doorctl.py tool <pi_tool> (--file F | --json J) [--timeout S]
doorctl.py pipeline dispatch <file>     # {name, host, repo?, task, stages, acceptance?}; verb pipeline
doorctl.py pipeline advance <file>      # {name, pane, wait_s, host?, repo?}; verb advance
doorctl.py pipeline follow <name> --host H [--repo R] [--max-s N]
```

## dotctl

Hand one task to the operator's OpenAI Dot through the loopback dot2api, and read it back.

- source: `runtime/dot_worker/dotctl.py`

```
dotctl submit --task <text>     POST /v1/tasks       -> task id (queued)
dotctl poll [<task_id>]         GET /v1/tasks/{id}   -> status, and the reply text when completed
dotctl status                   the worker marker, the 0600 key, GET /readyz -> ready
```

## embedctl

Apple's on-device NLEmbedding (sentence, English) as a fox9 adapter (ADR 0034 shape): text in, a JSON vector out, no model download, no extra RAM beyond the framework's own. One `swiftc` file.

- source: `tools/retrieval/embedctl.swift`
- build: `just adapters::build-embedctl`

```
embedctl embed --text "<sentence>"                      one vector
embedctl embed --jsonl <records.jsonl> [--field text] [--id-field id]
embedctl status
```

## evidence-replay

`evidence-replay`: aggregate-only corpus replay CLI.

- source: `crates/evidence_harness/src/main.rs`

## fanout-aec-replay

`fanout-aec-replay`: drive the LIVE-shaped wake-feed AEC over a v248 session PCM archive, row by row in index order — the same inputs the gateway has at runtime: raw 24 kHz mic chunks through the fanout normaliser, TTS chunks as sent, the playout stamps on the heartbeats, generation changes — and write the echo-cancell…

- source: `crates/voice_gateway/src/bin/fanout_aec_replay.rs`

## feedctl

The operator's feed store, headless.

- source: `tools/feeds/feedctl.py`

```
feedctl refresh [--opml PATH]          # fetch every feed the OPML names
feedctl unread [--limit N] [--before ID]
feedctl read ID | --nth N              # one item's text; does not mark it
feedctl mark ID                        # mark read; re-marking is a no-op
feedctl discover URL [--opml PATH]     # find a site's feed; writes nothing
feedctl add URL [--opml PATH]          # find it and add it to the feed list
feedctl import FILE [--opml PATH]      # merge another reader's OPML (no fetch)
feedctl remove FEED_URL [--opml PATH]  # take one feed out of the list
```

## fleetctl

The fleet adapter (ADR 0034 style: outside the gateway, fox9-owned names). Probes every host in the fleet manifest over bounded key-based ssh, labels ssh peers by fleet host, and emits one JSON snapshot line per interval on stdout for the gateway's `[fleet]` task.

- source: `retired/fleetctl/fleetctl.py`

## focusctl

What the operator has FOCUSED and SELECTED, as one bounded JSON receipt, read through Accessibility (feeds). The AX sibling of `runtime/screen/screenctl.swift`: where screenctl photographs a window and OCRs it, focusctl asks the focused element for its exact characters.

- source: `tools/focus/focusctl.swift`
- build: `just adapters::build-focusctl`

```
focusctl read [--max-chars 4000] [--deny <bundle-id,…>]
focusctl secure                       secure-input state only, no AX at all
```

## fox-gpui

`fox-gpui`: the fox alone in its window, its clips picked by an observed session's presence.

- source: `apps/fox-gpui/src/main.rs`

## fox9-coreml-stt

Copyright (c) fox9 contributors. Licensed under the MIT licence (see the workspace `license` field).

- source: `crates/coreml_stt/src/bin/fox9_coreml_stt.rs`

## freya-kit-gallery

Freya-kit-gallery: Vigil's PanelGallery (apps/vigil/src/showcase/PanelGallery.tsx) drawn by the kit.

- source: `apps/freya-kit/src/bin/gallery.rs`

## globectl

The Globe/fn key as press and release lines. The Globe key is a modifier the Carbon hotkey path cannot register, so this is a LISTEN-ONLY session event tap on flagsChanged keycode 63 (yapping's FnKeyMonitor shape).

- source: `tools/globe/globectl.swift`
- build: `just adapters::build-globectl`

```
globectl                  one JSON line per transition on stdout:
```

## glyph

Prevents additional console window on Windows in release, DO NOT REMOVE!! ![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]

- source: `apps/glyph/src-tauri/src/main.rs`

## glyphctl

`glyphctl` is the old name of `vulpine-glyphctl`, kept for one release. This binary sits beside vulpine-glyphctl in the bundle (and in a cargo target) and runs it under the old name, with the same arguments, stdin, stdout and exit code; vulpine-glyphctl then says one deprecation line on stderr.

- source: `apps/glyph/src-tauri/src/bin/glyphctl.rs`

## gpui-load-fast

The four realtime loads in plain Rust GPUI: BO5's gpuix window written the way Zed and gpui-kit apps are written (BQ7's sketch, docs/implementation-reviews/gpui-under-load-2026-10-18.md §3): an entity per panel drawn as a cached view, an entity per tree card, a `uniform_list` for the log…

- source: `spikes/2026-10-18-gpui-plain/fast/../src/main.rs`

## gpui-load-kit

The four realtime loads in plain Rust GPUI: BO5's gpuix window written the way Zed and gpui-kit apps are written (BQ7's sketch, docs/implementation-reviews/gpui-under-load-2026-10-18.md §3): an entity per panel drawn as a cached view, an entity per tree card, a `uniform_list` for the log…

- source: `spikes/2026-10-18-gpui-plain/kit/../src/main.rs`

## gpui-load-pre

The four realtime loads in plain Rust GPUI: BO5's gpuix window written the way Zed and gpui-kit apps are written (BQ7's sketch, docs/implementation-reviews/gpui-under-load-2026-10-18.md §3): an entity per panel drawn as a cached view, an entity per tree card, a `uniform_list` for the log…

- source: `spikes/2026-10-18-gpui-plain/pre/../src/main.rs`

## head-mlxc

`head-mlxc parity --export <dir> --cases <cases.jsonl> [--receipt <file>] [--cache-limit-mib N]`: replay head_export.py's function over a case file through mlx-c and gate it against head_server's answers (max |Δp| ≤ 1e-4, the same argmax per question).

- source: `crates/head_mlxc/src/main.rs`

## healthctl

Apple Health facts from a read-only SQLite store.

- source: `runtime/health/healthctl.py`

```
healthctl metrics                               which metrics the store holds (the closed set)
healthctl daily  --metric M --days N            per-day aggregates over the last N days (N <= 366)
healthctl recent --metric M [--n K]             the newest K readings (K <= 200, default 5)
healthctl ingest <export.json>                  load a Health Auto Export-style JSON into the store
```

## homectl

The events-in adapter (ADR 0034).

- source: `retired/homectl/homectl.py`

```
homectl init [--url U] [--token-file F] [--force] [--include-settings]
homectl list                                          the subjects in home.json
homectl probe                                         connect, count mapped subjects present upstream
homectl subjects [--compact] [--no-exposed]           every controllable subject with its live state (one read)
homectl aliases [--write]                             the upstream's aliases for mapped subjects it exposes to its
homectl recap [--since 3h] [--until T] [--limit N]    what happened to the MAPPED subjects over a window, from
homectl run [--replay TAP.jsonl]                      emit the contract forever (or replay a ha_events tap)
homectl act --subject S --verb V [--value N]          verbs-on-subjects (contract 3): one receipt on stdout
```

## house-lexicon

`house-lexicon`: the STT house lexicon from the command line — the terms the gateway builds from the homectl subject map and the `home-aliases.json` beside it, and a near-miss dry run that says, per term, whether it fired on a final and why not (distance against its length-banded budget, a tie with a…

- source: `crates/voice_gateway/src/bin/house_lexicon.rs`

```
    house-lexicon [--map <home.json>]
    house-lexicon [--map <home.json>] --dry-run <final text>
    house-lexicon [--map <home.json>] --dry-run-file <finals.jsonl>
```

## kiss3d-native

CF12 spike A: kiss3d 0.47 on native_kit::surface3d, on GPUI's own MTLDevice.

- source: `spikes/2026-10-24-gltf-vrm/kiss3d/src/main.rs`

## meetctl

The Meet local path's capture adapter (ADR 0039, docs/contracts/meeting.v1.md).

- source: `tools/meet/meetctl.swift`
- build: `just meet::build-meetctl`

```
meetctl start [--store <dir>] [--notice-given] [--notice-text <s>] [--pid <pid> | --bundle-id <id>]
meetctl start --fixture <dir> [--realtime] [the same decode / diarizer / events flags]
meetctl stop   [--state <path>]     SIGTERM to the running start, waits for its final state
meetctl status [--state <path>]     one JSON line
meetctl notice [--notice-text <s>]  the recording notice fox9 must say / show before capture
meetctl opt-out <call_id> | forget <call_id>  [--store] [--state] [--events-socket | --events-file]
meetctl sweep [--store <dir>] [--days <n <= 7>] [--dry-run]
```

## memoctl

Phone reach rung 0: a Voice Memo recorded on the phone or watch becomes a brain turn or a note.

- source: `tools/voice_memos/memoctl.py`

```
memoctl scan [--dir DIR] [--backfill] [--launch]  # one pass; prints ONE JSON line
memoctl consume [--drain]                         # new rows -> pi_todo / the background queue
memoctl drain                                     # queued memos -> the gateway (a turn, once each)
memoctl status                                    # seen count, state paths
```

## msgctl

The operator's iMessage channel: send one text to the operator's own handle, read who messaged since when.

- source: `tools/messages/msgctl.py`

```
msgctl send --text "The fleet bug landed." --confirm
msgctl unread --since 2h            # 30m | 2h | 1d | ISO 8601
```

## nsh-convo

BQ17's nsh window: the conversation window's turn log as ONE nsh TSX module (`../app`, built with `nsh build`) in a GPUI window (gpui-fast 0.1.9, the GPUI nsh draws with), observing a gateway READ ONLY.

- source: `spikes/2026-10-18-nsh-convo/host/src/main.rs`

## nsh-convo-fixture

The fixture gateway both conversation windows observe, on loopback.

- source: `spikes/2026-10-18-nsh-convo/host/src/fixture.rs`

## nsh-load

BQ8's nsh column: one GPUI window (gpui-fast 0.1.9, the GPUI nsh draws with) whose root is nsh's `AppView` running `../app/App.tsx` (built with `nsh build`), so BO20's harness measures it exactly as it measures the plain-GPUI columns: the same flags, `window-<pid>.json`, and `load-<pid>.jsonl` rows whose…

- source: `spikes/2026-10-18-gpui-plain/nsh/host/src/main.rs`

## nsh-views

BQ8: what one nsh view costs in memory. `nsh-views <bundle.nshc> <n> <settle s>` opens one GPUI window (gpui-fast 0.1.9, no focus, mouse passing through) with `n` AppViews side by side, each running the bundle in its own engine and QuickJS VM, waits `settle` seconds, prints one JSON line (n, resident MiB, phys_footprin…

- source: `spikes/2026-10-18-gpui-plain/nsh/host/src/views.rs`

## omuzaki-native

CF12 spike B: omuzaki's VRM stack on native_kit::surface3d, on GPUI's own MTLDevice.

- source: `spikes/2026-10-24-gltf-vrm/omuzaki/src/main.rs`

## orb-gpui

Orb-gpui: the Glyph's overlay orb drawn natively. The ask: "the orb native by default, the WebKit orb kept as a labeled option".

- source: `apps/orb-gpui/src/main.rs`

## presencectl

Read or set the operator's room over the gateway's owner-local Admin socket.

- source: `retired/presence/presencectl.py`

```
presencectl get                 -> {"ok": true, "room": "office", "source": "frontend_turn", "fresh": true, ...}
presencectl set --room kitchen  -> stamps `explicit` evidence, returns the same shape
```

## providerctl

Is an upstream model provider degraded? (d)

- source: `retired/providerctl/providerctl.py`

```
providerctl.py status [--timeout 6] [--only openai,anthropic]
```

## ptzctl

Nudge an ONVIF PTZ camera (adapter tier, ADR 0034; no gateway).

- source: `runtime/vision/ptzctl.py`

```
ptzctl.py --host 192.0.2.31 --profile MediaProfile000 --pan -0.5 --seconds 1.0
ptzctl.py --host 192.0.2.27 --profile MainProfileToken --tilt -0.5 --seconds 1.5 \
ptzctl.py --host 192.0.2.31 --profiles          # list media profiles + PTZ node
```

## recordctl

The capture recorder's platform half (recordctl before): a window or a region recorded with ScreenCaptureKit and the microphone, ⇧ marks drawn over it while it records, written as the raw recording that crates/capture_record makes into a capture.v1 bundle.

- source: `tools/capture/recordctl.swift`
- build: `just adapters::build-recordctl`

```
vulpine-record record --out <dir> [--target window|region|frontmost] [--max-seconds 60] [--no-mic]
vulpine-record ocr    --rgba <file> --width <w> --height <h> | --in <image>   Vision text: {"text": ...}
vulpine-record frame  --movie <mov> --at <ms> --out <png>   the movie's frame at a time on the recording's clock
vulpine-record status                                   the grants it would use, never prompting
```

## remotectl

The Chromecast Voice Remote as a hold-to-talk microphone over CoreBluetooth. The remote's voice key speaks Google's ATVV GATT service: hold the key and it streams 16 kHz IMA ADPCM, let go and the stream stops. remotectl decodes that to raw PCM and marks the edges.

- source: `runtime/remote/remotectl.swift`
- build: `just adapters::build-remotectl`

```
remotectl scan   [--seconds 4]                         the ATVV remotes this Mac can see, one JSON receipt
remotectl listen [--out <path>|-] [--device <uuid>] [--find-seconds 8] [--seconds N]
```

## roomctl

One interface for "make this room say / play something".

- source: `retired/roomctl/roomctl.py`

```
roomctl init                      # write the default rooms file for this house
roomctl list                      # rooms, drivers, entities
roomctl probe --room office       # driver reachability + current state
roomctl speak --room living-room --text "Dinner is ready."
roomctl play  --room office --wav /path/clip.wav
```

## rune-light-orb

rune-light on native_kit::surface3d, a spike.

- source: `spikes/2026-10-24-rune-light/src/main.rs`

## satellitectl

One request to the bridge's control socket: `node src/satellitectl.ts <socket> '<json>'` e.g. node src/satellitectl.ts ~/.local/state/foxline/satellite/home-assistant-voice-09fe50.local.sock '{"op":"timer_start","seconds":300,"name":"pasta"}'

- source: `apps/satellite-esphome/src/satellitectl.ts`

## scenario-runner

Live scenario smoke runner: executes declarative TOML scenarios against a running gateway websocket (typically the mini's gateway, over ssh or LAN).

- source: `crates/voice_gateway/src/bin/scenario_runner.rs`

## screenctl

One frame of what the operator is looking at, as TYPED, BOUNDED input. Never freeform control of the desktop: this tool reads, names, and writes one file.

- source: `runtime/screen/screenctl.swift`
- build: `just adapters::build-screenctl`

```
screenctl window --out <path.jpg> [--height 900] [--quality 70]
screenctl display --out <path.jpg> [--height 900] [--quality 70]
```

## speechctl

Apple's on-device SpeechAnalyzer as a fox9 SECOND OPINION (feeds; speechctl before). One `swiftc` file, no packages, the ADR 0034 adapter shape: a WAV in, JSON lines out, exit code says whether it worked.

- source: `runtime/speechctl/speechctl.swift`
- build: `just adapters::build-speechctl`

```
vulpine-speech status     [--locale en-US] [--module transcriber|dictation]
vulpine-speech transcribe --in <path.wav> [--locale en-US] [--module transcriber|dictation]
vulpine-speech transcribe --stdin --pcm-f32le [--rate 16000]        raw PCM on stdin, nothing on disk
vulpine-speech serve      --socket <path> [--locale …] [--module …]   one process, many requests
vulpine-speech ask        --socket <path> --in <path> [the transcribe flags]
```

## surface-smoke

Coordinated owned-window QA: nominal six seconds plus a short post-remove observation. Existing operator tooling must enforce the approved hard deadline.

- source: `spikes/gpui-surface-extraction/smoke/src/main.rs`

## tapctl

What this Mac is PLAYING, captured as audio, no driver, no Screen Recording. A Core Audio process tap in a private auto-start aggregate device, the mechanism four dictation apps on the swift shelf use (said, FineTune, livesub, daisy — vet 2026-09-19).

- source: `tools/audio/tapctl.swift`
- build: `just adapters::build-tapctl`

```
tapctl capture --out <path.wav> [--seconds 8] [--pid <pid> | --all]
tapctl duck --pid <pid> [--gain 0.2] [--ramp-ms 150] [--seconds 600]
tapctl procs
tapctl ear --out <raw.f32> --pid <pid> [--pid ...] [--watch-pid ...]
```

## tauri-load

The toolkit showdown's Tauri/WebKit contender: a Tauri 2 window whose React page, in WKWebView, runs the rig's four loads (spikes/2026-10-17-native-load) and the upped set (spikes/2026-10-18-toolkit-showdown/upped.json), the stack the Glyph and the Admin already use.

- source: `spikes/2026-10-18-toolkit-showdown/tauri-load/src-tauri/src/main.rs`

## three-rs-native

three-rs on native_kit::surface3d, a spike.

- source: `spikes/2026-10-20-three-rs-native/src/main.rs`

## threejs-wgpu

Route 3, the native baseline: the three scenes drawn with wgpu 30 (Metal) offscreen, read back (copy_texture_to_buffer, map_async, a blocking poll) as BGRA, freya-load's copy route at the three.js scenes' sizes.

- source: `spikes/2026-10-18-threejs-native/wgpu/src/main.rs`

## typst-panels-baseline

The binary-size baseline: reads a JSON file and prints its byte count, with std and serde_json only, so `typst-panels-measure` minus this is what the typst crates add.

- source: `spikes/2026-10-18-typst-panels/src/bin/baseline.rs`

## typst-panels-measure

The measure: load the catalog, then compile each template's sample cold, warm with the same data, and warm with changed data, in both schemes; print one JSON line and write the SVGs.

- source: `spikes/2026-10-18-typst-panels/src/bin/measure.rs`

## uniffi-bindgen

Uniffi's bindgen CLI, built from the pinned uniffi so the generated Swift matches the scaffolding.

- source: `crates/phone_core/src/bindgen.rs`

## visionctl

"who is there?" for one camera, as a verb with a receipt (ADR 0034 adapter tier).

- source: `runtime/vision/visionctl.py`

```
visionctl.py describe --place backyard            # fox9 name from home.json
visionctl.py describe --subject camera-1
visionctl.py describe --camera amcrest_1 --question "is the gate open?"
visionctl.py cameras                              # what the map knows
visionctl.py frames --out ~/.local/state/vulpine/admin/frames --height 240
visionctl.py frames --out … --event <frigate event id> --subject <announcement id>
visionctl.py describe --event <frigate event id> --clip [--clip-frames 8]
visionctl.py change --place backyard [--events PREVIOUS CURRENT]
```

## visual-readback

`visual-readback <jobs.json> <out_dir>`: `jobs.json` is a list of `{"id", "script"}`; each job's readback lands in `<out_dir>/<id>/` as `readback.json`, `readback.txt` (what a brain would read) and `composite.png` (the drawing with its GPU pictures pasted in, for a person's spot check).

- source: `spikes/2026-10-25-visual-readback/src/main.rs`

## visuals-showcase

BW2 ("a showcase of the new capabilities like shaders and webgpu/webgl/threejs ... by showing a few cool novel ideas we can select some new features to build off of them"): one GPUI gallery window with a live tile per native visual capability and five concept tiles to pick features from.

- source: `apps/visuals-showcase/src/main.rs`

## vulpine

`vulpine`: the vulpine CLI; its first family is `tool`, whose `check` is the tool.v1 conformance kit.

- source: `crates/vulpine_cli/src/main.rs`

## vulpine-agent-link

`vulpine-agent-link`: the vulpine connector (ADR 0057 §2).

- source: `runtime/agent_link/src/main.rs`

## vulpine-brain

`vulpine-brain <tool> [args…]` (brainctl before, or the binary linked as `<tool>`): run one of the ported brain tool scripts. See the crate docs in lib.rs.

- source: `crates/vulpine_brain/src/main.rs`

## vulpine-disk-snapshot

`vulpine-disk-snapshot`: the laptop's daily disk growth snapshot, the Rust copy of runtime/disk_snapshot/disk_snapshot.py (the dua engine), byte-identical on the fixtures recorded from it (benchmarks/fixtures/disk_snapshot/, tools/repo/disk_snapshot_fixtures.py).

- source: `crates/vulpine_disk_snapshot/src/main.rs`

## vulpine-fleet

Vulpine-fleet — the fleet adapter (ADR 0034 style: outside the gateway, fox9-owned names). Probes every host in the fleet manifest over bounded key-based ssh, labels ssh peers by fleet host, and emits one JSON snapshot line per interval on stdout for the gateway's `[fleet]` task.

- source: `crates/vulpine_fleet/src/main.rs`

## vulpine-fleet-probe

Vulpine-fleet-probe: `runtime/fleet_probe/fleet_probe.py` as one static binary per fleet host (ADR 0041). It runs ON a fleet host, prints ONE JSON object (the Python probe's bytes: `fox9-fleet-probe/1`) and exits;

- source: `crates/fleet_probe/src/main.rs`

## vulpine-frigate-relay

`vulpine-frigate-relay <command> [args…]`: Frigate's review alerts, signed, to the gateway's webhook intake (the Rust copy of runtime/home_bridge/frigate_relay.py). See the crate docs in lib.rs.

- source: `crates/vulpine_frigate_relay/src/main.rs`

## vulpine-glyphctl

Vulpine-glyphctl (`glyphctl` before; the old name works for one release) — drive the running Glyph app from a shell over its owner-only control socket: the mic, the body and face, reads, typed and spoken turns, recorded-audio injection, a direct brain-tool call, status.

- source: `apps/glyph/src-tauri/src/bin/vulpine_glyphctl.rs`

```
    vulpine-glyphctl [--socket <path>] <COMMAND> [ARGS]
    audio <enabled|disabled>      Set and settle audio capture state
    enable-audio                  Enable and settle audio capture
    disable-audio                 Disable and settle audio capture
    show-last, show               Show the Glyph, or hide it when it is shown
    hide                          Hide the application window
    status                        Get current application status
    doctor [--json]               The socket path (this shell's and Glyph's), the Glyph pid and
                                  the age of the oldest request it is still working on
                                  (tries the GUI temp folder's socket when this shell's refuses)
    sessions [--json]             The live sessions on the bound gateway (role, kind, phase),
                                  observable first; names the --observe=<id> a phone needs
    brain [--addr <ip:port>] [--json]
                                  The brain roster (pooled pis, lanes) through the headless
                                  Admin dispatcher (admin-headless, 127.0.0.1:8791 by default)
    relaunch [--app <path>] [--timeout <secs>]
                                  Quit Vulpine, reopen it with this shell's TMPDIR carried (the app
                                  binds its socket under ITS launch TMPDIR), wait, then status
    tool <pi_tool> --file <path>  Invoke one brain tool directly (no turn, no Brain); the input
                                  JSON from a file (the default; an inline <json> also works)
                                  [--timeout <secs>]; prints the tool's JSON
                                  (the door waits 60 s; Glyph 70 s by default;
                                  an input wait_s asks wait_s + 60 s, up to 300;
                                  a dispatch verb that starts an agent adds 150 s)
    pipeline dispatch|advance|report|close <file.json> [--timeout <secs>]
                                  A herdr pipeline verb from a file of its arguments (the
                                  envelope built for you); advance/report add next_wait_s
    pipeline run <file.json> [--max-s <secs>] [--once]
                                  Drive a herdr pipeline to its outcome (pi_herdr_dispatch run,
                                  resumed until it resolves); one JSON line per stage event
    pipeline follow <name> --host <h> [--repo <r>] [--max-s <secs>] [--read-only]
                                  Wait on a pipeline's stages to DONE (0) / PARTIAL (2)
    pipeline sweep [host] [--repo <r>]
                                  Close every finished pipeline's panes on the host
    read <url> [--restart]        Read a page aloud with a resumable cursor (no Brain)
    read pause|resume|next|previous|restart|stop|where
                                  ...move or park the read in flight
    send <text|--file p> [--wait] Inject text as-if-spoken (STT bypass); --wait prints the reply
                                  (--help per command; `--` ends options)
    speak <text|--file p>         Read text aloud via session TTS (no Brain)
          [--room <room>]         ...through that room's speaker instead (kitchen, living-room, office)
    avatar <json|--file p>        Send one typed avatar action to the session's rig (no Brain;
                                  --session <id>: another bound session's rig)
    inject-audio <wav> [--wait]   Stream a WAV as microphone audio (full wake/STT path)
                                  [--timeout <secs>] bounds a --wait (default 180)
    reconnect                     Drop and re-establish the gateway session (close handshake)
    reconnect --hard --i-know     Sever the gateway transport with no Close frame (test verb;
                                  needs [vulpine] droppable_transport = true)
    owner [--json]                The ADR 0024 owner: attachment, id, lease generation, hello mode
    playback [--json]             The last played segments: generation, bytes, first audio, play_observed
    room <name|none>              Declare the room this Glyph is in (reconnects); none = gateway default
    interrupt                     Interrupt the active gateway turn
    subtitles <on|off>            Enable or disable subtitles
    labs <on|off>                 The one Labs switch (live, saved)
    chassis <name>                Switch the overlay's body live: classic, island, halo,
                                  familiar, ribbon or printer (remembered)
    orb-style <style>             Put the native orb in a style (remembered): classic, phosphor,
                                  dither, ... (vulpine-glyphctl orb-style --help lists them)
    orb-size <small|medium|large> Look → Size: the native faces' stage, 130/180/240 pt (remembered)
    face <avatar> [variant]       Show a face live, optionally with a variant (remembered):
                                  orb, cast, scanner or phonogram (vulpine-glyphctl face for variants)
    look [--opacity N] [--ring on|off] [--mood <mood>|auto]
                                  Set the face's opacity (20–100), ring light and pinned mood
    theme <name>                  Set the orb theme (for tinty integration)
    theme --check <file>... [--json] What theme files set and skip, before binding them
    dictation hold [--literal|--review] [--style s] | release
                                  Open / end a hold-to-talk dictation as the key does
    dictation feed [--from <path|->] [--edges <path|->]
                                  Hold a dictation on outside 16 kHz PCM (a remote's mic)
    dictation review send|plain|scratch
                                  Close an open review as Return / Shift+Return / Esc do
    dictation erase-last          Scratch the last typed dictation (silent; refusals printed)
    dictation status              Hold, mode, style, key route, last insert (no words)
    dictation mode --literal|--review [--style s] | on | off
                                  Change the dictation settings (saved to config.toml)
    keep-that                     Send 'keep that' (the gateway answers aloud)
    recall --at <clock> [--minutes n] | --from a --to b | --last <min>
                                  Read back what was kept (pi_recall_window, nothing spoken)
    render <kind> --file <body.json> | --sample <kind> [--ttl <secs>]
                                  Preview one render on the declaring panels; says if it drew
    enroll start [--seconds n] | status | discard
                                  Real-voice enrollment from this mic (embedding kept, audio deleted)
    meet status|opt-out|forget [<call_id>]
                                  Run meetctl on this machine (no_adapter when absent)
    meet minutes [<call_id>|last]
                                  A stored call's minutes (pi_meeting_minutes; prints model text)
    onboarding, welcome           Open the welcome window (the privacy grants)
    capture [--window|--region]   Screenshot or --record (narrated), mark up, send to the brain (--help)
    showcase [--tile <id>]        Open the installed visuals showcase (never a build; --help)
    list-mics, list-microphones   List available microphones
    set-mic, set-microphone <id>  Set the active microphone by device ID
    help, --help, -h              Print this help message
    --socket <path> or $VULPINE_GLYPH_SOCKET name it outright; else the path the running Glyph
    wrote to ~/Library/Application Support/com.voidfab.vulpine/glyph.sock.path
    (whatever TMPDIR launched it; a Glyph built before the bundle id moved wrote it under the
    old id's folder, read after), then this shell's $XDG_RUNTIME_DIR or $TMPDIR/glyph.sock.
    Glyph's Diagnostics > Command line installs this command on your PATH.
    vulpine-glyphctl scanner               # Show the scanner face
    vulpine-glyphctl audio disabled        # Stop and settle audio capture
    vulpine-glyphctl status                # Check current status
    vulpine-glyphctl hide                  # Hide the window
    vulpine-glyphctl face cast sigil       # Show Cast with the sigil engine
    vulpine-glyphctl look --opacity 60 --ring off --mood auto
    vulpine-glyphctl theme nord            # Set theme to 'nord'
    vulpine-glyphctl list-mics             # List available microphones
    vulpine-glyphctl set-mic default       # Set microphone to default
```

## vulpine-hc-approve

`vulpine-hc-approve approve|deny|inspect`: one request on stdin, one result line on stdout.

- source: `crates/hc_approve/src/main.rs`

## vulpine-herdr

Vulpine-herdr (herdrctl before): the herdr brain tools' helpers as one Rust binary (slice 1 of the ADR 0041 §2 port of runtime/herdr_*). Each subcommand is the Python script of the same name, output for output on the recorded fixtures (benchmarks/fixtures/herdrctl/, tests/parity.rs):

- source: `crates/vulpine_herdr/src/main.rs`

## vulpine-home

`vulpine-home <command> [args…]` (homectl before; the binary linked as `homectl` for one release): the home bridge's adapter. See the crate docs in lib.rs.

- source: `crates/vulpine_home/src/main.rs`

## vulpine-mynah-stt

`vulpine-mynah-stt`: the gateway's STT worker wire in front of mynah-asr's streaming WebSocket.

- source: `crates/mynah_stt_shim/src/main.rs`

## vulpine-mynah-stt-helper

`vulpine-mynah-stt-helper`: the gateway's STT worker wire over mynah-asr's C library, in one process.

- source: `runtime/mynah-stt/src/main.rs`

## vulpine-openai-speech

`vulpine-openai-speech`: a Wyoming TTS server in front of an OpenAI-speech server on loopback.

- source: `crates/openai_speech_shim/src/main.rs`

## vulpine-provider

Vulpine-provider (providerctl before): is an upstream model provider degraded? The logic lives in lib.rs (port 1 of ADR 0041); this is the process boundary.

- source: `crates/vulpine_provider/src/main.rs`

## vulpine-providerctl-incur

, the incur spike: providerctl behind incur-rs's envelope.

- source: `spikes/2026-10-07-incur-rs/src/main.rs`

## vulpine-reach

`vulpine-reach`, the mini's reach helper (ADR 0053 addendum A4, A5; an ADR 0041 §1 runtime helper).

- source: `crates/reach_iroh/src/bin/vulpine_reach.rs`
- build: `just setup::build-vulpine-reach`

## vulpine-realtime-stt

`vulpine-realtime-stt`: the gateway's STT worker wire in front of an OpenAI Realtime transcription server.

- source: `crates/realtime_stt_shim/src/main.rs`

## vulpine-relay

Vulpine-relay: the laptop's one relay to the mini, carrying the Glyph's loopback gateway ports and the Admin's socket over one ssh session.

- source: `crates/vulpine_relay/src/main.rs`

## vulpine-room

Vulpine-room (roomctl before) — one interface for "make this room say / play something": the gateway's room-speaker route and the brain tool `pi_room_speak` both run it.

- source: `crates/vulpine_room/src/main.rs`

## vulpine-testbed

Vulpine-testbed (the harness): this checkout's gateway library served in-process for the harness, with every path under one state root.

- source: `crates/voice_gateway/src/bin/vulpine_testbed.rs`

## vulpine-vigil-serve

Vulpine-vigil-serve: Vigil's installed build on loopback, the port of runtime/vigil-serve/vigil_serve.py (deleted) with the same arguments and refusals.

- source: `crates/vigil_serve/src/main.rs`

## vulpine-vision

`vulpine-vision <command> [args…]` (visionctl before; the binary linked as `visionctl` for one release): the camera-vision adapter. See the crate docs in lib.rs.

- source: `crates/vulpine_vision/src/main.rs`

## vulpine-voice-gateway

Vulpine-voice-gateway — the Fox9 Voice Gateway server: frontends connect over WebSocket, and it owns turns, speech in and out, and the brain seam.

- source: `crates/voice_gateway/src/main.rs`

## vulpine-wechat

`vulpine-wechat` (wechatctl before) — the WeChat send channel; the library docs say what each stage and refusal means.

- source: `crates/vulpine_wechat/src/main.rs`

## vulpine_glyphctl

Vulpine-glyphctl (`glyphctl` before; the old name works for one release) — drive the running Glyph app from a shell over its owner-only control socket: the mic, the body and face, reads, typed and spoken turns, recorded-audio injection, a direct brain-tool call, status.

- source: `apps/glyph/src-tauri/src/bin/vulpine_glyphctl.rs`

```
    vulpine-glyphctl [--socket <path>] <COMMAND> [ARGS]
    audio <enabled|disabled>      Set and settle audio capture state
    enable-audio                  Enable and settle audio capture
    disable-audio                 Disable and settle audio capture
    show-last, show               Show the Glyph, or hide it when it is shown
    hide                          Hide the application window
    status                        Get current application status
    doctor [--json]               The socket path (this shell's and Glyph's), the Glyph pid and
                                  the age of the oldest request it is still working on
                                  (tries the GUI temp folder's socket when this shell's refuses)
    sessions [--json]             The live sessions on the bound gateway (role, kind, phase),
                                  observable first; names the --observe=<id> a phone needs
    brain [--addr <ip:port>] [--json]
                                  The brain roster (pooled pis, lanes) through the headless
                                  Admin dispatcher (admin-headless, 127.0.0.1:8791 by default)
    relaunch [--app <path>] [--timeout <secs>]
                                  Quit Vulpine, reopen it with this shell's TMPDIR carried (the app
                                  binds its socket under ITS launch TMPDIR), wait, then status
    tool <pi_tool> --file <path>  Invoke one brain tool directly (no turn, no Brain); the input
                                  JSON from a file (the default; an inline <json> also works)
                                  [--timeout <secs>]; prints the tool's JSON
                                  (the door waits 60 s; Glyph 70 s by default;
                                  an input wait_s asks wait_s + 60 s, up to 300;
                                  a dispatch verb that starts an agent adds 150 s)
    pipeline dispatch|advance|report|close <file.json> [--timeout <secs>]
                                  A herdr pipeline verb from a file of its arguments (the
                                  envelope built for you); advance/report add next_wait_s
    pipeline run <file.json> [--max-s <secs>] [--once]
                                  Drive a herdr pipeline to its outcome (pi_herdr_dispatch run,
                                  resumed until it resolves); one JSON line per stage event
    pipeline follow <name> --host <h> [--repo <r>] [--max-s <secs>] [--read-only]
                                  Wait on a pipeline's stages to DONE (0) / PARTIAL (2)
    pipeline sweep [host] [--repo <r>]
                                  Close every finished pipeline's panes on the host
    read <url> [--restart]        Read a page aloud with a resumable cursor (no Brain)
    read pause|resume|next|previous|restart|stop|where
                                  ...move or park the read in flight
    send <text|--file p> [--wait] Inject text as-if-spoken (STT bypass); --wait prints the reply
                                  (--help per command; `--` ends options)
    speak <text|--file p>         Read text aloud via session TTS (no Brain)
          [--room <room>]         ...through that room's speaker instead (kitchen, living-room, office)
    avatar <json|--file p>        Send one typed avatar action to the session's rig (no Brain;
                                  --session <id>: another bound session's rig)
    inject-audio <wav> [--wait]   Stream a WAV as microphone audio (full wake/STT path)
                                  [--timeout <secs>] bounds a --wait (default 180)
    reconnect                     Drop and re-establish the gateway session (close handshake)
    reconnect --hard --i-know     Sever the gateway transport with no Close frame (test verb;
                                  needs [vulpine] droppable_transport = true)
    owner [--json]                The ADR 0024 owner: attachment, id, lease generation, hello mode
    playback [--json]             The last played segments: generation, bytes, first audio, play_observed
    room <name|none>              Declare the room this Glyph is in (reconnects); none = gateway default
    interrupt                     Interrupt the active gateway turn
    subtitles <on|off>            Enable or disable subtitles
    labs <on|off>                 The one Labs switch (live, saved)
    chassis <name>                Switch the overlay's body live: classic, island, halo,
                                  familiar, ribbon or printer (remembered)
    orb-style <style>             Put the native orb in a style (remembered): classic, phosphor,
                                  dither, ... (vulpine-glyphctl orb-style --help lists them)
    orb-size <small|medium|large> Look → Size: the native faces' stage, 130/180/240 pt (remembered)
    face <avatar> [variant]       Show a face live, optionally with a variant (remembered):
                                  orb, cast, scanner or phonogram (vulpine-glyphctl face for variants)
    look [--opacity N] [--ring on|off] [--mood <mood>|auto]
                                  Set the face's opacity (20–100), ring light and pinned mood
    theme <name>                  Set the orb theme (for tinty integration)
    theme --check <file>... [--json] What theme files set and skip, before binding them
    dictation hold [--literal|--review] [--style s] | release
                                  Open / end a hold-to-talk dictation as the key does
    dictation feed [--from <path|->] [--edges <path|->]
                                  Hold a dictation on outside 16 kHz PCM (a remote's mic)
    dictation review send|plain|scratch
                                  Close an open review as Return / Shift+Return / Esc do
    dictation erase-last          Scratch the last typed dictation (silent; refusals printed)
    dictation status              Hold, mode, style, key route, last insert (no words)
    dictation mode --literal|--review [--style s] | on | off
                                  Change the dictation settings (saved to config.toml)
    keep-that                     Send 'keep that' (the gateway answers aloud)
    recall --at <clock> [--minutes n] | --from a --to b | --last <min>
                                  Read back what was kept (pi_recall_window, nothing spoken)
    render <kind> --file <body.json> | --sample <kind> [--ttl <secs>]
                                  Preview one render on the declaring panels; says if it drew
    enroll start [--seconds n] | status | discard
                                  Real-voice enrollment from this mic (embedding kept, audio deleted)
    meet status|opt-out|forget [<call_id>]
                                  Run meetctl on this machine (no_adapter when absent)
    meet minutes [<call_id>|last]
                                  A stored call's minutes (pi_meeting_minutes; prints model text)
    onboarding, welcome           Open the welcome window (the privacy grants)
    capture [--window|--region]   Screenshot or --record (narrated), mark up, send to the brain (--help)
    showcase [--tile <id>]        Open the installed visuals showcase (never a build; --help)
    list-mics, list-microphones   List available microphones
    set-mic, set-microphone <id>  Set the active microphone by device ID
    help, --help, -h              Print this help message
    --socket <path> or $VULPINE_GLYPH_SOCKET name it outright; else the path the running Glyph
    wrote to ~/Library/Application Support/com.voidfab.vulpine/glyph.sock.path
    (whatever TMPDIR launched it; a Glyph built before the bundle id moved wrote it under the
    old id's folder, read after), then this shell's $XDG_RUNTIME_DIR or $TMPDIR/glyph.sock.
    Glyph's Diagnostics > Command line installs this command on your PATH.
    vulpine-glyphctl scanner               # Show the scanner face
    vulpine-glyphctl audio disabled        # Stop and settle audio capture
    vulpine-glyphctl status                # Check current status
    vulpine-glyphctl hide                  # Hide the window
    vulpine-glyphctl face cast sigil       # Show Cast with the sigil engine
    vulpine-glyphctl look --opacity 60 --ring off --mood auto
    vulpine-glyphctl theme nord            # Set theme to 'nord'
    vulpine-glyphctl list-mics             # List available microphones
    vulpine-glyphctl set-mic default       # Set microphone to default
```

## vulpine_phone

Vulpine on the phone (rung 3): the GPUI-owned iOS app, moved out of the phone-stack spike (spikes/2026-11-06-phone-stack, PH1-PH3, FK1, GL6) by MB2.

- source: `apps/phone/src/main.rs`

## wactl

The operator's WhatsApp unread, read-only, over an installed `wacli`.

- source: `runtime/messages/wactl.py`

```
wactl status                          # is a wacli binary here, and is it paired?
wactl unread --limit 10 --contacts    # which chats are unread, with counts
wactl read --chat "Robin" --contacts   # the newest messages of one chat
wactl read --ref 2 --contacts         # the same, by its place in the unread list
```

## wgpu-gpui

Wgpu-gpui: can a native wgpu renderer draw into a GPUI window with no CPU copy? The routes, in the item's order, on BS1's kit (gpui-fast 0.1.9):

- source: `spikes/2026-10-18-threejs-native/wgpu-gpui/src/main.rs`

## whisper-candle-shim

Whisper-candle-shim: see `lib.rs` and README.md.

- source: `tools/speech/whisper_candle_shim/src/main.rs`
