Skip to content
Vulpine
Esc
↑↓navigate↵open⌘Jpreview
On this page

Recipes

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…

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 (next after the highest v 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-.json;
just rollback version *args The release before v 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--: 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): 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//.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//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--.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/ 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=] (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 Vigil (a build from before the rename passes, named). Args: [host=].
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:/, 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 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// 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 (…
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//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// (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/-.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/, 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/ 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 /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-.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 /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//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 :~/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 (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/) 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 on the mini, from two numbers: the wait (no other push, root and load), just push-quiet logged to /push/push-.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-.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 (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.toml and write -ids.txt (“ ” 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-.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) -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.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): //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-.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 · –results · –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/.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 /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).

Was this page helpful?