---
title: "Recipes"
description: "Every public recipe, in file order, with the comment written above it: the front page (the root justfile, what just lists) first, then each module (just/<module>.just, run as just <module>::<recipe>; just --list <module> shows the same…"
type: "generated"
source: "docs/reference/recipes.md"
---

> **Generated** from the code

Every public recipe, in file order, with the comment written above it: the front page (the root `justfile`,
what `just` lists) first, then each module (`just/<module>.just`, run as `just <module>::<recipe>`;
`just --list <module>` shows the same names). The bare names from before the module cut still run for one
release through `just/aliases.just`.

## The front page (`justfile`)

| recipe | what it does |
|---|---|
| `just install *flags` | (ADR 0041 §3): the one install path, in the doctor's order (docs/install.md is the same sequence by hand): the pinned toolchain (`mise install`), the JS workspace (`bun install`), the gateway's release build, `just bootstrap`, `just models`, `just secrets`, then `just doctor` (exit 1 unt… |
| `just bootstrap *args` | Create what the doctor checks, in its order, under $HOME (or `--home <dir>`): the state dir, the state config from tools/install/skeletons/ (generated from the gateway's config structs: required keys set, every other key commented with its default), ~/.config/vulpine and its fox9.toml,… |
| `just secrets *args` | The secrets step — the six secrets the doctor checks, by NAME, with the file each lives in, the mode it needs and what it still lacks. Reads presence and modes only; prints no value. `--home <dir>` for a scratch home. |
| `just models *args` | (ADR 0041 §3): install the runtime model servers at their pinned digests — the qwentts.cpp tts-server (pinned upstream + tools/patches, built into ~/.local/state/foxline/bin, the talker and codec at their sha256, the com.foxline.qwentts-server LaunchAgent) and kev.serve (kev at its commi… |
| `just doctor *args` | What this install is missing — one OK / MISSING / WRONG line per check with its fix line (mise pins, the state config and ~/.config/vulpine, model bundles and pinned digests, LaunchAgents and ports, the six secrets by NAME and mode, disk and memory floors). Read-only; |
| `just dev` | runs `mise exec -- bun run dev` |
| `just fix` | One mutating formatter/linter pass over unstaged and untracked work. |
| `just check` | Fast changed-file static checks; pre-commit runs the staged equivalent. The hosted-diagnostic pins come first: a drifted digest lists its paths and fails until `python3 tools/repo/python_hosted_diagnostic_repin.py --write` is committed. |
| `just verify` | Changed-domain tests over staged bytes; pre-push derives the pushed range. |
| `just release-check` | Full publication gate. Run once immediately before freezing review bytes. |
| `just release *args` | (ADR 0041 §6): fold changelog.d into a `## v<N>` section, tag v<N> (next after the highest v<N> tag, or the live stamp + 1 before the first tag), build the gateway, check its stamp against the tag's commit, write benchmarks/results/rolls/roll-v<N>-<date>.json; |
| `just rollback version *args` | The release before v<version> and the exact roll command for it, with the config caveat. Prints only. |

## `just setup::…` (`just/setup.just`)

Install pieces beyond `just install`: the Rust ports (vulpine-provider, vulpine-fleet), the pane-pi extensions, the relay agent, hooks, data.

| recipe | what it does |
|---|---|
| `just setup::hooks-install` | Install mise-wrapped repository hooks into .git/hooks, their `mise x` offline (tools/repo/hook_offline.py: a commit on an away network never waits on mise's fetches; `MISE_OFFLINE=0 git commit` goes online). |
| `just setup::glyph-relay-agent-install` | Keep the relay under launchd (survives reboots; waits for a hand-started relay to exit before taking the port). Re-run after moving the checkout. |
| `just setup::install-fox9-report-local` | Same extension on this laptop (pane pis here report too). |
| `just setup::install-fox9-approval-local` | runs `cp catalog/pi/extensions/fox9-approval/index.ts "$HOME/.pi/agent/extensions/fox9-approval.ts"` |
| `just setup::install-fox9-todo-list-local` | fox9-todo-list: pi-todo-list's todo_list over a file-backed store, for pane pis — never the voice loadout. A directory extension (index.ts + the vendored todo-state.ts); same herdr-pane gate as fox9-report. |
| `just setup::install-vulpine-provider` | (ADR 0041 port 1): build the Rust vulpine-provider (providerctl before; mbx when it is on PATH, else cargo) and install it where `[providers] providerctl` looks by default; the smoke line reads no network (xai has no feed). |
| `just setup::data-fetch *args` | (ADR 0041 "data out of git"): copy the large data files git no longer tracks (the SFT train/test splits, the retrieval corpus, the mlx/llm vet harvest) from benchmarks/data-manifest.json's `where` (the archive root of tools/repo/paths.py, or gs://) to their repo paths, verifying each sha… |
| `just setup::install-vulpine-fleet` | (ADR 0041 port 2). The binary embeds runtime/fleet_probe/fleet_probe.py, so rerun this after editing the probe. The smoke is `--help`, then `list` (validates the manifest; no ssh, no DNS) when ~/.config/foxline/fleet.json exists. (ADR 0063 §6): the binary is vulpine-fleet; |
| `just setup::install-vulpine-room host="" *flags` | (ADR 0041 port 3); roomctl is vulpine-room since (`roomctl` beside it is a link to it for one release, an old binary there kept as roomctl.previous; runtime-tools.toml [[renamed]]). The smoke is `--help`, then `list` (reads the rooms file; |
| `just setup::install-vulpine-home host="" *flags` | (ADR 0041 port 4): vulpine-home, homectl.py in Rust (crates/vulpine_home; `homectl` beside it is a link to it for one release, runtime-tools.toml [[renamed]]). The smoke is `--help`, then `list --compact` (reads the home map; no upstream, no network) when the map exists. |
| `just setup::install-vulpine-vision host="" *flags` | vulpine-vision, runtime/vision/visionctl.py in Rust (crates/vulpine_vision; `visionctl` beside it is a link to it for one release, runtime-tools.toml [[renamed]]). |
| `just setup::install-vulpine-frigate-relay host="" *flags` | vulpine-frigate-relay, runtime/home_bridge/frigate_relay.py in Rust (crates/vulpine_frigate_relay). |
| `just setup::install-vulpine-disk-snapshot *flags` | vulpine-disk-snapshot (crates/vulpine_disk_snapshot), the laptop's daily disk snapshot in Rust, installed where runtime/disk_snapshot/com.voidfab.fox9.disk-snapshot.plist and `just repo::disk-snapshot` look. A laptop job, so it installs on this machine only. |
| `just setup::install-vulpine-brain host="" *flags` | vulpine-brain (crates/vulpine_brain; brainctl before, and a link of that name to it for one release), the Rust binary the brain tools spawn for presencectl, selwrite and homeact in place of /usr/bin/python3 (paths.ts brainScriptCommand: the binary when it is on disk, else the… |
| `just setup::install-vulpine-herdr host="" *flags` | (ADR 0041 §2): vulpine-herdr (herdrctl before), the herdr brain tools' helpers as one binary (`convo`, `checks`). |
| `just setup::build-vulpine-reach` | (ADR 0053 addendum A4, runtime/reach): vulpine-reach, the mini's reach helper, built from the DETACHED crate crates/reach_iroh (its own Cargo.lock, so iroh never enters the workspace graph; `mbx` builds the workspace and does not apply). |
| `just setup::install-vulpine-reach host="" *flags` | Install vulpine-reach where its launchd job runs it (~/.local/state/foxline/bin/vulpine-reach). |
| `just setup::reach-agent-install host *flags` | The reach helper's launchd job (deploy/launchd/com.voidfab.vulpine.reach.plist.tmpl) on a host: copy the template there, render its home token, write it 0600 to ~/Library/LaunchAgents, bootout then bootstrap (just/steps/reach-agent-install.steps). |
| `just setup::reach-agent-remove host` | The reach helper's off switch on a host: bootout com.voidfab.vulpine.reach and remove its plist (the binary stays). |
| `just setup::reach-brain-agent-install host *flags` | Plan slice 5: the brain host's launchd job (deploy/launchd/com.voidfab.vulpine.reach-brain.plist.tmpl), `vulpine-reach brain serve` with the brain's own sealed key, beside the helper's job on the same host: copy the template there, render its home token, write it 0600, bootout then boots… |
| `just setup::reach-brain-agent-remove host` | The brain host's off switch: bootout com.voidfab.vulpine.reach-brain and remove its plist (the binary and key stay). |
| `just setup::nightly-agent-install *flags` | The long hook tier as a LOCAL launchd job on the MacBook Pro (deploy/launchd/com.voidfab.vulpine.nightly.plist.tmpl, tools/repo/nightly_local.py), keyless: 03:17, a fresh worktree at origin/master, `hk run nightly --all` under the laptop build slot, a receipt in… |
| `just setup::nightly-agent-remove` | The nightly job's off switch: bootout com.voidfab.vulpine.nightly and remove its plist (the receipts stay). |
| `just setup::nightly-dry-run *args` | Every step the nightly would run, with its command; runs and writes nothing (args: --only STEP,STEP, --ref REF) |
| `just setup::nightly-status` | This host's nightly receipts and the push tier they give |
| `just setup::build-fleet-probes dest="target/fleet-probes"` | vulpine-fleet-probe (crates/fleet_probe, runtime/fleet_probe/fleet_probe.py as a binary) for every fleet target, into DEST as vulpine-fleet-probe-<os>-<arch>: this host's own and, from a Mac, linux-x86_64 as a static musl binary linked by the pinned toolchain's rust-lld (no C cross tool… |
| `just setup::admin-relay-agent-install` | The laptop Admin's relay to the mini's Admin socket (runtime/relay/admin_gateway_relay.py) under launchd, beside the Glyph relay's job. Re-run after moving the checkout. `glyph-relay-agent-install` runs it too. |
| `just setup::admin-relay-agent-remove` | The Admin relay's off switch: stop it (a clean exit takes its markers down) and remove the job. |
| `just setup::admin-relay-status` | What the Admin relay's directory says (read-only JSON: running, the relay marker, whose endpoint). |
| `just setup::webkit` | Orchestrator (herdr-core batch, 2026-10-30) The WebKit the visual gates and the effects bench run (apps/vigil/scripts/browsers.ts never downloads one). mise cannot pin a browser; |
| `just setup::migrate-roots host *args` | Move a host's old XDG roots (~/.config/foxline, ~/.local/state/foxline) to the vulpine ones, leaving a relative symlink at each old path so every absolute old path (a plist's --config, the gateway binary, an env file) keeps resolving. Prints the plan by default; |
| `just setup::relay-ship host="local" *flags` | The relay's non-bundle install: build vulpine-relay (crates/vulpine_relay, release) and put it at ~/.local/state/vulpine/bin/vulpine-relay, where the "Gateway on another Mac" setting's per-user plist runs it in place of the Python relay (a dev run, a Mac whose Vulpine.app does… |

## `just voice::…` (`just/voice.just`)

The voice gateway: build, sign, test, roll and read it on the mini.

| recipe | what it does |
|---|---|
| `just voice::protocol-generate` | runs `mise exec -- bun run protocol:generate` |
| `just voice::protocol-typecheck` | runs `mise exec -- bun run protocol:typecheck` |
| `just voice::admin-bind-worker-probe binary` | Probe the compiled Gateway's private bind mode, including inherited FDs. |
| `just voice::traces limit="8"` | Reduce live gateway JSONL traces. Default dir is the gateway's state folder. |
| `just voice::traces-reduce query="latest"` | runs `uv run python tools/telemetry/trace_reduce.py reduce "{{query}}"` |
| `just voice::traces-remote query="latest" host=mini` | Same reducers on the mini. Pipes this checkout's tool over SSH; no scp.: every ssh / scp to a host in this file is `paths.py route <host> --exec [--scp] -- ...` (the scp + ssh deploys: `--exec --steps just/steps/<recipe>.steps [--dry-run]`, one probe, BF9): the LAN name wi… |
| `just voice::traces-remote-list limit="8" host=mini` | runs `python3 tools/repo/paths.py route "{{host}}" --exec -- python3 - list --limit "{{limit}}" < tools/telemetry/trace_reduce.py` |
| `just voice::traces-overlay query="latest" host=mini` | Overlay cargo traces on the mini (not Application Support). |
| `just voice::overlay-status host=mini` | What runs on the mini: the gateway agent, its version (`v<N>`, the `kill` argument of the next roll), its pid and the :8780 listener. Read-only.: it runs with the installed gateway binary's `overlay-stdio status` (just/steps/overlay-stdio-rust.steps; |
| `just voice::overlay-config-check host=mini *args` | Drift between the mini's volume config and the staged one, by section: what a normal roll would drop, add or change. Read-only; exit 2 on drift. Runs the Rust copy (crates/overlay_stdio's laptop binary, over /usr/bin/ssh); |
| `just voice::overlay version kill="" host=mini` | runs `if [ "${VULPINE_ROLL_RUNNER:-rust}" = rust ]; then python3 tools/repo/paths.py route "{{host}}" --exec --steps just/steps/overlay-stdio-rust.steps --set "args=start --version {{version}}{{ if kill == "" { "" } else { " --kill " + kill } }}"; elif [ -n "{{kill}}" ]; then python3 tools/repo/paths.py route "{{host}}" --exec -- python3 - start --version "{{version}}" --kill "{{kill}}" < retired/overlay_stdio/overlay_stdio.py; else python3 tools/repo/paths.py route "{{host}}" --exec -- python3 - start --version "{{version}}" < retired/overlay_stdio/overlay_stdio.py; fi` |
| `just voice::overlay-roll version kill="" host=mini *flags` | Roll the gateway to a binary already on the mini's volume (foxline-voice-gateway-stdio-v<new>): `just overlay-roll <new> <old>`. Both are version integers: `kill` is the OLD version, the `v<N>` that `just overlay-status` prints, never a pid. From a laptop build use `just overlay-roll-internal`. |
| `just voice::pcm-sweep host=mini` | Move settled PCM receipts from the gateway's internal staging dir to the volume archive the analysis tooling reads. Runs in ssh context (TCC never restricts it). Only files quiet for 60+ minutes move — a live session appends to its receipt continuously, so its mtime stays fresh. |
| `just voice::build-gateway` | Build the gateway the roll ships (on the MacBook Pro, signed there with the Developer ID: SG1, sign-gateway below). A stable identity matters: ad-hoc linker signatures change identity every build, so every roll dropped the mini's TCC/FDA grants; |
| `just voice::sign-gateway` | The gateway is Developer ID signed, and only on the MacBook Pro (SG1; "we sign everything now with our developer ID ... the signer is on the macbook pro"). |
| `just voice::overlay-roll-internal version kill="" host=mini *flags` | Build, sign, ship and roll in one step: `just overlay-roll-internal <new> <old>` (both version integers, e.g. `469 468`). Commit first: the binary's identity stamp and the roll script both come from the laptop's working tree. |
| `just voice::deploy-brain-tools host=mini` | Build the brain-tools extension bundle, pi-load-test it ON the mini in the gateway's exact spawn shape, and only then install it into the LIVE runtime root (~/.local/state/foxline/runtime-root — the /Volumes runtime-root copy is orphaned; never update it). |
| `just voice::deploy-refork host=mini *flags` | fox9-refork: the gateway loads $VULPINE_RUNTIME_ROOT/extensions/fox9-refork/ and pi prefers a stale index.js over the required index.ts (2026-09-30: the Sep-1 index.js refused every brain tool call after the v477 roll). |
| `just voice::deploy-fox9-report host=mini *flags` | fox9-report: the submit_task_report tool for every pi that herdr runs in a pane. A GLOBAL pi extension (~/.pi/agent/extensions), like herdr's own herdr-agent-state.ts beside it; |
| `just voice::deploy-fox9-approval host=mini *flags` | fox9-approval: the request_approval tool for pane pis — the agent dials the gateway's owner-local approval socket and the operator answers by voice. Same global-extension shape and gate as fox9-report. |
| `just voice::mini-sync-checkout host=mini kickstart="yes"` | The mini's pi brain runs from the mini's OWN checkout of this repo (catalog/agents/<agent>/.vulpine/loadout.toml → pi --tools, catalog/pi/extensions/ vulpine-tools via the agents' link of the same name). |
| `just voice::upstream-drift *args` | Exit 1 = a fact broke (fix before rolling); 2 = pins moved but facts hold (read the changelog, then `just upstream-drift --update`). pi / herdr upgrade drift: sha256 pins + the wire facts fox9 relies on |
| `just voice::corpus-liveness host=mini` | Capture-liveness bridge for corpus recording: runs on the mini, forwarded to 127.0.0.1:8793 here so the scenario reader can poll it. Ctrl-C to stop. |
| `just voice::gateway *args` | runs `mise exec -- cargo run -p vulpine-voice-gateway -- {{args}}` |
| `just voice::gateway-check` | Type-check the gateway.: this and the gateway build/test recipes export TMPDIR as tools/repo/paths.py `build_temp` (the archive volume when mounted), so rustc's temp objects stay off the laptop root. |
| `just voice::gateway-test` | Compile under `build_temp`, then run the tests in a private store folder under the caller's TMPDIR, removed after (their stores refuse /Volumes; `paths.py test-run --check` goes first, before any build). |
| `just voice::handoff-verify` | Handoff checkpoint gate: the suites this project treats as green/red, non-incremental so a tight laptop disk is not refilled (compiled under `build_temp`, run in a private store folder like `gateway-test`). |
| `just voice::benchmark-rust-gateway *args` | runs `mise exec -- bun run benchmarks/run-rust-gateway-fixture.ts {{args}}` |
| `just voice::benchmark-gateway-latency *args` | runs `mise exec -- bun run benchmarks/run-gateway-latency-benchmark.ts {{args}}` |
| `just voice::deploy-macmini item_id app_name predecessor_name attempt="v1" host=mini` | Prints a HOLD plan (one JSON line, exit 2) for a Mac mini candidate deploy; the staging/preflight/launch pipeline is not built, so nothing is copied to, armed on or launched on the mini (tools/gateway/deploy_macmini.py, --execute too). |
| `just voice::mic-status host=mini` | ADR 0025: gateway.mic-control component (mixer link, gain, capture levels). |
| `just voice::scenario-live url agent workspace persona scenarios="benchmarks/scenarios/text-turn-smoke.toml"` | Live scenario smokes against a running gateway (creates a real session). e.g. just scenario-live ws://127.0.0.1:8780 fixture ~/work operator |
| `just voice::screen-host station host=mini` | FOX9 tee-up 2345 slice 8 / 0320 item 9: point the mini gateway's screen route at a station. `laptop` sets `[screen] host = "mba-laptop"` (the mini's ssh alias for the operator's laptop); `mini` removes the host line (the agent on the mini itself). |
| `just voice::owner-retire *args` | List, read-only, which evicted composition's pi session files the gateway would retire next on a host: backfill (a plan, then the move) the session files no stored owner names into retired/<date>/unowned/. |
| `just voice::deploy-catalog host=mini` | The gateway's Catalog reader (the Admin Catalog section) reads tools/catalog/index.json and checks every package's entry points under its RUNTIME ROOT (~/.local/state/foxline/runtime-root on the mini), not the checkout; |
| `just voice::panels-probe *args` | panels-probe: does a panel reach every live frontend? A read-only probe (tools/gateway/panels_probe.py): it binds as a ui client that declares no render kind, posts ONE synthetic Forecast card through the render preview door (the wire `vulpine-glyphctl render` rides: no br… |
| `just voice::panels-probe-remote host=mini *args` | The same probe on a host's gateway (the mini after a roll): the script and the card travel over the route's ssh (nothing is copied to the host), it runs there against the loopback gateway with the host's traces, and the receipt lands here as benchmarks/results/panels-probe-<date>-<host>.json. |
| `just voice::door *args` | The gateway's headless door on a host, with no frontend bound. just voice::door pipeline follow copybera-rs/milestone-5 --host local --repo ghq/github.com/voidfab/copybera-rs just voice::door pipeline dispatch --json-b64 "$(base64 < envelope.json \| tr -d '\n')" No bare `--` (doorctl ref… |
| `just voice::gateway-tests *args` | Gateway lib tests via the opt-in, local-only mise result-cache MVP. --fresh executes the original suite without task-cache reads/writes; --explain shows its inputs. Hooks opt in separately with VULPINE_GATEWAY_TASK_CACHE=1; nightly always executes fresh. |
| `just voice::overlay-dry-run version kill="" host=mini *flags` | The rehearsal before an attended roll on the Rust runner. `just overlay-dry-run <new> <old>` runs two commands on the host, each by the INSTALLED gateway binary's `overlay-stdio` subcommand (just/steps/overlay-stdio-rust.steps, refused with exit 78 by a binary without it): `l… |

## `just services::…` (`just/services.just`)

The services the gateway spawns beside pi: the ambient sidecar and the alternative brains.

| recipe | what it does |
|---|---|
| `just services::build-ambient-sidecar` | Mini stdio overlay listener. Keep prior binaries. Do not apply.sh.: the Foundation Models background provider. Built with CommandLineTools swiftc (macOS 26 SDK), staged on the mini's internal exec dir beside the gateway; |
| `just services::ambient-sidecar-roll host=mini` | The ssh / scp below take the host's route (`paths.py route <host> --exec [--scp] -- ...`). Stage the sidecar on the mini (atomic rename). The gateway config's [ambient] worker_bin must point at ~/.local/state/foxline/bin/fox9-ambient-sidecar. |
| `just services::build-fm-brain` | runs `cd runtime/fm-brain && swiftc -target {{swift_target}} -O -parse-as-library -framework FoundationModels fm_brain.swift -o fm-brain && ./fm-brain --version` |
| `just services::fm-brain-roll host=mini` | runs `python3 tools/repo/paths.py route "{{host}}" --exec --scp -- runtime/fm-brain/fm-brain ":.local/state/foxline/bin/fm-brain.incoming"` |
| `just services::llama-brain-roll host=mini` | llama-brain: a GGUF model in-process via node-llama-cpp as a pi-shaped brain provider, the compact lane's third engine. Ships the script + launcher to the mini's internal exec dir, installs node-llama-cpp THERE (prebuilt Metal binary, \~200 MB, never committed), and prints the version. |
| `just services::k-brain-roll host=mini` | k-brain: the scripted K for the baseline-test dialogue eval — dependency-free node, bound by the baseline-k loadout's `[pi] command`. |
| `just services::llama-brain-model path host=mini` | runs `python3 tools/repo/paths.py route "{{host}}" --exec -- 'mkdir -p ~/.local/state/foxline/models'` |
| `just services::build-sound-head-trainer` | Build the sound-head trainer (runtime/sound-head-trainer, Create ML) with plain swiftc. |
| `just services::sound-head-trainer-roll host=mini` | Stage the trainer on the mini beside the ambient sidecar (atomic rename). |
| `just services::build-sound-detector` | Build the sound detector sidecar (runtime/sound-detector, CoreML) with plain swiftc. |
| `just services::sound-detector-roll host=mini` | Stage the sound detector sidecar on the mini beside the ambient sidecar (atomic rename). |
| `just services::sound-detector-rss host *args` | The sound detector's peak RSS on a host over live audio, sampled every 10 s (default 10 minutes); exit 1 over its 300 MB budget, 2 when no sidecar ran (open a session with a mic first). `--minutes N`, `--json` (tools/ambient/sound_detector_rss.py). |

## `just apps::…` (`just/apps.just`)

Glyph, Vigil and the TypeScript workspace.

| recipe | what it does |
|---|---|
| `just apps::build` | runs `mise exec -- bun run build` |
| `just apps::typecheck` | runs `mise exec -- bun run typecheck` |
| `just apps::pi-tools-typecheck` | Requires root frozen Bun dependencies and the standalone extension's npm ci. Checks declarations only; never starts Pi or calls a registered tool. Then the vulpine-tools test files (tools/tsconfig.pi-tests.json; BA7). `bun check` since CB1; |
| `just apps::voice-client-typecheck` | runs `mise exec -- bun run voice-client:typecheck` |
| `just apps::glyph-typecheck` | runs `mise exec -- bun run glyph:typecheck` |
| `just apps::glyph-build` | runs `MISE_OFFLINE=1 MISE_LOCKFILE=0 MISE_EXEC_AUTO_INSTALL=0 MISE_TASK_RUN_AUTO_INSTALL=0 mise exec -- python tools/repo/task_cache.py glyph-build --hook` |
| `just apps::glyph-tauri-check` | runs `mise exec -- bun run glyph:tauri-check` |
| `just apps::glyph-showcase` | ADR 0036 showcase: the real chassis and avatars on a simulated session, as one self-contained HTML file (apps/glyph/dist-showcase/glyph-chassis-showcase.html). |
| `just apps::vigil-dev port="5173"` | Vigil against the gateway on :8780 (the laptop's relay to the mini). The gateway resolves the workspace on its own host, so pass it absolute, as Glyph's config.toml does; a relative catalog/agents/<agent> is refused as loadout_resolution_failed. |
| `just apps::vigil-showcase port="5199"` | Vigil frames showcase (ADR 0037): every frame on a scripted call, no gateway. Dev-only. |
| `just apps::vigil-effects-bench *args` | The effects bench. The showcase meter in Playwright's WebKit (Glyph's engine, from its cache; never downloaded), headless and silent on loopback: page frame p50/p95 with the ASCII pass off and on, the pass's submit time and uploads. |
| `just apps::glyph-dev` | Local Tauri shell. Mic stays off until you enable it in Operations. XDG_RUNTIME_DIR must be owner-only; cargo/tauri often inherit /tmp (1777). |
| `just apps::glyph-relay *args` | Laptop loopback :8780 -> the mini (`mini`) :8780 (stt-relay command hop). |
| `just apps::sign-glyph app_path` | Same persistent identity for a built Vulpine.app bundle. Since 2026-09-04 the normal path is `cd apps/glyph && APPLE_SIGNING_IDENTITY="$(python3 ../../tools/install/codesign_identity.py)" bun run bundle:macos` (CM17: the identity is configuration, tools/install/codesign_identity.py; |
| `just apps::preview` | runs `mise exec -- bun run preview` |
| `just apps::admin-install *args` | Build Vulpine Gateway from this checkout and install it into the mini's ~/Applications. |
| `just apps::gateway-release-bundle *args` | IP8 (plan slice 18): a RELEASE Vulpine Gateway.app that carries the gateway's runtime, so a new Mac needs no checkout (docs/design/gateway-app-install-2026-11-07.md section 2.4). |
| `just apps::vigil-build` | VITE_VULPINE_GATEWAY_* / VITE_VULPINE_VIGIL_* in the env override as for vigil-dev. Writes dist/vigil-build.json (commit, dirty, workspace, loadout, built-at) and dist/MANIFEST.sha256. Needs the root `mise exec -- bun install`. |
| `just apps::vigil-install *args` | Ship apps/vigil/dist (from vigil-build) to the mini's ~/.local/state/vulpine/vigil, keeping the old one as vigil.previous (ADR 0043 L3: vigil-serve-install moves the codec folder there; run it first). |
| `just apps::site-build` | Build Vulpine's landing page (apps/site, Astro, static) into the gitignored apps/site/dist: the claims checked against their receipts (tools/docs/site_claims.py --check; |
| `just apps::site-check *args` | The landing page's naming lint over apps/site (dist included): no retired name, no private repo or tree name, no fleet host or address, no household name (the private list in the private store, never in git). |
| `just apps::site-deploy-vercel dir *args` | Deploy the landing to the `vulpine-site` Vercel project as a PREVIEW, in one command (tools/docs/vercel_deploy.py): copy apps/site into the new folder `dir` with /docs pointed at the docs host (--docs-host, VULPINE_DOCS_HOST, or the newest docs preview), `vercel link`, `vercel deploy --target previe… |
| `just apps::vigil-serve-install *args` | Serve the installed Vigil build on the mini's loopback, 127.0.0.1:8794, as the launchd job com.voidfab.vulpine.vigil (runtime/vigil-serve; template deploy/launchd/com.voidfab.vulpine.vigil.plist.tmpl). Args: [host=]<alias> (default the mini), engine=rust (the only engine since; |
| `just apps::vigil-serve-smoke *args` | GET http://127.0.0.1:8794/ on the mini over ssh: wants 200 and the index's <title>Vigil</title> (a build from before the rename passes, named). Args: [host=]<alias>. |
| `just apps::vigil-serve-ship host="" *flags` | Build crates/vigil_serve (release) and ship vulpine-vigil-serve to the host's ~/.local/state/vulpine/bin, after a --help smoke there; the old binary stays as vulpine-vigil-serve.previous (legacy-id: a pre-L3 vulpine-codec-serve is left as it is). |
| `just apps::site-media which out` | Record a silent showcase clip for the landing site, `which` = glyph (the chassis showcase: Halo, Cast face, Seal) or vigil (the browser skin's frames showcase on loopback vite, no gateway; app folder apps/vigil). |
| `just apps::footprint target *args` | A frontend's memory as one number with a method (the ui5 vet's footprint recipe): `target` = glyph, admin or a pid. |
| `just apps::glyph-ax *args` | The running Glyph's or Admin's Accessibility tree as text, so a lane verifies a chassis or a panel without a screenshot. Roles, labels, frames and actions: `just apps::glyph-ax tree glyph [--json] [--depth N] [--values] [--menus]`; |
| `just apps::glyph-ax-test` | glyph-ax's pure half over recorded-shape trees (tools/glyph/fixtures/ax-tree-glyph.json, ax-tree-convo.json): no app, no grant. |
| `just apps::tui *args` | The terminal skin (apps/tui) in one command, for a phone's SSH or Mosh session (ledger row 472). |
| `just apps::vigil-visual-gate *args` | The visual gate (ledger row 818): every Vigil page and state rendered headless at 390, 1024 and 1280 px and audited for visual defects. The states are apps/vigil/scripts/visualStates.ts; the engine is Playwright's WebKit from its cache (never downloaded), or --engine chromium as CI runs it. |
| `just apps::glyph-visual-gate *args` | The Glyph visual gate (ledger rows 847, 890): the visual gate's Glyph suite over the chassis showcase, every body and Operations tab at 390, 1024 and 1280 px. |
| `just apps::vigil-clip-webp folder *flags` | q80 WebP copies of a clip folder's APNGs (ledger 602), written beside them for Vigil's `<img>` while the ASCII pass keeps decoding the APNGs: `<clip>.q80.webp` for every clip the folder's theme.json names (ffmpeg splits the frames, img2webp encodes at quality 80 with each frame's own delay) and one… |
| `just apps::glyph-themes-install *args` | The shipped Glyph Themes (apps/glyph/src/theme/themes: Night glass, Porcelain, Tidewater) copied into the folder the Glyph's Operations → Look → Theme select lists ($XDG_CONFIG_HOME/glyph/themes, else ~/.config/glyph/themes), each checked with the loader's rules first. |
| `just apps::stackchan-sim *args` | The Stack-chan bridge, simulator first: the bridge with the stub gateway in this process and the simulated Stack-chan page, a xiaozhi-v1 client that draws the 320x240 face. Prints the page's URL (http://127.0.0.1:<port>/, loopback, a free port unless --port). |
| `just apps::stackchan-conformance *args` | The firmware's own xiaozhi-v1 parser over every frame the bridge and the page send: xiaozhi-contract.ts read from the vetted stack-chan zip in place (its commit and sha256 checked, refused if it imports anything), imported only in a child node under the permission model (reads the cont… |
| `just apps::stackchan-opus-bench *args` | What Stack-chan's Opus costs, on synthetic signals only (loopback, nothing played): encode and decode per 60 ms frame (p50 / p95 / max over --frames, at least 500), the round trip's correlation and SNR (a sweep and a speech-like chirp, each way), and the bridge as its own process betwe… |
| `just apps::release-dry-run *args` | The release recipe's dry run, end to end and offline: a fixture Vulpine.app (main executable, the required sidecars in Contents/MacOS, a versioned framework) signed inside-out ad-hoc with the hardened runtime, verified deep and strict, DMG built and signed, SHA256SUMS, a Sparkle 2 appc… |
| `just apps::release-bundle *args` | REL3 (follow-up): the one command that builds a RELEASE Vulpine.app. The first notarized 0.1.0 shipped without its conversation window and native orb because a plain `bun run bundle:macos` carries them only when named. |
| `just apps::release-identity-check app *args` | The bundle identity gate: a signed Vulpine.app against apps/glyph/src-tauri/bundle-identity.json (the entitlement set, no JIT-family entitlement, the designated requirement and Team ID), so the microphone and screen-recording grants survive an update. Read-only; exits 1 on drift. |
| `just apps::switch-to-vulpine host source *flags` | Switch a machine from Glyph.app to the released Vulpine.app (scripts/release/switch_to_vulpine.py): refuses an unsigned, ad-hoc or wrong-identity app (codesign deep verify, bundle_identity.py check --mode release, Gatekeeper); quits a running Glyph or older Vulpine; |
| `just apps::convo-gpui-build` | The GPUI conversation window, built for the Glyph to carry: `bun run bundle:macos --convo-gpui <path>` copies the binary this prints as Contents/MacOS/convo-gpui (ADR 0046 as amended). A detached crate on the GPUI toolchain (Rust 1.95 or newer for std::hint::cold_path; |
| `just apps::orb-gpui-build` | REL3: the native orb (apps/orb-gpui), built for the Glyph to carry: `bun run bundle:macos --orb-gpui <path>` copies the binary this prints as Contents/MacOS/orb-gpui, where the shell's resolve_orb looks first. |
| `just apps::native-gate *args` | The native gate: apps/native-kit's and apps/native-cards' galleries drawn headless on Metal (gpui-fast's HeadlessAppContext, CoreText, no window on screen, no Screen Recording) and held against their blessed sets (tests/visual/baselines/metal-darwin, Vigil's manifest shape… |
| `just apps::native-gate-live *args` | The native gate's live rows for the orchestrator's chain (tools/apps/native_gate_live.py): the idle row, the web panel and its canary, the AX cycle and its leak canary, and convo-gpui's script visuals at rest in reel mode with their canary, one after another, each under its own short hold of the lap… |
| `just apps::copywatch out` | copywatch, the injected Metal copy counter (moved it to tools/apps/copywatch, its one copy): builds libcopywatch.dylib (clang, arm64, ad-hoc signed) into <out> and prints its path. |
| `just apps::admin-popout-build` | The Admin's event timeline pop-out in GPUI: the TS Admin's bundle carried it as Contents/MacOS/admin-popout and started it from the timeline's Pop out button; |
| `just apps::admin-sessions-popout-build` | The Admin's Live sessions pop-out in GPUI: the Admin's second, on the pop-outs' shared crate (apps/sidecar-window), once carried in the TS Admin's bundle (retired). |
| `just apps::admin-shadow-parity *args` | The shadow GPUI Admin's parity report (no human review of the shadow, automated testing instead): every row of docs/operations/admin-shadow-review.md turned into a check (the TS Admin's fixture-test words beside the shadow's, the cited tests, the blessed states, the property tests'… |
| `just apps::admin-shadow-install` | The shadow GPUI Admin's old laptop install (ADR 0060).: the GPUI Admin IS Vulpine Gateway.app now, so this is `admin-install local` for one release (it installs Vulpine Gateway.app on THIS Mac, keeping the old one as .previous). |
| `just apps::upstream-patches *args="run"` | The upstream-ready GPUI patches, prepared and not sent (an offer upstream is the operator's call): each in apps/native-kit/patches/<name>/ with its DRAFT-PR.md and a test in the harness (apps/native-kit/patches/upstream-harness) that must FAIL on the published crates (RED, the harness… |
| `just apps::convo-live gateway *args` | The conversation window's live acceptance in one command (ledger row 1410; BT5's run, re-run after each Glyph rebuild): builds convo-gpui (or takes CONVO_GPUI_BIN), bundles it as a background accessory app on the root disk (the lane-bundles folder in the home folder), starts it observing <gateway> (… |
| `just apps::convo-web-card` | The conversation window's web-drawn card, live: apps/convo-gpui/tests/web_card_ax.rs starts the window on tests/fixtures/web-card.jsonl (no focus, no hotkey) and reads its tree from outside with glyph-ax: the 24-hour chart's page (AXWebArea) under its card's Chart block with all 24 val… |
| `just apps::convo-shader-idle` | convo-gpui's shader charts, live: apps/convo-gpui/tests/shader_idle.rs starts the built window (no focus, nothing audible) on tests/fixtures/shader-card.jsonl and passes when the golden forecast and heatmap cards were drawn by the kit's shader (no web page), every chart came to rest, a… |
| `just apps::convo-thinking-idle` | convo-gpui's thinking lattice, live: apps/convo-gpui/tests/thinking_idle.rs starts the built window (no focus, nothing audible) on tests/fixtures/thinking.jsonl and passes when the lattice opened, the window named the work in order (waiting on the model, the web search, replying), the… |
| `just apps::convo-visual-idle *args` | convo-gpui's script visuals, live: apps/convo-gpui/tests/visual_idle.rs starts the built window (no focus, nothing audible) on tests/fixtures/visual-card.jsonl (five visuals: a dashboard, a canvas, a shader, a scene, a shader with a buffer pass) and passes when every visual loaded and… |
| `just apps::convo-list-rest *args` | convo-gpui's long log at rest, live: the list patches' live row. Builds the window with `--features layout-probe` (its frame journal reads the layout nodes and the footprint, src/probe.rs) and runs tools/apps/convo_list_rest.py: 600 turns (1,200+ rows) replayed without focus, nothing a… |
| `just apps::fox-live *args` | The fox, native in 2D, live: apps/fox-gpui/tests/fox_live.rs starts the built fox-gpui (no focus, nothing audible) on a recorded presence with the fixture's two generated clips and copywatch injected, and passes when GPUI uploaded exactly the pictures the fox made while drawing many mo… |
| `just apps::fox3d-live` | The fox in 3D, live: apps/fox-gpui/tests/fox3d_live.rs opens the 3D fox in its own windows (no focus, nothing audible, no clip read) with copywatch injected and hands it a scripted presence. |
| `just apps::filaments-live` | The signal filaments, live: apps/fox-gpui/tests/filaments_live.rs opens the filaments in their own windows (no focus, nothing audible: the voice is a recorded level, numbers only) and passes when they present nothing for 3 s at rest, move at 20 or more frames a second while the sample… |
| `just apps::typecheck-bench *args` | The TypeScript typecheck steps timed, one fresh child per run reaped with wait4 (wall and peak RSS): the push tier's five exactly as hk.pkl runs them, then the workspace packages the push does not check. |
| `just apps::typecheck-trial *args` | The Rust-port typecheck trial, never a gate. TSC71 is the TypeScript 7.1 nightly of the commit the ports pin (the baseline, so a difference is the port's and not upstream drift); |
| `just apps::tauri-parity *args="report"` | The Tauri-to-GPUI parity baseline. `write` regenerates apps/<app>/parity/*.txt (the shells' tauri::commands, emitted events and webview listens); `check` is the commit step `tauri-parity-baseline`; |
| `just apps::showcase-reel *args` | The visuals reel (the on-screen tests as a highlight reel): apps/visuals-showcase/reel.toml played as a demo, no verdicts. |
| `just apps::showcase *args` | One interactive showcase panel: with no word it opens on the Library (purpose-first landing; its Looks group opens the Look lab, every look in the looks library over a subject you pick), with a tile's word on that tile (`just apps::showcase look-lab`). |
| `just apps::puck-wakes host="mini" hours="24" *args` | The puck's wakes per hour, read on the mini from the bridge's kept sidecars (VULPINE_WAKE_CLIP_DIR in ~/.config/foxline/satellite-kitchen.env, the 990): every on-device wake with what the bridge did (run, queued_busy, ignored_stop, stop_word, no_request), how many kept audio and how ma… |
| `just apps::puck-wake-label id as host="mini"` | Label one puck wake by hand: `just apps::puck-wake-label <id> real\|false\|clear` (ids from `just apps::puck-wakes mini 24 --list --unlabeled`). A false puck wake can also be labeled by voice: say "I wasn't talking to you" while the puck still listens (CJ41's verb); |
| `just apps::puck-cutoff-read host="mini" hours="0" *args` | The puck's "Fox Nine" cutoff read, run on the mini: real vs false wake-score histograms, false wakes per hour and recall loss at cutoffs 0.90-0.99, the stop model's fires per day, and the firmware yaml diff when enough labels say a cutoff should move. |
| `just apps::phone-sim scenario *args` | The phone app in the iOS simulator with mock services: builds it under the laptop build slot (a no-op when nothing changed), installs it on a booted iPhone 17 simulator and plays one scenario from apps/phone/scenarios/ (`--mock <scenario>`: a scripted link, warm-up and voice turns, and… |
| `just apps::phone-sim-gate *args` | Every phone scenario's screens against apps/phone/tests/visual/<scenario>/ (the native gate's tolerance; a diff PNG beside each failing shot); a full PASS stamps apps/phone's sources for the commit guard. `--bless` writes the baselines (view every PNG first); `--scenarios a,b` narrows it. |
| `just apps::phone-device-smoke log` | Judge a pulled phone log for one finished turn. The whole loop is `apps::phone-device-turn`. |
| `just apps::phone-device-install app out host` | Deploy an already signed development app; startup observations are not a complete voice smoke. |
| `just apps::phone-device-collect source out host` | Read the existing diagnostic launch; no install, restart, signing or automatic audio. |
| `just apps::phone-device-turn lane out host *args` | The whole device loop in one command: build under the laptop slot, sign.sh, copy to the connected Mac, install and read back, launch Talk with --no-mic --auto-hold and a fresh run marker, wait for one turn, pull and judge phone.log. |
| `just apps::phone-release app profile out` | The TestFlight package: a device build (build-sim.sh, TARGET=aarch64-apple-ios --features core) signed with the App Store profile by sign.sh, platform keys stamped, entitlements read back, packed as an .ipa and checked. No Apple account is touched; |
| `just apps::phone-upload step ipa *args` | Validate, or validate then upload, the .ipa with altool and the App Store Connect key file the orchestrator gives per run. `--dry-run` prints the altool steps and reads no key. |

## `just adapters::…` (`just/adapters.just`)

The Swift and Rust adapters (ADR 0034): build, sign and test each ctl.

| recipe | what it does |
|---|---|
| `just adapters::build-screenctl` | The screen agent, built and SIGNED with the same stable identity as the gateway and Glyph. |
| `just adapters::test-screen-policy` | The screen agent's insert policy — the per-app strategy table, the tri-state write verdict and the insert receipt — is pure Swift in runtime/screen/insert_policy.swift, tested over a fake AX element with no live app and no grant. Runs before every build-screenctl. |
| `just adapters::test-learn-edit` | The screen agent's learn-from-edit record builder: the context anchors around a verified insert, the span between them on the \~3 s read-back, the private-store directory refusals and the JSONL record — pure Swift in runtime/screen/learn_edit.swift, synthetic fields only. |
| `just adapters::test-globe-guard` | The Globe key guard: which flagsChanged/keyDown sequences are a Globe press or release — pure Swift, no tap, no Input Monitoring grant. |
| `just adapters::build-globectl` | globectl: the Globe/fn key as pressed/released JSON lines from a listen-only event tap; Glyph spawns it when `global_shortcuts.hold_to_talk = "Globe"`. Input Monitoring is granted to the RESPONSIBLE app (Glyph when Glyph spawns it); |
| `just adapters::test-record-gesture` | The capture recorder's gestures (CC2): which ⇧ press is a pin, a stroke or a box, the events.jsonl lines, the candidate sampler and the PNG encoder — pure Swift, no screen, no grant. |
| `just adapters::build-recordctl` | vulpine-record (recordctl before; CC2): a window or region recorded with ScreenCaptureKit and the microphone, ⇧ marks over it, OCR and movie frames for crates/capture_record. It ships inside Vulpine.app (scripts/bundle-macos.ts builds and the bundler signs it there); |
| `just adapters::build-fox9-hook out="tools/agents/fox9-hook"` | fox9-hook: the agent-presence hook receiver Claude Code and codex call from their hook tables — stdin payload in, one spool file per agent session out (~/.local/state/foxline/agents/<agent>-<session>.json), prints nothing, blocks nothing, exit 0 always. Build + sign here; |
| `just adapters::build-denoisectl` | denoisectl: the streaming GTCRN Core ML enhancer as a measurement adapter (WAV in, denoised WAV out, per-frame cost receipt). Measured 2026-09-19: REJECTED in front of the STT lane (benchmarks/results/gtcrn-denoise-20260919.md); |
| `just adapters::build-embedctl` | embedctl: Apple NLEmbedding sentence vectors as an ADR 0034 adapter for retrieval experiments — `benchmarks/retrieval/run_spike.py --embedctl tools/retrieval/embedctl`. Measured 2026-09-19: NOT a retrieval policy for this corpus (hit@5 0.06 standalone, hurts as a re-ranker); |
| `just adapters::build-speechctl` | vulpine-speech (speechctl before): Apple's on-device SpeechAnalyzer as a second-opinion STT adapter — one swiftc file, WAV in, JSON lines out, never the microphone. |
| `just adapters::build-focusctl` | focusctl: the focused element, the selection, the caret and the secure-input holder as one JSON receipt over Accessibility — no pixels, no Screen Recording. The Accessibility grant belongs to the process that runs it (a terminal, or the bundle that will host it as a subcommand). |
| `just adapters::test-call-policy` | callctl's decision policy — the call-app and excused-category tables, the browser "Leave call" confirmation, the 15 s hold / 10 min cooldown and the listener-driven watch — is pure Swift in runtime/calls/call_policy.swift, tested over fixture AX trees and a fake property listener. |
| `just adapters::build-callctl` | vulpine-call (callctl before): is the operator in a call — who holds the mic (CoreAudio process objects) and whether a camera runs anywhere (CoreMediaIO); no TCC grant, no capture, fox9's own Glyph never counts. |
| `just adapters::tcc-probe-build` | tccprobe: the laptop experiment on TCC identity for bare helpers — the same probe built plain and with quill's embedded Info.plist (`-sectcreate __TEXT __info_plist`), both signed with the fox9 identity, run with and without meetrs's responsibility disclaim. |
| `just adapters::build-grants` | The grant HOLDER. An .app bundle for the same reason the screen agent is one — Calendars/Reminders are granted to an application by bundle id + code requirement — plus the hardened-runtime entitlement that lets a hardened process ask for personal information at all. |
| `just adapters::build-audioctl` | vulpine-audio (audioctl before): output devices list/get/set/volume over CoreAudio, no TCC grant; the mechanism behind `pi_mac_control` output actions. The old file name is left as a link to it for one release (runtime-tools.toml [[renamed]]); |
| `just adapters::build-aecprobe` | aecprobe: mic + process-tap reference as two 16 kHz WAVs captured at once, then fox9's own canceller (daf-rs) over the pair and the residual as a number — `daf-rs probe` (crates/aec_daf) drives it. |
| `just adapters::build-tapctl` | tapctl: capture what this Mac PLAYS through a Core Audio process tap (per pid or global) into a WAV with an RMS receipt — the far-end AEC reference with no driver and no Screen Recording grant. |
| `just adapters::build-ioreport-sample` | ioreport-sample: CPU / GPU / ANE / DRAM watts and GPU residency from IOReport, one JSON line per second (`--seconds N`), no sudo, no model. A standalone Cargo project (its own workspace, not a root member); set CARGO_TARGET_DIR to build off the root disk. |
| `just adapters::compute-residency *args="--fixture"` | Compute residency join: a powermetrics plist capture (per-process GPU time) + ioreport-sample lines + a gateway trace's tts_worker_ttfa / decision_shadow rows -> who held the GPU, per second and per slow turn. Never runs powermetrics. No args: the synthetic fixture (dry run). |
| `just adapters::test-capture-sizing` | The screen agent's capture sizing: points x pointPixelScale with a proportional 4K cap — pure Swift in runtime/screen/capture_sizing.swift, no display, no grant. Runs before every build-screenctl. |
| `just adapters::test-press-gates` | The screen press's actionability gates: visible, stable (17 ms samples), enabled, advertises AXPress, the hit-test reaches it — pure Swift in runtime/screen/press_gates.swift over synthetic evidence, no app, no grant. Runs before every build-screenctl. |
| `just adapters::test-ptt-policy` | remote_ptt's pure policy: the Siri Remote facts, the seize plan (only the Siri interface) and the hold edge machine over a fake HID — no remote, no grant. Runs before every build-remote-ptt. |
| `just adapters::build-remote-ptt` | remote_ptt: a paired Siri Remote's Siri button as hold-to-talk — ptt_down / ptt_up JSON lines; `--glyphctl <path>` drives `vulpine-glyphctl dictation hold\|release`. Needs Input Monitoring only; `--list` names the remotes seen. |
| `just adapters::test-atvv` | remotectl's ATVV wire and hold machine: the control parser, the capability parse, IMA ADPCM, the 8 -> 16 kHz upsample, mic_start / mic_stop and the MIC_EXTEND keep-alive — pure Swift in runtime/remote/atvv_wire.swift, no Bluetooth, no remote. |
| `just adapters::build-remotectl` | remotectl: the Chromecast Voice Remote's voice key as a hold-to-talk mic over CoreBluetooth — `scan` lists ATVV remotes, `listen` writes 16 kHz s16le PCM while the key is held with mic_start / mic_stop on stderr. The Info.plist rides in __TEXT,__info_plist for the Bluetooth usage line. |
| `just adapters::feeds-refresh-install dry=""` | The feed store's refresh timer: renders deploy/launchd/com.voidfab.vulpine.feeds-refresh.plist.tmpl for THIS host and checkout and loads it, so `feedctl refresh` runs every 30 minutes. Run it on the brain host from its checkout; dry=1 prints the rendered plist and loads nothing. |
| `just adapters::frigate-relay-install dry="" python=""` | The Frigate relay (Frigate's review alerts, signed, to the gateway's webhook intake): renders deploy/launchd/com.voidfab.vulpine.frigate-relay.plist.tmpl for THIS host and checkout, installs it 0600 and loads it. |
| `just adapters::install-grants bundle=""` | The grant holder's install step: build and sign VulpineGrants.app (build-grants, selftest first), then put it where the brain host's LaunchServices finds it — ~/Applications — and drop the checkout copy from LaunchServices so `open -b com.voidfab.vulpine.gateway.grants` r… |
| `just adapters::pack-grants out=""` | The signing half of "sign here, install there": build-grants on the Mac that holds the signing key, then one zip of the signed bundle (ditto keeps the signature) and its sha256. Copy the zip to the gateway's Mac and run `just adapters::install-grants <zip>` there. |
| `just adapters::grants-status` | The verify command: the installed holder's `grants` receipt (contract, verbs, and calendars / reminders / contacts: full, write_only, not_determined, denied, restricted), read through LaunchServices so the answer is the holder's own grants (a direct exec over ssh answers for sshd). |
| `just adapters::frigate-enable host *args` | The gateway side of enabling the Frigate webhook sender, from the laptop, on a plist-owned gateway host (the mini: no gateway.env). On the host over its route: the source's secret generated there into overlay.env, its mirror and the gateway plist (never in argv or output; |
| `just adapters::agent-link-ship host="mini" *flags` | The vulpine connector (vulpine-agent-link, runtime/agent_link): build it here, smoke it, ship it to the host's ~/.local/state/vulpine/bin and restart a loaded job on it (just/steps/agent-link-ship.steps). overlay-roll-internal runs the same steps after every roll, never fatally. |
| `just adapters::agent-link-install dry=""` | Render deploy/launchd/com.voidfab.vulpine.agent-link.plist.tmpl for THIS host, install it 0600 and load it. Run it on a gateway host that is not the mini (the nix host configuration owns the mini's agents: the runbook's module lines). dry=1 prints the rendered plist and loads nothing. |
| `just adapters::test-grants-screen` | The dispatcher, unsigned under .t/grants (no bundle, no grant, nothing launched through LaunchServices): the holder's selftest, then `fox9grants screen` answers screenctl's usage (exit 2) and `screen ask` its own refusals (no_socket, agent_unreachable). Runs before every build-grants. |

## `just meet::…` (`just/meet.just`)

meetctl, the Meet local path (ADR 0039): its tests, the build and the minutes score.

| recipe | what it does |
|---|---|
| `just meet::test-meet-windows` | meetctl's window splitter (ADR 0039) — Freely's SpeechWindow (450 ms silence, 15 s cap, 200 ms pre-roll), the PCM16 WAV round trip and the private-store store guard — is pure Swift in tools/meet/meet_windows.swift, tested on synthetic signals. |
| `just meet::test-meet-events` | meetctl's decode-to-event half (docs/contracts/meeting.v1.md): the two-leg TranscriptMerger with the echo-leak drop, the far-leg diarizer labeller, the meeting.v1 encoder (golden JSONL), the sweep plan and the tombstone — pure Swift in tools/meet/meet_events.swift, synthetic inputs. |
| `just meet::meet-score *args` | Score meeting minutes against the golden meeting (benchmarks/meet/golden-01): decisions precision/recall, strict unknown speaker, doubts, open questions, the 14 KiB cap. No args: the checked-in stub answer; |
| `just meet::build-meetctl` | meetctl (ADR 0039): the Meet local path's adapter — on callctl's confirmed browser call, the mic leg and the browser's tapped output as silence-aligned windows in a private-store spool; |
| `just meet::build-meet-sortformer` | meet-sortformer: streaming far-leg speaker labels for `meetctl --diarizer streaming`. fetch.sh downloads FluidAudio v0.15.5 at its pinned commit OUTSIDE the repo (sha256-checked) and applies fox9's streaming clock fix (tools/meet/patches/); the wrapper builds on the archive drive. |
| `just meet::test-meet-cloud` | meet-cloud's pure half (ADR 0039 and its 2026-10-17 addendum): a Meet Media API session replayed from a JSONL tape (tools/meet/meet_cloud_tests/tape.jsonl: shapes from the saved Media API pages, ids and audio synthetic) becomes meeting.v1 lines through meet_windows' splitter and meet_ev… |

## `just qa::…` (`just/qa.just`)

The feature QA reads (benchmarks/qa, tools/qa) and the attended passes.

| recipe | what it does |
|---|---|
| `just qa::lexicon-attended` | Attended recall pass: opens the lexicon teleprompter. Run the relay (`just glyph-relay`) and a Glyph session first; the gateway on the mini records receipts as usual. When the reader says Complete: Copy JSON, save it beside the corpus results, then `just lexicon-attended-score`. |
| `just qa::lexicon-attended-score since_hours="6" host=mini` | Scores the attended pass on the mini: raw vs rescored recall per term over the receipts recorded in the last `since_hours` hours, plus the protected zero-harm check. Aggregate statistics only. |
| `just qa::reads-v498 *args` | The v498 reads that need no voice, from the laptop Glyph (vulpine-glyphctl under the Glyph's own TMPDIR): meet minutes and recall through the tool door, a "fleet status" text turn (spoken), a dictation hold/release into TextEdit, and the long-form seams; |
| `just qa::radio-morning` | One morning laptop TV script. No niner-over. No New Session. |
| `just qa::qa-server station="mini" *args` | --- feature QA (benchmarks/qa, tools/qa) ----------------------------------- The section-gated script read: reader page + takes + liveness + per-section trace pull and score. Recording switches and the roll are separate steps — see benchmarks/qa/README.md. |
| `just qa::qa-check run` | Score a run offline (exit 1 on any FAIL / NOT_HEARD). |
| `just qa::qa-replay *args` | Replay the text-lane steps through the laptop Glyph (audio disabled); --lane inject for say-built spoken clips. |
| `just qa::qa-compare *runs` | Two runs side by side (stations): facts, scoreboards, felt ladder, differing steps. |
| `just qa::qa-collect run` | Pull a run's PCM archive, receipts and traces off the mini. |
| `just qa::qa-recording mode="status"` | Recording switches for an attended read: status \| on \| off (then roll). |
| `just qa::qa-catalog *args` | features.toml → docs/features/README.md (+ coverage from a run when given). |
| `just qa::qa-selftest` | runs `uv run python tools/qa/qa_lib.py --selftest` |
| `just qa::qa-glyph-body *args` | QA section 79-glyph-body, automated against the LIVE laptop Glyph: switches The operator's body / face / look on screen, asserts vulpine-glyphctl status, the state files and the window frame, restores the starting state (always), then scores the section like a read. Never touches the mic. |
| `just qa::qa-slow-page host=mini *args` | The suite's own slow page for section 50's pending-fetch steps (RD-09a, RD-10a, RD-11a): tools/qa/slow_page.py on the gateway host's LOOPBACK :8797 (/delay/<s>, 0-60 s), from stdin like screen-host, in the foreground; it exits after an hour (`--for`). Start it before section 50. |
| `just qa::score-on *args` | Score a run ON the gateway host (its trace rows never leave it). Prints the ssh + scp lines that copy the run's run.json / runsheet.json / windows.json and tools/qa/score_on_host.py into the host's qa_runs/<run> and start the scorer there under nohup (score.rc + score.receipt land when… |

## `just audio::…` (`just/audio.just`)

Audio and speech qualification, PCM tools and the transcript / TTS eval scorers.

| recipe | what it does |
|---|---|
| `just audio::audio-qualification-template output="benchmarks/traces/audio-qualification/smoke.json" tier="smoke" profile="mac-native"` | Create a local-only physical audio receipt. Smoke defaults to one Mac-native route. |
| `just audio::audio-qualification-verify manifest="benchmarks/traces/audio-qualification/smoke.json"` | Validate route identity, signal integrity, repetitions, timing, and authority outcomes. |
| `just audio::audio-qualification-smoke-from-trace trace output="benchmarks/traces/audio-qualification/smoke-receipt.json"` | runs `uv run python tools/verification/audio_qualification.py smoke-from-trace --trace "{{trace}}" --qualification-id "fox9-smoke" --output "{{output}}"` |
| `just audio::audio-qualification-test` | Run the audio-qualification tests; the 833-case test_control.py runs on four xdist workers. |
| `just audio::tts-ab-test` | runs `uv run python tests/test_tts_ab.py` |
| `just audio::apple-speech-probe-test` | runs `uv run python tests/test_apple_speech_probe.py` |
| `just audio::speech-qualification-machinery-test` | runs `uv run python tests/test_workspace.py` |
| `just audio::qwen-quant-ab-test` | runs `uv run python tests/test_qwen_quant_ab_control.py` |
| `just audio::audio-capture-probe-test` | runs `uv run python tests/test_audio_capture_probe.py` |
| `just audio::pcm-stat file rate="16000"` | Named meters for a local 16 kHz mono f32le dump. Corpus stays off Git. |
| `just audio::pcm-extract file dest rate="16000"` | Cut the longest ≥250 ms burst to 16 kHz pcm16. Corpus stays off Git. |
| `just audio::pcm-replay file rate="16000" worker="" model=""` | Isolated Shadow+Silero replay of a local f32le dump. No Brain session. |
| `just audio::eval-score pairs out="benchmarks/results/eval-score.jsonl" summary="benchmarks/results/eval-score-summary.json"` | Equivalence-aware transcript scoring (jiwer WER/MER/WIL/CER over spoken-form canonicalized pairs; verdicts match/mismatch/quarantine/refused). Pairs is a JSONL of {id, reference, hypothesis}. |
| `just audio::tts-qa manifest out="benchmarks/results/tts-qa.jsonl" summary="benchmarks/results/tts-qa-summary.json"` | Structural TTS failure QA (empty/silence/clipping/loop/duration checks, no model). Manifest is a JSONL of {id, path, expected_text?}. |
| `just audio::eval-self-test` | Planted-defect positive controls for both eval tools — a check that cannot trip on planted bad input must not be trusted on real input. |
| `just audio::eval-tests` | runs `uv run --with jiwer==4.0.0 --with numpy --with pytest==9.1.1 pytest -q tests/test_eval_scoring.py tests/test_tts_structural_qa.py tests/test_eou_calibration.py tests/test_tts_pron_audit.py` |
| `just audio::eou-sweep dataset="" language="en" out="benchmarks/results/eou-sweep-en.json"` | EOU calibration against eot-bench (dataset on the archive volume locally, an external volume on the mini). sweep-silence needs no model; replay-worker runs on the mini. An empty dataset is <archive>/models/eot-bench-data (tools/repo/paths.py's archive root). |

## `just assets::…` (`just/assets.just`)

Local asset installs and the MGS extraction tools (outputs stay out of git).

| recipe | what it does |
|---|---|
| `just assets::brand-svg-audit *args` | brand SVG audit (vet-sem): FAIL/WARN/INFO audit of the three masters under assets/brand/; exit 1 on any FAIL. |

## `just memory::…` (`just/memory.just`)

The project-memory index and the operator's episodic memory on the mini.

| recipe | what it does |
|---|---|
| `just memory::memory-index host=mini force="0"` | Rebuild the live project-memory index (remote-dispatch + memento + fox9 docs/handoff) and stage it where the mini gateway reads it per turn. Digest-gated + atomic; force=1 pushes even when the corpus is unchanged. |
| `just memory::memory-index-install` | Install the hourly launchd refresh (laptop): runs memory-index every hour and at login, logging to ~/Library/Logs/fox9-memory-index.log. |
| `just memory::operator-memory cmd="status" host=mini` | Operator episodic memory on the corpus host: extract episode proposals from armed-final receipts, promote/demote by session-id prefix, show counts. Transcript text stays on the mini (0600) — review proposals there before promoting; promotion merges into the live index. e.g. |
| `just memory::memory-index-uninstall` | runs `launchctl bootout gui/$(id -u)/com.voidfab.fox9.memory-index 2>/dev/null \|\| true` |
| `just memory::memory-index-status` | Last refresh runs + whether the launchd agent is loaded. |

## `just verbs::…` (`just/verbs.just`)

The verb scorer and the decision model's scorecards.

| recipe | what it does |
|---|---|
| `just verbs::verb-calibrate date=`date +%Y%m%d`` | The tier-3 verb scorer's calibration receipt — the corpus harness emits the unthresholded score table, tools/verbs/calibrate.py writes benchmarks/results/verb-tier3-calibration-<date>.json (the file `min_conf_is_pinned_to_the_calibration_receipt` holds MIN_CONF to) and the jevlike rows… |
| `just verbs::verb-score provider date=`date +%Y%m%d` *args` | One scorer, one receipt in the calibration receipt's shape: `just verb-score jaccard` is row zero (no model); laya / jev-visual / jevmlx refuse to load without --i-have-dks-ok (pass it as extra args once given). |
| `just verbs::decision-scorecard url="http://127.0.0.1:8871" model="r12s0" ssh=mini date=`date +%Y%m%d` *args` | The weekly decision scorecard (r9 §5): a served decision.v1 endpoint scored over the frozen live held-out on the archive volume, with a receipt of metrics and file hashes that never carries text. |
| `just verbs::decision-scorecard-v2 model="r12s0" date=`date +%Y%m%d` *args` | The weekly scorecard's v2 card, asking nothing: rescore the week's cached answers with r6's last mini-served answers (2026-09-30b) as a paired row (session-clustered CIs, exact McNemar + Holm, AURC), the three non-LM control arms fitted on r9's train half, and the 5-gram shingle block.… |
| `just verbs::decision-scorecard-weekly *args` | The weekly scorecard end to end: refuse (exit 2) unless the mini's kev.serve --run is the labelled model (`ps` over ssh), then `decision-scorecard` bounded like the 10-04 run (sequential, 4 req/s, 4 seeds, the partial threads), `decision-scorecard-v2` with every cached hea… |
| `just verbs::decision-scorecard-stage host="mini"` | The weekly scorecard runs ON the gateway host (tools/verbs/decision_scorecard_host.py): no relay to drop, no laptop to be awake. |
| `just verbs::decision-scorecard-host-install dry=""` | On the gateway host, from its checkout: render deploy/launchd/com.voidfab.vulpine.decision-scorecard.plist.tmpl for this host, install it 0600 and load it (Sundays 03:30). |
| `just verbs::decision-scorecard-latest host="mini"` | The last weekly decision scorecard from the gateway host: its <state>/decision-scorecard/latest.json (headline numbers only: open-phrasing recall at the 0.90 / 0.95 floors, is_command at the floors, the controls, the operator's labels), one ssh read through `paths.py… |
| `just verbs::decision-scorecard-labels host="mini"` | The operator's labels alone, now, on the gateway host from its checkout: every turn-outcome record since 2026-10-27 with false_fire / missed_address over the settle label, scored from the router's logged p at the last card's floors (or r13b s0's documented 0.883 / 0.9… |
| `just verbs::verb-score-air provider pack="v1" seeds="4" *args` | One scorer run on the Air, end to end (tee-up 1510 slice 8): ship the tree, a scratch venv per provider (PyPI or the named upstream at a pinned commit), model files by curl, the run traced per call, the receipt fetched back and rendered with `scorer_table.py --view open`. |

## `just decision::…` (`just/decision.just`)

The decision model's helpers on the mini: install the ANE decision.v1 helper (runtime/systemone-ane).

| recipe | what it does |
|---|---|
| `just decision::install-systemone-ane *args` | Ship `runtime/systemone-ane` (kev r6, CoreML build J on the ANE, decision.v1 on 127.0.0.1:8873) to a host's runtime root. The ask: the helper lives on the mini beside qwentts.cpp; |
| `just decision::reinstall-systemone-ane *args` | The mini's helper binary (2026-10-08 17:10) predates `--state-build`, so the plist's `--state-build .../build-T64 --state-boundary on` is accepted and ignored, and engine report is not served either. |
| `just decision::score-archive *args` | The injection-archive held-out half (decision-r14-arm section 2c) is scored ON A FLEET HOST and the file never leaves the fleet. |
| `just decision::outcomes-export *args` | The gateway's turn-outcome records (`[training] outcomes`: one record per settled router decision with what followed) as a de-identified aggregate: counts by outcome, settle, top pick, is_command decile, stable verdict, playback, model and verb, plus delay percentiles; |
| `just decision::false-fire-read *args` | The operator's false-fire labels ("I wasn't talking to you", the Admin's "Wasn't for me") joined to their turn-outcome records' decision_context, as counts against the other acted-on turns. |
| `just decision::label-read *args` | The operator's two labels per day: false fires ("I wasn't talking to you", "Wasn't for me") against the other acted-on turns and missed addresses ("I was talking to you", the Admin's "Missed") against the other not_armed drops, each with the is_command decile and the de… |
| `just decision::r19-gonogo host="mini"` | The r19 go/no-go read: per source (laptop Glyph, mini Glyph, puck) the turn-outcome records, the operator's labels, r13b s0's floor fires per class and what an audio field would veto at a fixed recall, with the shuffled and keyword controls. |
| `just decision::veto-read host="mini"` | The shadow source veto, scored prospectively: the frozen 4-weight logistic in benchmarks/verbs/source-veto-weights.v1.json (fitted once on 10-27's records: r13b s0's logit, the span's level over its floor, SoundAnalysis speech_max, the span's length) read on the gateway host's records… |
| `just decision::rollback-systemone-ane *args` | The rollback of a served ANE build swap ("lock only if p95 <= 400 ms, else back to L"). |
| `just decision::cuelight-veto-read outcomes sessions` | The shadow CueLight veto, scored prospectively: the frozen logistic in benchmarks/verbs/cuelight-veto-weights.v1.json (fitted once through 2026-11-07: the r13b family's is_command logit, the span's length, CueLight's speech mean and max) read on a private copy of the gateway host's turn-outcome reco… |
| `just decision::stage-systemone-ane *args` | Stage a build's package on the gateway host for the nix host configuration's served-build one-shot (modules/fox9-systemone-ane.nix, scripts/fox9-served-build.sh: the operator's whole part of a helper build swap is the host's `./scripts/apply.sh`). |

## `just telemetry::…` (`just/telemetry.just`)

Read-only reads of the gateway's traces: the day's rows off the mini (speaker, latency, guard, shadows).

| recipe | what it does |
|---|---|
| `just telemetry::day-rows *args` | The day's four aggregates (speaker rows, the per-turn latency verdicts, the injection guard, the two decision shadows) since a binary's first session, read on the mini over `ssh -4` with nice 10; aggregates only come back; |
| `just telemetry::wake-hold-scorecard *args` | The wake and hold lanes in standard forms per device (laptop, mini, codec, puck): KWS wakes and false-accept proxy per listening hour, FRR from the operator's labels and the label-free proxy, VAD p_miss / p_fa / DCF against the segmenter, the hold's sett… |

## `just fleet::…` (`just/fleet.just`)

The fleet manifest's paperwork: a new host's entry, validated, and the probe key's authorize command.

| recipe | what it does |
|---|---|
| `just fleet::add-host *args` | Render a new host's fleet manifest entry (a name, never an address), validate it with fleetctl's manifest rules (and `fleetctl list` when installed) and print the operator's one-line authorize command. Writes nothing, ssh-es nowhere; |
| `just fleet::park-plan *args` | A park plan (the disk ruling: one TSV row per folder or glob under the source root, `park` or `park>Nd`) carried out in three passes that never delete (tools/fleet/park_plan.py): for a local `--source` the copy pass and the SHA-256 checksum pass run and the cleanup is wr… |
| `just fleet::macos-canary *args` | (step 0 of S1): the macOS upgrade canary, read-only. `run --host laptop` probes this machine; `run --host mini` pipes the probe to the host over its route (tools/repo/paths.py). |
| `just fleet::herdr-machines-plan *args` | CL21 (ADR 0054 S1) The herdr machines declared in the fleet manifest (a host row's `"herdr": true` or `"herdr": {...}`; tools/fleet README), reconciled on THIS host by the installed vulpine-fleet (`just install-vulpine-fleet`; |
| `just fleet::herdr-machines-apply *args` | runs `bin="${FLEETCTL:-$HOME/.local/state/foxline/bin/vulpine-fleet}"; [ -n "${FLEETCTL:-}" ] \|\| [ -e "$bin" ] \|\| bin="${bin%/*}/fleetctl"; "$bin" herdr-machines apply {{args}}` |
| `just fleet::herdr-hosts-env *args` | ADR 0054 S2 The herdr hosts the fleet manifest declares, by the installed vulpine-fleet. |
| `just fleet::herdr-census *args` | runs `bin="${FLEETCTL:-$HOME/.local/state/foxline/bin/vulpine-fleet}"; [ -n "${FLEETCTL:-}" ] \|\| [ -e "$bin" ] \|\| bin="${bin%/*}/fleetctl"; "$bin" herdr-hosts census {{args}}` |
| `just fleet::warp-beacon-install *words` | The WARP home profile (tools/fleet/warp_home.py, tools/fleet README "WARP at home"): a TLS beacon on the mini's LAN address is a Zero Trust managed network, and the home device profile (the private profile's settings, the whole 10/8 range excluded) wins there. |
| `just fleet::warp-beacon-check *words` | runs `#!/usr/bin/env bash` |
| `just fleet::warp-home *args` | runs `/usr/bin/python3 tools/fleet/warp_home.py {{args}}` |
| `just fleet::overlay *args` | CM10 (ADR 0053 S3) The fleet overlay's paperwork (tools/fleet/overlay.py): `key` prints the operator's one command that mints a one-use tagged pre-auth key on the control VM over IAP and pipes it into `store-key` (0600 under ~/.config/vulpine/secrets, never printed); |
| `just fleet::reach-latency *args` | (Reach S5, ADR 0053 addendum A7): the reach latency budget from a relay's own log: the `reach up` and `reach_path` rows vulpine-relay writes, as A7's legs (dial to first byte on the relay path, the punch, the direct and relayed RTT) with p50 and p95 against their targets. |

## `just catalog::…` (`just/catalog.just`)

The Catalog index (ADR 0024): build it from the tree and validate it with typed failures.

| recipe | what it does |
|---|---|
| `just catalog::index` | Rebuild tools/catalog/index.json from the tree — every package's kind, id, version, root, entry points and digest. The tool is the index's only writer; the gateway reads it for the Admin Catalog section. |
| `just catalog::validate *args` | Validate the tracked index against the tree and a fresh build (tools/catalog/README.md "## Validation contract"). Typed failures, one per line: unknown_kind, duplicate_id, bad_version, missing_entry, stale_index, index_unreadable. Exit 2 on any failure. |
| `just catalog::tool-check dir *args` | TV1-S5 (tool.v1, 2026-11-01) (ADR 0058 §5, §9): the tool.v1 conformance kit on one tool folder: the manifest's lint (tool_manifest.ts's rules by name), its golden calls through the real handler plus the generated negatives (no network unless --net), the slim declaration's and the guide's… |
| `just catalog::build-door out="target/door"` | DOR: the tool door as bundled JS for the gateway app's one bun (Contents/Helpers/vulpine-bun). |
| `just catalog::hardpoint-check *args` | EX1 (ADR 0059 §5): check your own hardpoint through the gateway's bind path: admission of catalog/hardpoints/<id>/hardpoint.toml under the runtime root, then the slot's qualification probe (tts renders `Hardpoint check.` to bytes, never played; |

## `just docs::…` (`just/docs.just`)

The docs: checks, the generated reference and index, the site, the changelog fold, the reader test.

| recipe | what it does |
|---|---|
| `just docs::docs-check *args` | Docs baseline: links, anchors and repo paths in the tracked Markdown. Report-only; pass `--fail-on broken_link,...` and paths to gate. |
| `just docs::docs-site-stage` | The docs site (Blume, site/): stage the docs into site/docs/ with a sidebar from the map and the classes. |
| `just docs::docs-site-build host="air"` | Node from nixpkgs; output in <host>:~/ghq/github.com/voidfab/fox9-workbenches/docs-site/dist (a Node server, MCP at /docs/mcp: `npm start` there). Build the docs site on a host with room for node_modules (not the laptop), as a trial. |
| `just docs::docs-site-roll host=mini` | Syncs the mini's checkout, stages, runs `npm ci` + `blume build` in site/ and restarts the fox9-docs agent (the nix host configuration modules/fox9-docs.nix); the brain's `fox9docs_*` MCP tools read the same server. |
| `just docs::docs-retrieval-eval out=""` | Score the served docs search on benchmarks/docs-retrieval/questions.toml without a model: hit@1, hit@5 and MRR with the voice brain's filter (living, decision, generated). The MCP calls run on the mini over ssh. Docs search eval; |
| `just docs::docs-reference *args` | Regenerate docs/reference/ (CLIs, brain tools, config, recipes, components) from the sources; --check for hooks. |
| `just docs::docs-coverage *args` | Does every CLI, brain tool, config section, recipe and component appear in a doc? |
| `just docs::docs-mcp-add host=mini` | The mini refuses ssh port forwarding, so ssh runs tools/gateway/mcp_stdio_bridge.py there against the loopback URL. Register the docs site's MCP server with Claude Code on this machine (local scope, over ssh). |
| `just docs::atlas-mcp-add bin="atlas"` | Register atlas's code-graph MCP server (`atlas mcp`, stdio: callers, impact, trace) with Claude Code, local scope. Never installs. The Atlas IDE's launcher is also called `atlas` and has no `mcp` subcommand, so the binary's --help must list `mcp`; pass a path to use a binary off PATH. |
| `just docs::docs-index *args` | Regenerate docs/llms.txt (the living docs and ADRs for agents); --check for hooks. |
| `just docs::changelog-fold` | Fold changelog.d/ fragments into CHANGELOG.md under Unreleased. |
| `just docs::docs-check-test` | runs `uv run --with pytest==9.1.1 pytest -q tests/test_docs_check.py tests/test_docs_index.py tests/test_changelog_fold.py tests/test_scan_hidden_unicode.py tests/test_doc_sync.py tests/test_docs_reference.py tests/test_api_catalog.py tests/test_docs_site.py tests/test_docs_public.py tests/test_docs_site_vercel.py tests/test_vercel_deploy.py tests/test_docs_retrieval_eval.py tests/test_mcp_stdio_bridge.py` |
| `just docs::docs-inventory day="2026-10-06" *args` | Inventory and triage of every tracked doc: class + the rule that gave it, lines, last commit, inbound links, map, docs-check findings, and one verdict each (keep / historical / merge-into / delete). |
| `just docs::docs-reader-test *args` | The no-context reader test. A codex reader (sol 6.1, isolated: no hooks, MCP, web or shell) given ONLY the living docs (docs/knowledge-surfaces.json, historical sections dropped) answers the twenty questions of benchmarks/docs/reader-questions.json citing a doc; |
| `just docs::docs-site-build-vercel dir="site" scope="full"` | The docs site for the `vulpine-docs` Vercel project, preview only (the operator deploys it prebuilt; apps/site/README.md, "Deploying"). |
| `just docs::docs-site-deploy-vercel dir *args` | Build the docs into `dir` and deploy them to the `vulpine-docs` Vercel project as a PREVIEW, in one command (tools/docs/vercel_deploy.py): the build, `vercel link`, `vercel deploy --prebuilt --target preview`, a second deploy when Vercel made the project's first one production, a smoke fetch (/docs… |
| `just docs::omni-mcp-add url="http://127.0.0.1:51234/mcp"` | Omni is the laptop's local semantic file search (Settings > Serving: loopback 127.0.0.1:51234, MCP at /mcp, no token on loopback). |
| `just docs::map-render *args` | Re-render a living architecture map through archify against this checkout (tools/architecture_maps/map_render.py): docs-check's map evidence first (the pinned revision, every component source a file at it and still in the tree), then archify's own validate and deliver into the map's meta.output. |
| `just docs::vet-archive *args` | The private vet archive on the archive volume, where the vet working files (the tools/notes_vet reports and prior maps and the superseded barge prompt) live instead of git. The folder is vet-archive under the private store's root (VULPINE_PRIVATE_ROOT; |
| `just docs::vet-lead-audit *args` | The vet LEAD audit. Every LEAD in a docs/implementation-reviews/notes-vet-* record (either lens: VERDICT or the devtool pass's VERDICT-2) maps to a tracker item, or carries a minted / merged / done / superseded disposition in tools/notes_vet/lead-dispositions.json. |
| `just docs::docs-public *args` | The guard over the docs the public build stages (the `public` list of docs/knowledge-surfaces.json): no tracker id, lane or tee-up reference, private word or link into the internal set. `--scan PATH...` applies the text rules to a doc that is not public yet; `--list` and `--words` print the set. |
| `just docs::docs-site-stage-public` | Stage the public docs set only into site/docs/ (no records, skills or links to the repo); writes over a full stage. |

## `just verification::…` (`just/verification.just`)

The verification contracts: routes, qualification candidates, Tart, the reference corpus.

| recipe | what it does |
|---|---|
| `just verification::tart-qualification-prepare config deadline authority out` | Repository-owned preparation only: no SSH, VM, acquisition, or native execution. |
| `just verification::tart-qualification-check packet` | runs `mise exec -- python tools/tart_qualification/tart_qualification.py check --packet "$1"` |
| `just verification::tart-qualification-check-native packet cargo` | runs `mise exec -- python tools/tart_qualification/tart_qualification.py check-native --packet "$1" --cargo "$2"` |
| `just verification::tart-qualification-test` | runs `PYTHONDONTWRITEBYTECODE=1 mise exec -- python -W error::ResourceWarning tests/test_tart_qualification.py -v` |
| `just verification::aec-weights *args` | Fixed hash-checked build input; an existing corrupt file is refused, not replaced. |
| `just verification::qualification-template base output=".t/qualification/candidate.toml" *args` | Create a signed-commit/tree-bound local qualification manifest. |
| `just verification::qualification-candidate manifest archive` | Validate, scan, and archive an exact signed publication candidate in one fail-closed command. |
| `just verification::qualification-candidate-test` | runs `mise exec -- python tests/test_qualification_candidate.py -v` |
| `just verification::verification-routes-validate` | Validate the machine-readable verification routes and their non-vacuity tests. |
| `just verification::verification-routes-inventory` | runs `uv run python tools/verification_routes.py inventory --manifest docs/verification-routes-v2.json --repo-root .` |
| `just verification::verification-routes-test` | runs `uv run --with pytest==9.1.1 python tools/verification_cargo_delta.py --route-tests` |
| `just verification::hosted-toolchain-bootstrap-test` | runs `uv run --with pytest==9.1.1 pytest -q tests/test_hosted_route_executor.py` |
| `just verification::verification-routes-assess receipt tree` | runs `uv run python tools/verification_routes.py assess --manifest docs/verification-routes-v2.json --receipt "{{receipt}}" --expected-tree "{{tree}}"` |
| `just verification::feature-delivery-pilot-validate manifest receipt trace lifecycle` | Temporary fixed-schema validator for one reviewed data-only loadout pilot. |
| `just verification::reference-corpus-scan inbox="_zips"` | Build the exhaustive metadata-first local source register without extracting or executing candidates. |
| `just verification::reference-corpus-verify inbox="_zips"` | Rehash the complete local inbox and prove exact register equality. |
| `just verification::reference-corpus-test` | runs `uv run python tests/test_reference_corpus.py` |

## `just repo::…` (`just/repo.just`)

Repo hygiene and lanes: the Python tests, the JS lint, the tree checks, worktrees, merges and pushes.

| recipe | what it does |
|---|---|
| `just repo::test-python *args='tests'` | The whole tests/ directory from one command: the modules it imports (numpy, scipy, jiwer, fastapi; mlx on Apple silicon only — elsewhere the mlx tests skip with their reason) and the repo root on the path. |
| `just repo::test-python-mlx *args='tests/test_mlx_pointer_train.py tests/test_verbs_mlx_head_runner.py tests/test_head_export.py tests/test_verbs_head_server.py tests/test_verbs_router_head.py tests/test_verbs_router_head_r9.py tests/test_verbs_router_head_r9_views.py tests/test_verbs_act_head.py tests/test_verbs_family_view_oracle.py'` | test-python plus mlx-lm: by default the test files that skip themselves without mlx / mlx-lm (importorskip or a find_spec skipif; there is no marker): the pointer trainer, the head runner / export / server, the router, act and family-view heads. Tiny random models, no weights loaded. |
| `just repo::js-lint *files` | JS/TS checks. Oxlint and fallow gate at push; Oxfmt is report-only until the one-time reformat is ruled on. Both run through mise (the versions mise.toml pins, offline), so a lane shell without mise on PATH runs them before a commit too (ideas). |
| `just repo::js-audit base="origin/master"` | `fallow audit` against the base; its base cache goes to the archive volume when mounted and is pruned to the newest three (tools/repo/fallow_audit.py). |
| `just repo::js-health-baseline` | Re-save the per-file complexity counts after a pure-move commit. |
| `just repo::fmt-js-check` | Oxfmt: `just fmt-js-check` counts unformatted tracked files; `just fmt-js FILE…` formats the named files. |
| `just repo::fmt-js +files` | runs `oxfmt -c .oxfmtrc.json {{files}}` |
| `just repo::worktree-reap *args` | Finished linked worktrees (branch gone from origin, HEAD in origin/master, idle 24 h): dry run lists them; --apply archives edits to the archive volume, removes the worktree and deletes its branch. |
| `just repo::worktrees-gc *args` | Agent worktrees by merge state, dirtiness and idle hours; --remove-merged-clean selects merged + clean + idle (--min-age 2 h) ones under .claude/worktrees with no running process in them (dry run; --apply removes, branches kept). |
| `just repo::merge-lane branch *args` | Cherry-pick a lane branch onto the current branch: tracker conflicts (events union + dedupe, item front matter by key) and receipts both sides appended to resolve by construction; |
| `just repo::push-quiet *args` | Wait for an idle laptop (root >= 4 GiB, load < 30, memory free >= 10 %, no rustc/swiftc/tauri build, no other push; poll 60 s; `--no-idle` skips it), then for the 1-minute load < 8 (poll 30 s; |
| `just repo::remote-cargo worktree lane cargo_args *flags` | cargo for a lane on the Air in a synced copy of its worktree: the Air slot by --slot <dir> (mkdir, 60 s polls, released when cargo exits), the changed .rs touched after the slot, --private-target (APFS clone, removed at close), --dry-run prints the plan; the exit is cargo's. |
| `just repo::remote-cargo-kill lane *flags` | Stop a lane's cargo on the Air: its pid file's process group gets SIGTERM, SIGKILL after 10 s, one ssh bounded at 30 s; a stale pid file is reported, not an error; the slot is not touched. |
| `just repo::push-kill step="gateway-tests" *flags` | Stop a push step's process group on the Air (gateway-tests or verification-route-tests) from its pid file under vulpine-lanes/push: SIGTERM, SIGKILL after 10 s, one ssh bounded at 30 s; the slot is not touched. |
| `just repo::lanes-migrate slot *flags` | One-time: move the Air's ~/fox9-lanes to ~/vulpine-lanes and link the old name back for one release; refused while a lane tool, a cargo or a pid file is live; holds the given slot for the one ssh; deletes nothing. |
| `just repo::disk-snapshot *args` | Dated du snapshot of $HOME, the checkout, worktrees, ~/tmp and cargo targets under ~/.local/state/vulpine/disk-snapshots/ (the resolved state root), with the top growers since the last one. Read-only. Daily launchd template: runtime/disk_snapshot/com.voidfab.fox9.disk-snapshot.plist. |
| `just repo::disk-snapshot-python *args` | The disk snapshot's Python (runtime/disk_snapshot/disk_snapshot.py), the rollback for one release |
| `just repo::disk-snapshot-fixtures *args` | The disk-snapshot port's fixtures (benchmarks/fixtures/disk_snapshot/). Nothing measures a real disk: each case runs over a fresh temp tree with a fake du, git, script and dua as all of PATH, a fixed clock and fixed free space. |
| `just repo::disk-hygiene-test` | runs `uv run --with pytest==9.1.1 pytest -q tests/test_worktree_reap.py tests/test_worktrees_gc.py tests/test_disk_snapshot.py tests/test_disk_snapshot_fixtures.py tests/test_merge_lane.py` |
| `just repo::git-isolation-test` | Tests that run git never inherit a hook's GIT_DIR: lint + sentinel regression. |
| `just repo::runtime-tools-check *args` | (ADR 0041 §2): every spawned runtime path has a runtime-tools.toml entry and every runtime .py is on runtime-python-exceptions.toml. `--list` prints the derived spawn set; `--port-queue` the ranked port queue. |
| `just repo::providerctl-fixtures *args` | The providerctl port fixtures (benchmarks/fixtures/providerctl/): `compare` runs the Rust binary and the retired Python tool over every case, byte for byte; `record` rewrites the cases from the Python tool. docs/port-recipe.md. |
| `just repo::host-literals-check *args` | No NEW home-directory (/Users/<name>) or mini-alias literal in code, plists, templates or the justfile (the pre-commit step `host-literals`). Hosts and paths resolve through tools/repo/paths.py (env, then ~/.config/foxline/fox9.toml, then today's default); |
| `just repo::tracked-size-check *args` | No tracked file over 1 MiB unless tools/repo/tracked_size_allow.txt lists it with a category and reason (the pre-commit step `tracked-size`). `--list` prints every tracked file over the limit, `--strict` also fails on an allow-list entry the tree has outgrown. |
| `just repo::naming-check *args` | (ADR 0042, proposed): a NEW identifier, env var, launchd label, path, crate or package name uses vulpine; a new foxline name or a new fox9 path/env/label/package fails (the pre-commit step `naming` checks the staged diff). |
| `just repo::naming-inventory *args` | The alias table of docs/naming.md (every foxline / fox9 / vulpine family, its vulpine name, alias and migration step), regenerated from the tree (`--write` rewrites the doc's generated block, `--json` gives every folder count, `--steps` sums the families by ADR 0042's migra… |
| `just repo::notices *args` | THIRD_PARTY_NOTICES.md from the Cargo.lock / bun.lock / package-lock.json sets, the Python requirements (the justfile's --with pins, PEP 723 blocks, requirements files) and the hand-kept tools/repo/notices-extra.toml (ports, patches, weights, models, rules). |
| `just repo::notices-check` | The pre-commit step `notices` — exit 1 when THIRD_PARTY_NOTICES.md is stale (date line ignored). |
| `just repo::boundaries-check *args` | (docs/boundaries.md): the three boundary checks over the whole tree — no secret in argv, a log line or a literal (`secret_shape_check.py`); household audio and private rows to fleet hosts only (`audio_destination_check.py`); |
| `just repo::hook-tiers *args` | The hook tiers. With no args, rewrite docs/reference/hook-tiers.md from hk.pkl's `// tier:` lines (fast = every commit, < 10 s; push = every push, <= 3 min; long = the nightly hook); `--check` is the pre-commit step `hook-tiers`; |
| `just repo::fleetctl-fixtures *args` | benchmarks/fixtures/fleetctl/: a fake ssh, a fake local interpreter and a fake moraine socket, so nothing reaches a host; `record` rewrites the cases from the Python tool under /usr/bin/python3. docs/port-recipe.md. |
| `just repo::recipes-check *args` | The justfile's front page holds at most twelve public recipes, every recipe name from before the module cut (tools/repo/recipes_legacy.txt) still runs bare, and every tool a recipe body runs exists — the pre-commit step `recipes`. `--json` prints the counts by module. |
| `just repo::system-python-check *args` | BG9 (ledger row 577): every tool run by an absolute /usr/bin/python3 (the gateway's config defaults, vulpine-glyphctl doctor's footprint.py, the roll's host scripts) compiles under that 3.9 interpreter, and no annotation it evaluates at import uses `X \| Y` without the future import. |
| `just repo::roomctl-fixtures *args` | benchmarks/fixtures/roomctl/: five fake devices on loopback (tts-server, Home Assistant, a UPnP renderer, a Sonos TLS websocket, an SSDP responder) and a fake `say`, so nothing reaches a speaker; `record` rewrites the cases from the retired Python tool under /usr/bin/python3. docs/port-recipe.md. |
| `just repo::brainctl-fixtures *args` | benchmarks/fixtures/brainctl/: presencectl.py, selwrite.py and homeact.py against a fake Admin socket in a temp folder (nothing reaches the gateway); |
| `just repo::homectl-fixtures *args` | benchmarks/fixtures/homectl/ (port 4): Home Assistant (REST and websocket on one loopback port) and the station directory faked, a virtual clock, a temp HOME, so nothing reaches a light, a lock or the internet; |
| `just repo::frigate-relay-fixtures *args` | benchmarks/fixtures/frigate_relay/: an MQTT broker and the gateway's webhook intake faked on loopback, a virtual clock, a temp HOME, so nothing reaches the house broker, Frigate or the gateway; |
| `just repo::visionctl-fixtures *args` | benchmarks/fixtures/visionctl/: Frigate's HTTP API and the vision model faked on loopback, a fake sips and ffmpeg as the only programs on PATH, a virtual clock, a temp HOME and TMPDIR, so nothing reaches a camera, Frigate or the vision host; |
| `just repo::vulpine-env *args` | vulpine-env.toml, the typed environment. `check` validates the schema and fails on a stale generated loader (crates/vulpine_env/src/lib.rs, crates/vulpine_env/ts/vulpine-env.ts); `generate` rewrites them; |
| `just repo::fleet-probe-fixtures *args` | The fleet probe port, `record` \| `compare` \| `live`. Fixtures in benchmarks/fixtures/fleet_probe/: fake system tools first on PATH, a fake HOME, a frozen clock and a loopback fake of the two quota endpoints, so nothing leaves the machine; |
| `just repo::read-guide area` | A commit that stages a guarded path (tools/repo/read_receipt.toml: turn.rs, decision.v1.md, approval_queue.rs) carries `Read-Guide: <area> <sha12> <YYYY-MM-DD>`; this names the area's guide and prints the trailer for its current bytes. |
| `just repo::preflight *args` | The eleven checks the orchestrator runs by hand before every push, in order, as one table (check, rc, seconds, first failing line): the hosted-diagnostic pins, the routes inventory, the tool catalog, the Catalog index, the QA catalog, docs-check with the push gate's --fail-on list read… |
| `just repo::push-roll push version *args` | Push master, then roll v<version> on the mini, from two numbers: the wait (no other push, root and load), `just push-quiet` logged to <lane dir>/push/push-<n>.log and the push-logs folder, the roll with its exported env and the python3 link (no ssh/scp shims), the mini c… |
| `just repo::push-roll-receipts *args` | The lane folder's roll-<v>.json receipts as one table (version, push, sha, pid, speaker, rc, failed step, minutes, finished), newest N by version, for the ledger and the tee-ups. `--last N` (10), `--lane-dir` (default $LANE_DIR); reads files only (tools/repo/push_roll.py receipts). |
| `just repo::remote-cargo-base worktree lane cargo_args *flags` | (ideas): remote-cargo with `--base-ref master` and `--no-fail-fast` (put into a test run's cargo arguments before any `--`), so "is this failure mine?" is one short command: the same cargo runs on master in the same slot and the failing tests print as mine / pre-existing /… |
| `just repo::clippy-gate-light` | (ideas): the release gate's clippy (`just release-check`) covers the gateway and fleetctl only, so the glyph crate's warnings piled up between full checks (cleared 11). |
| `just repo::prompt-corpus-check *args` | (opinionate-main's prompt-corpus guards): the pre-commit step `prompt-corpus` (CLAUDE.md's @-imports resolve; |
| `just repo::rust-file-ceilings *args` | (the shep vet): the Rust file-length ratchet's ceilings moved down to today's counts. Every listed file that shrank gets its new count, a file back at or under 1,000 lines leaves the list; |
| `just repo::clippy-ratchet *args` | (the harness vet): the per-crate clippy ratchet over the whole workspace. One `cargo clippy --workspace --all-targets` pass with tools/repo/rust_lint_ceilings.toml's `lints` on at warn (never deny; mise.toml's Rust, not rustup's default), each finding counted once per crate; |
| `just repo::rust-lint-selftest *args` | CL23 (BeautifulRust's lints/check, MIT): every lint the repo turns on (the ratchet's `lints`, the root Cargo.toml's [workspace.lints], the root clippy.toml) fires on its marked line in the fixture crate tools/repo/rust_lint_fixture and nowhere else, so a lint a toolchain bump silences i… |
| `just repo::task *args` | opt-in local result caching, one or several independent targets. --list discovers admitted checks; --fresh bypasses reuse; --explain shows cache inputs. Examples: just repo::task docs-tests admin-tests; just repo::task --list |
| `just repo::remote-check *args` | The existing staged gates on a build host, never an empty-index check. Requires a clean committed candidate and an explicit host slot; no laptop fallback. |

## `just herdr::…` (`just/herdr.just`)

What a pi in a herdr pane loads: the global pi extensions shipped to a fleet host (fox9-agent-guard).

| recipe | what it does |
|---|---|
| `just herdr::deploy-agent-guard *args` | fox9-agent-guard carries guard.ts's agent rule packs (and the hard tiers on bash/write/edit) into every pi that herdr runs in a pane. |
| `just herdr::deploy-codex-guard *args` | fox9-codex-guard carries the same agent rule packs into every codex that herdr runs in a pane. |
| `just herdr::deploy-report-carrier *args` | A claude, codex or opencode stage reports like a pi stage. |
| `just herdr::deploy-pane-extensions host *flags` | The four in-pane pi extensions (fox9-report, fox9-approval, fox9-todo-list, fox9-agent-guard) are INSTALLED copies under ~/.pi/agent/extensions that nothing refreshed when the checkout moved (AR14). |
| `just herdr::maintenance host minutes *flags` | A herdr restart or upgrade lists no agent at all, and the pipeline stall rule read that as every stage's agent gone (every running pipeline ended PARTIAL). |
| `just herdr::restart host *flags` | herdr's own restart and upgrade open the maintenance window THEMSELVES, then run herdr's command on the same host, so nobody runs `just herdr::maintenance` first. |
| `just herdr::upgrade host *flags` | runs `#!/usr/bin/env bash` |
| `just herdr::hc-restart host *flags` | (ADR 0055 §8, §9): herdr-core (`hc`) beside the 0.9 recipes above, which stay until the cutover. hc-restart = `hc server restart` on that host, no maintenance window (hc keeps every terminal across its own restart). |
| `just herdr::hc-upgrade host *flags` | runs `#!/usr/bin/env bash` |
| `just herdr::hc-approve-install host *flags` | (ADR 0055 §4 and its CO13 addendum): vulpine-hc-approve, a crate bin (crates/hc_approve, ADR 0041 §1), at [herdr] approve_bin on an hc machine (default ~/.local/state/foxline/bin/vulpine-hc-approve). |
| `just herdr::bench-backends root out *flags` | BX1 (batch BX): herdr 0.9 against herdr-core (hc) on the same workloads, on SCRATCH instances only: a herdr 0.9 server with its own HOME and an hc core with its own HC_SESSION and XDG folders under <root> (the lane's scratch folder). |

## `just lane::…` (`just/lane.just`)

The orchestrator's batch bookkeeping (mint, record, hold, ids) and the lanes' script runner.

| recipe | what it does |
|---|---|
| `just lane::mint batch spec *flags` | Mint (or update the draft of) every lane's item from a spec TOML, keep <batch>-batch.toml and write <batch>-ids.txt ("<lane> <FOX9-id>" per line). Restartable: a lane that already has an item is skipped. |
| `just lane::record batch lane agent *flags` | Record the agent id the launch returned for a lane; rewrites agents-<batch>.txt and prints the branch name. |
| `just lane::hold batch lane *after` | Hold a lane until the named lanes land (no names clears the hold); prints the merge order. |
| `just lane::ids batch *flags` | Print (and rewrite) <batch>-ids.txt from the batch TOML. |
| `just lane::run script *args` | Run a lane's helper script from the lane worktree with a clean env, one log line in $LANE_RUN_LOG, and a refusal before the run on git push/stash, --no-verify, rm -rf outside the worktree and the scratchpad, or a temp literal. |
| `just lane::launch-brief batch lane *flags` | Print the header a lane brief starts with, from the batch TOML: the item and title, LANE_DIR, LANE_SCRATCHPAD, LANE_RUN_LOG, the rules, brief and ids files, the agent branch once recorded, the hold and the lane_run line. |
| `just lane::link-modules batch lane *flags` | Link the main checkout's node_modules into a lane worktree (one symlink per tracked package.json folder, never a copy, never over something there); `record` does it already, this reruns it once the worktree exists. |
| `just lane::receipt first second *rest` | Keep remote_cargo's --json line (a file holding it, or the JSON) under the lane's table in <batch>-batch.toml; `hold` and `ids` then show mine/pre_existing/rc per lane (ideas ledger row 168). |
| `just lane::squash message *flags` | A lane's commits as one commit that cannot revert master: the soft reset goes to the merge base with master (or --base), never to master itself; then one commit, checked to change only the squashed commits' paths. |
| `just lane::run-master *args` | Run a command on master's bytes of the named files in a temp folder (cwd), refusing a file master lacks: `just lane run-master python3 -m pytest -q -- tests/test_x.py` (the AY4 idea). |
| `just lane::link-here *flags` | A lane links the main checkout's node_modules into its OWN worktree (no LANE_DIR, no batch): the fetch_url tests and every other package import then resolve in the lane. Refuses the main checkout itself. |
| `just lane::capture-herdr-replies host *flags` | Capture herdr's real replies on a host into the reply fixtures (ideas ledger row 321): `workspace create`, `pane list` and `agent start` over the host's route, scrubbed, written with captured: true, the workspace closed after. Starts an agent on the host: the orchestrator's live step. |
| `just lane::slot-status *flags` | The laptop build slot at a glance (ideas ledger row 666): held or free, who holds it and why (the holder note beside the slot, row 667), and the lanes waiting in order. The slot is $LANE_SLOT, else $LANE_DIR/build-slot-laptop; `--json` passes through. |
| `just lane::slot-report *flags` | Where the build slots' minutes went: slot-history as a table, per slot, per lane and per holder note (the push's native gate, the Glyph rebuild, a lane's remote cargo), since 06:00 today unless `--since HH:MM` ('YYYY-MM-DD HH:MM' or epoch); |
| `just lane::receipt-file lane *flags` | A lane's receipt with nothing typed but the lane (ideas ledger row 687): <lanes folder>/<lane>/receipt.md appended to the lane's item from the folder's *-ids.txt, through the same path as `receipt <item> <file>`. |
| `just lane::seed-target lane *flags` | Clone the shared cargo target into the lane's private one with an APFS clone when it is absent (ideas ledger row 715), so a Rust lane's first build is incremental; refuses off APFS or across volumes. `--dry-run` passes through. |
| `just lane::asks *flags` | The operator's own typed prompts for this project since a date (ideas ledger row 404): the main checkout's session transcripts, only the prompts the harness marks human-typed, into one owner-only file outside git; pass `--out <the session scratchpad>/asks-<date>.md`. |
| `just lane::merge-plan *flags` | Predicted merge conflicts before any merge (ideas ledger row 403): each lane branch of agents-<batch>.txt in the lane folder (or --branch B) against master, and each pair of lanes, through merge-tree with its objects in a scratch folder; one line per conflict by file, then the files. |
| `just lane::gate-dry *flags` | The visual gate on master plus one lane before the merge (ideas ledger row 878): the merged tree from merge-tree (its objects in a scratch folder), the gate's paths of it exported into the session scratchpad, node_modules linked from the main checkout, `bun apps/vigil/scripts/visualGate.ts` run ther… |
| `just lane::gpui-clippy manifest *args` | Clippy for a detached GPUI crate (ledger row 1303): cargo clippy on the build toolchain (1.98.1) when it has the clippy component, else on 1.96.1 (clippy and std::hint::cold_path both), with that toolchain's bin first on PATH so Homebrew's cargo never runs; |
| `just lane::new-app app` | A new detached app under apps/ (a Cargo.toml, no package.json; ledger row 1346, BT1 x BT6): appends it to the root Cargo.toml's exclude, the native-spike-contracts route's path_patterns and package.json's `!apps/<x>` negation (each at its end, never reordered), and, when the crate reaches apps/nativ… |

## `just hosts::…` (`just/hosts.just`)

The fleet's ssh routes: which route reaches each host (the LAN name, else the fallback alias) and its socket.

| recipe | what it does |
|---|---|
| `just hosts::doctor *flags` | Per host: whether the LAN name answers (`ssh -4`, BatchMode, ConnectTimeout 5), the fallback alias and its answer, the socket's state (`ssh -O check`: master running, no master, absent) and the route tools will use. Read-only; exit 1 when a host has no route that answers. |
| `just hosts::route host=mini *flags` | The route one host resolves to (a name such as mini, or any alias a host names): the summary, or the argv prefix a tool uses (`--ssh`, `--scp`, `--rsync-e`, `--alias`, `--json`; `--rsync`: `-e '<ssh>' <alias>` from one probe, ledger row 204); `--no-probe` runs no ssh. |
| `just hosts::shim-check *flags` | Which tools still run `ssh` / `scp` from PATH: a static scan of tools/repo, tools/gateway, tools/agents, tools/fleet and the just files for a bare ssh/scp argv, `shutil.which("ssh")` or an ssh/scp command line; nothing runs and no host is dialed. |
| `just hosts::away-doctor host="mini" *flags` | Away from home, when a route refuses (`route: <host>: nothing answers ...`): the fallback master's `ssh -O check`, a bounded (10 s) `cloudflared access token` probe that says valid or expired (never the token), and the login command when it is not valid (the operator'… |

## `just ops::…` (`just/ops.just`)

The operations after a roll (relay, pane extensions, Admin, vulpine-fleet, Glyph), one recipe with a receipt table.

| recipe | what it does |
|---|---|
| `just ops::after-roll host *args` | After a green roll, in the hand scripts' order (tools/repo/after_roll.py): `--relay` restarts the laptop relay agent and runs `vulpine-glyphctl reconnect`; the pane extensions deploy and `--check`; the Admin install; |
| `just ops::notify-test *args` | Notify to the phone: one neutral test push through each configured transport (the Home Assistant companion app, ntfy) in the gateway's own request shapes, and with `--health` the Admin's gateway.notify row (ready and healthy, or the failure). |
| `just ops::env-set host key *args` | One allow-listed key (VULPINE_NTFY_*, VULPINE_NOTIFY_*) into every env file the roll reads on the host: the overlay's overlay.env and its internal mirror (retired/overlay_stdio/overlay_stdio.py ENV_FILE, ENV_MIRROR), both 0600. The value comes from stdin ONLY (a pipe or a file; |
| `just ops::models-stage name host *args` | Stage one small runtime model on a host by its sha256 (tools/install/staged-models.toml: cuelight-nano first): the local source must match the manifest, a host that already has it gets no copy, else the bytes stream over the route's ssh into a .staging file that is renamed into ~/Library/Application… |
| `just ops::stale-paths folder *args` | Worktree paths that scripts in a folder still name: the removed worktrees and every file:line that names one, or with `--removing <worktree>` what a removal would leave stale (run it before removing worktrees). `--depth` (default 2), `--all-files`, `--json` (tools/repo/stale_paths.py). Read-only. |
| `just ops::training-archive *args` | FR1 (2026-11-02) The training archive (docs/operations/training-archive.md): vulpine's training data copied into the private Coldline bucket gs://vulpine-dev-training-archive (vulpine-dev). |
| `just ops::training-archive-install dry=""` | Install the nightly sync (deploy/launchd/com.voidfab.vulpine.training-archive.plist.tmpl, 01:40 local) on this laptop from the main checkout, 0600; `dry=1` prints the plist. The first night macOS asks for Removable Volumes access for the job's interpreter (the operator's click). |

## `just approvals::…` (`just/approvals.just`)

The operator's approval policy helpers: the sha256 pin for a checkout's own .vulpine/policy.toml.

| recipe | what it does |
|---|---|
| `just approvals::trust-repo checkout *args` | Print the sha256 pin for a checkout's `.vulpine/policy.toml` as committed at HEAD and the `trusted_repo_policies = ["<checkout>:<sha256>"]` line to add under `[approvals]` in the operator's approval-policy.toml. |

## `just harness::…` (`just/harness.just`)

The test harness: `just harness lite|full`, one manifest of suites, one receipt, one verdict.

| recipe | what it does |
|---|---|
| `just harness::lite *args` | The lite tier: the laptop smoke (minutes, fakes, nothing audible, no model load, nothing on the mini or the operator's Glyph). Webkit suites wait for the laptop's webkit slot. Flags: --only a,b · --skip a,b · --slots queue\|none\|refuse · --work <dir> · --results <dir> · --no-write. |
| `just harness::full *args` | The full tier: the nightly suites (the mini testbed's with --host mini-testbed; on the laptop its build and webkit suites wait for their slots and the testbed's read NOT_RUN). The same flags as lite. |
| `just harness::check` | Validate the manifest: every suite's tier, hosts, parser and validity rule (exit 2 on a refusal). |
| `just harness::list` | Every suite: tier, hosts, slot or pending lane, and what a PASS proves. |
| `just harness::checkpoint *args` | One checkpoint of a running testbed: its Admin, health, redb store copies, SQLite counts and the trace since the last checkpoint in --out; anything outside the testbed root (the live Admin, 8791) is refused. |
| `just harness::scenario *args` | Scenarios on a testbed with a virtual clock, checkpointed at every `break`: --mode auto (continue at once), pause (wait for `just harness continue`), exit (CI: stop at the first break with its state). --break-at N adds a break before step N. |
| `just harness::continue break_dir` | Release the oldest paused break of a `just harness scenario --mode pause` run (its break dir is printed when it pauses). |
| `just harness::tick *args` | The loop tick: one line on the newest lite receipt (fresh at HEAD, or stale), the last nightly and whether the weekly UI review is due; `--run` runs lite when stale (never while a push runs: exit 5, deferred). |
| `just harness::prepush *args` | The optional pre-push step: a PASS or WARN lite receipt of exactly HEAD on a clean tree, else run lite now; exit by its verdict (0 PASS/WARN, 1 FAIL, 3 INVALID/BLOCKED). Run it before `just push-quiet`, never inside the hook. |
| `just harness::nightly-gate *args` | The mini nightly's idle gate, read-only (exit 0 open, 3 refused): no roll, push, hold, other nightly or running testbed; nobody at the machine; no live conversation for 30 min; memory, load and disk in bounds. |
| `just harness::nightly *args` | The nightly itself (the launchd job runs tools/harness/nightly.py directly): gate, then `harness full` on the testbed with a watchdog; one receipt. On the laptop only with --dry-run or --allow-no-gateway: the full tier is the mini's. |
| `just harness::stage-testbed *args` | The mini full tier's stage, one folder per commit: vulpine-testbed, scenario-runner, vulpine-glyphctl and a built Vulpine.app with stage.json (commit, sha256s). Refuses a dirty tree and a folder of another commit. |
| `just harness::ui-review *args` | The weekly UI review: the week's visual runs per component, a reviewer pass (codex through the shared bulk path, or --reviewer fixture\|none), ADD/CHANGE/REMOVE proposals that name a component and a capture, a page for the operator; --write-ledger appends them to the ideas ledger as `logged` rows. |
| `just harness::perf-class *args` | This host's class (laptop-m3, mbp-m2max, air-m4, mini-m4) and machine. |
| `just harness::perf-pin *args` | Measure and pin cells of this class into benchmarks/pins/<class>.json: waits for a quiet host, five rounds; refuses while a selected cell is unmeasured (--only a,b pins some cells and keeps the rest; --allow-loaded stamps loaded). |
| `just harness::perf-gate *args` | Measure and grade every cell of this class against its pin and budgets: exit 0 held, 1 regressed, 2 UNJUDGED. |
| `just harness::perf-view *args` | The pin of this class, or a gate's report (--from <perf-gate.json>), as one table. |
| `just harness::sweep *args` | The ask: "the full sweet of tests including our property testings". Every suite this laptop and the build hosts can run, in a fixed order (tools/harness/test-sweep.toml), into ONE receipt table: the harness tiers, the property suites with their cases and seeds, every bun suite, every GPUI app on a b… |

## `just feedback::…` (`just/feedback.just`)

Feature requests from use: harvest the brain's unmet asks off the mini into tracker drafts, triage them (CI27).

| recipe | what it does |
|---|---|
| `just feedback::harvest *args` | Read the gateway's feature-request store off the mini (one ssh read through `paths.py route`), create a DRAFT feature under the epic "Feature requests from use" for each request never harvested, update the draft of one asked again since, then write the ha… |
| `just feedback::triage *args` | The harvested drafts nobody has decided yet, as a table (most asked first) with a recommendation each; `--out FILE` writes them as JSON for the orchestrator's selection rows; `--json` prints the JSON. The operator's answers go back through `just feedback::apply FILE`. |
| `just feedback::apply file *args` | Carry out the operator's triage decisions, a JSON list of {item, decision: drop\|prioritize\|add, reason?}: drop scraps the draft with the reason in a `## Triage` section, prioritize sets priority high and clears attention, add writes a `## Triage` section saying next-ba… |
| `just feedback::import-gaps *args` | File script-v3's open gaps (a `none-yet` that no catalog tool fills and no tracker item tracks, per benchmarks/harness/voice-corpus/script-v3-gaps.json) as asked-kind DRAFTS, one per CJ19 candidate. |
| `just feedback::session-review *args` | Last night's session review, from the laptop: reads the mini's <state>/session-review/latest.json (one ssh read through `paths.py route`), written nightly by runtime/session_review/session_review.py, and prints the night's counts (tool failures, refusals, could-not-do… |
| `just feedback::session-review-file *args` | File the session review's recurring issues (seen at least --min-count times, default 2) as DRAFT features in the feature-request shape, so `just feedback::triage` puts them to the operator beside the brain's own asks. |
| `just feedback::session-review-install dry=""` | On the gateway host, from its checkout: render deploy/launchd/com.voidfab.vulpine.session-review.plist.tmpl for this host, install it 0600, load it (05:10 every night) and run the review once now, so the Admin's gateway.session_review row has a receipt at once. |

## `just usage::…` (`just/usage.just`)

The usage ledger: every tool call, verb and door call counted per day, and the never-used report (CJ1).

| recipe | what it does |
|---|---|
| `just usage::report *args` | The usage ledger off the mini's Admin socket (one read over ssh through `paths.py route`; |

## `just infra::…` (`just/infra.just`)

Cloud infrastructure as code: the fleet control server on GCE in vulpine-dev (Alchemy 2; plan, and the operator's deploy).

| recipe | what it does |
|---|---|
| `just infra::fleet-control-check` | The stack's typecheck (bun check) and its rules' tests (bun test), from its own lockfile. No cloud call. just infra::fleet-control-check |
| `just infra::fleet-control-plan *args` | The check, then Alchemy's plan against vulpine-dev with an in-memory state store: provider reads (GETs) only, no create, no state write. Needs gcloud already logged in; it never logs in. Extra flags pass through (e.g. --detailed for every declared property). |
| `just infra::fleet-control-deploy confirm=""` | Operator only. Creates or updates the fleet control VM and its network, address, disk, service account and empty secrets; it bills vulpine-dev (about $18-19 a month, deploy/fleet-control/README.md). Refuses without the confirm word. No lane and no agent runs it. |
| `just infra::fleet-control-render` | The check, then the stack's offline dry run: the firewall rules, the public names, the VM's metadata keys and the iroh relay list, from the same functions the stack declares with. No cloud call, no credential; |
| `just infra::fleet-iroh-allowlist *args` | The fleet iroh relay's allow-list from the gateway helper's paired list. Prints the operator's one IAP command that pipes the rendered list (one hex EndpointId per line) into the VM's data disk and runs the relay's `allowlist` step; it prints no key and runs nothing. |
| `just infra::fleet-iroh-access *args` | PA1 (ADR 0053 P13 ruling 5 option A): print the operator's command that switches the relay to asking the mini's helper about each key (`[reach] relay_access_listen`, iroh-relay's http access mode), and its rollback; runs nothing. |

## `just rust::…` (`just/rust.just`)

The Rust dev toolbox: the cargo subcommands pinned in mise.toolbox.toml (what this host has, install them) (CL24).

| recipe | what it does |
|---|---|
| `just rust::toolbox *args` | Each toolbox tool, its pinned version, what this host's install prints, and the tools this host is missing, read offline (`mise where`, no lockfile written). Exit 0 with missing tools listed; |
| `just rust::toolbox-install` | Install the toolbox on this host: `MISE_ENV=toolbox mise install` on mise.toml's Rust (1.91.0 first on PATH, as lane_cargo.py names it: mise's cargo backend otherwise compiles with rustup's default, 1.88 on the laptop, and cargo-expand / cargo-edit need 1.90+), three build jobs, at nice 10. |
| `just rust::deny *args` | cargo-deny over every tracked Cargo.lock's workspace with the root deny.toml (advisories, licenses, duplicate versions, sources); a GATE workspace's error exits 1, the spikes are counted only. `--json`, `--receipt FILE`, `--only DIR`. |
| `just rust::shear *args` | cargo-shear over the GATE workspaces (the root, the apps, the tool projects; `--all` adds the spikes): a declared dependency no source file names exits 1. Also the nightly step `rust-shear`. |
| `just rust::deps-list *args` | Every workspace rust::deny and rust::shear visit, and its class (gate or report). |
