---
title: "Glossary"
description: "The glossary: what Vulpine's (fox9's) words mean, from the gateway, brain, skins, Client Core, protocol, agent, persona and loadout to the presentation seams; the decision model, the brain lanes, speech and the install moved to docs/context-runtime-glossary.md on 2026-10-15."
type: "living"
source: "CONTEXT.md"
verified: "2026-11-14"
group: "The voice path"
---

> **Living doc**, checked against the code 2026-11-14

Vulpine is a voice assistant you host yourself. The gateway runs on a Mac in the house: it hears each spoken turn, answers the requests on its own short list of verbs, and hands everything else to your agent, the brain, which runs on Pi today. You talk to it through Vulpine.app on a Mac, a browser tab or a room speaker; Vulpine Gateway.app holds the gateway and its window. You address it by its callsign, "Fox Nine".

This page defines the terms. Glyph and Vigil are looks inside the clients, never app names. Every new identifier takes the name vulpine: env vars, paths, launchd labels, binaries, crates and packages. Existing `foxline` and `fox9` identifiers keep their names until their family migrates; `docs/naming.md` holds the table.

## Language

**Vulpine**:
The name of the protocol and the whole system: the product as people see it, and the name every new identifier takes (ADR 0042).
_Avoid_: Fox9 as the product name in new user-facing text; `fox9` or `foxline` in a new path, env var, label or package name

**Fox Nine**:
The callsign: the name a person says to address the agent, canonicalised to `fox9` by the invocation aliases.
_Avoid_: Vulpine as a wake word

**fox9**:
The canonical form of the callsign and the signing identity's label (ADR 0042). Existing `fox9` paths, env vars, labels and packages are interim and migrate to vulpine with their family.
_Avoid_: fox9 in a new path, env var, launchd label, crate or package name

**foxline**:
The project's first name. It survives in attribution (license, notices, records, commit history) and in the identifier families not yet migrated: config keys, state paths, env vars and the installed gateway path (`docs/naming.md`). The spoken `foxline` / `fox line` are transcript variants of the callsign, not names.
_Avoid_: foxline in any new name

**ACP boundary** (accepted design, ADR 0070; `docs/contracts/acp-integration.v1.md`):
The opt-in agent integration beside the voice path, off in both directions by default. **Outbound**, the operator's Pi
uses an ACP agent; **inbound**, an ACP client uses a dedicated restricted Pi child. A **managed** child is an allocation
Vulpine owns and confines; an **attached** agent keeps its external profile and is reached through herdr with a fenced
writer. Neither capability negotiation nor attachment grants human approval authority. An **isolated approval** is
operator preauthorization bound to a verified managed allocation, immutable scope and expiry, never an impersonated
human click; its executor is off by default and fences delivery on revocation.
_Avoid_: brain transport replacement, sandbox (for a loadout without enforcement), owned agent (for an observed terminal)


**Voice Gateway**:
The reusable runtime that coordinates low-latency two-way voice between a frontend, speech services and a Pi-backed agent. Its crate and cargo binary are `vulpine-voice-gateway` (`crates/voice_gateway`). An install runs it from `<state>/bin/foxline-voice-gateway`.
_Avoid_: Foxline core, codec server, voice orchestrator

**Vigil**:
The look of Vulpine in a browser, fullscreen or on a second screen, drawn as selectable frames (ADR 0043). Eros is the automatic conversation workspace: assistant and operator profiles, avatar and camera controls, editable text, voice and inline visual responses. Minimal is the portraitless choice, and eight legacy frames keep their own looks, including the Metal Gear Solid-style layouts (ADR 0037). Presentation preferences persist; camera and avatar activation do not. Its wire value is `vigil` (`FrontendKind::Vigil`, the `vigil` loadout); Glyph's is `overlay`. The gateway also accepts the former name, listed in `docs/naming.md`.
_Avoid_: the former name as the product name, Codex

**Agent**:
A Pi-backed working identity rooted in a workspace and Pi configuration, optionally refined by voice-specific loadouts. Agent prompts own mission, runtime, tool, and safety policy but remain neutral about character identity and speaking style.
_Avoid_: Character, persona

**Persona**:
The presentational identity used for voice and UI, including display name, voice assets, Persona prompt fragments, and optional frontend-specific representation.
_Avoid_: Agent

A Persona can change within a frontend session without changing the Agent. Switching Agent changes the Brain, workspace and loadout; switching Persona changes voice and reference assets, Persona prompt fragments and presentation identity. Persona prompts alone own character identity, fictional counterpart, address terms and speaking style. Persona packages live in the runtime root's `catalog/personas/`; a workspace that holds a persona folder is refused at bind.

**Avatar Action**:
A semantic presentation request routed through the Voice Gateway to a frontend, such as changing expression, focus, or animation, without prescribing theme-specific visuals.
_Avoid_: MGS animation, sprite command

**Script Visual** (`visual.v1`):
The visual response channel's second tier beside the card (ADR 0047, docs/contracts/visual.v1.md). The brain sends a sandboxed Luau program with `pi_show_visual`; its view returns a typed `ui.*` tree (charts, tables, controls, canvases, 3D scenes, Shadertoy shaders) that a frontend draws natively. The gateway dry-runs it first, and a card-only frontend gets its card projection.
_Avoid_: widget, applet, HTML panel (a visual carries no markup); card (say Card for card.v1)

**Capture** (`capture.v1`):
What the operator shows instead of describing (ADR 0048, docs/contracts/capture.v1.md): a bundle in the frontend's private store of keyframes (a still or a recording), the operator's marks (pins, strokes, boxes in keyframe pixels), the narration and each keyframe's OCR text. It rides a typed turn as `text_utterance { capture }`; the brain gets the marked keyframes as prompt images and the rest as words.
_Avoid_: screenshot (one keyframe is a capture's simplest case); attachment (the wire member's name, not the thing)

**Link Panel** (`links.v1`):
A bounded list of plain labels and optional checked web destinations, separate from passive cards (`docs/contracts/links.v1.md`; built, labeled experimental). Only a frontend that declares the kind receives destinations; others get labels and detail. Opening a destination takes a separate operator activation.
_Avoid_: clickable card (card.v1 stays passive)

**Shown File** (`file.v1`):
The visual response channel's file tier (ADR 0049, docs/contracts/file.v1.md): a file from the gateway's allowed folders that the brain shows with `pi_show_file`. The render names it (name, sniffed type, size, SHA-256) and carries no bytes. The conversation window fetches the bytes by hash and draws them in its file pane through a viewer registry keyed by type; a card-only frontend gets its card projection.
_Avoid_: attachment (a capture's word, ADR 0048), upload, download, preview (the window shows the file itself)

**File Find** (`pi_show_file {describe}`):
The brain asks for a file by the operator's words and the gateway finds it on its own disk (ADR 0049). It ranks a name index of the allowed folders (fsearch's ranking), asks the local decision model on a close call, and otherwise shows a **chooser** of up to three on the operator's screen (`FileSpec.choices`; a tap fetches the one chosen). The brain hears only `found` (`shown` with the kind in words, or `asked_user`), never a name, folder, size or date.

**Feature Request** (`pi_feature_request`):
An ask vulpine cannot do yet, logged by the brain on its own (`proactive`) or because the operator asked (`asked`). The gateway keeps it on the gateway host, deduped on the normalized ask, until `just feedback::harvest` turns it into a draft tracker item.
_Avoid_: feedback (memento's `mm feedback`), bug (a feature request is something missing, not something broken), wishlist (fine to speak, not a type)

**Usage Ledger** (`<state>/usage-ledger.redb`):
The gateway's per-UTC-day count of every **trigger**, kept 90 days across restarts and rolls (ADR 0050): a brain tool call (`brain_*` and MCP tools included), a routed verb or a door call, by tier, name, loadout and outcome (`ok`, `ask_back`, `refused`, `failed`, `cancelled`). It holds counts and times, never words. The Admin's Usage view, the never-used report, graduation and `just usage::report` read it beside each tool's **prefill cost** (estimated schema tokens, `catalog/pi/tool-prefill.json`); `[usage] enabled` (on) is the switch.
_Avoid_: telemetry (the trace and span pipeline), receipts (the `pi_*` tools' per-call lines), stats, analytics

**Tool State** (on, deferred, off):
Each tool a loadout allows is **on** (in the brain's prefill), **deferred** (callable but out of the prefill, found with `pi_tool_search`) or **off** (unavailable to the brain and the door). The Admin's Tools section writes the states to the overlay `tool-toggles.json` under the state root; they apply at the next brain launch, and deleting the overlay turns every tool back on. A **locked** tool (`pi_ask_operator`, the cancel tools, `pi_feature_request`, `pi_tool_search`) is always on.
_Avoid_: disabled (say off), lazy tool (say deferred), hidden tool (Pi's word for a declaration left out of a request)

**tool.v1** / **Prefill Form** / **Tool Guide** (ADR 0058, `docs/contracts/tool.v1.md`):
Every catalog tool speaks **tool.v1**: a call is `{action, args}` with one of eight shared actions (list, get, search, create, update, delete, act, watch), and a result is `{ok, data, receipt, ask_back?, error?}` with closed error codes and a hint. An `on` tool's **prefill form** is `slim` (typed params and a one-line description) or `full` (the whole description; `[brain] tool_form` defaults to it). Its **tool guide** is the how-to text a slim form leaves out, returned by `pi_tool_search {action: "get", args: {names}}`.
_Avoid_: tool schema (when you mean the declaration), tool docs (say guide), verb (for a tool's action; verbs are the gateway's closed table)

**Memory Fact** (`pi_memory_recall`, `pi_memory_propose`):
One short sentence the brain keeps for the operator on the gateway's disk, like "garbage day is Thursday". A fact the gateway heard the operator say (their turn, or their yes to an ask-back) is **kept** at once; one from a tool, a page or an unheard `operator` claim is a **proposal** until the operator says yes, and lapses after 30 days. Recall marks proposals `unconfirmed` and never returns an id, a password, a code or a private number.
_Avoid_: memory (alone: the corpus retrieval store is also memory), note (an mm observation), household fact for anything inferred (household facts are the operator's words)

**Watch** (`brain_watch_set`, `<state>/watches.json`):
A standing "tell me when X": a typed **condition** over a source the gateway already sees, and the **line** to say. The sources: the operator arrives home or enters a room, a herdr agent is done or needs them, a build passes or fails, a camera sees a label, or an owned herdr pane prints a marker (an **output watch**). The gateway speaks the line through the governor's `watch` source with no brain turn. A watch fires once by default (up to 5 times) and lapses after a day (at most a week), optionally within a local time window; the Admin lists and cancels watches.
_Avoid_: alarm (a time of day, `brain_alarm_set`), reminder (fine to speak; the macOS Reminders read is `pi_reminders`), subscription, trigger (the usage ledger's word for any counted call)

**Sound class** / **sound watch** / **sound rule** (`sound_watch.rs`, `<state>/sound_rules.json`, `<state>/sound_classes.json`):
A **sound class** is a household sound in Vulpine's words (`dog-bark`, `water-running`, `tv`) with the labels each **engine** scores it by: `soundanalysis` (the ambient sidecar), `detector` (the 54-class CoreML detector, `fox9-sound-detector`) or `head:<name>` (a custom head); custom classes go in the classes file. A **sound watch** fires on a class held for a minimum time in a **room with a mic** (a room whose frontend streams its mic), with hysteresis and a cooldown. A **sound rule** is the operator's Admin rule "when <sound> in <room> for <time> -> say / notify / home action", the only place a home action runs unattended. Labels and scores only, never audio.
_Avoid_: automation (Home Assistant's word), sound event (the detector's term for one 40 ms tag), trigger

**False-fire label** (`false_fire.rs`, the turn-outcome store):
The operator's mark that a turn Vulpine acted on was not addressed to it, given by the closed verb "I wasn't talking to you" (no brain turn, nothing spoken) or the Admin's "Wasn't for me" on the Recent turns card. It lands in the turn-outcome record (outcome `false_fire`) or as a label row naming the record, and is the router's ground truth for false fires.

**Missed-address label** (`missed_address.rs`, the turn-outcome store):
The operator's mark that a final the gateway dropped unaddressed (`not_armed`) was for Vulpine, given by the closed verb "I was talking to you" (no brain turn, nothing spoken) or the Admin's "Missed" on the Recent turns card. It lands in the record (outcome `missed_address`) or as a label row naming it.

**Label queue** / **label words** (`label_queue.rs`, `label_words.rs`, `<state>/training/label-words/`):
The **label queue** is the Admin section where the operator answers +1 / 0 / -1 whether a settled turn was meant for Vulpine, shown with its **context** (the router's score, what Vulpine was doing, the request before, the utterance after, the device); the answers become false-fire and missed-address labels. The **label words** are the words of every settled utterance, kept owner-only on the gateway host in eight dated files for the queue alone (`[training] label_words`, on). **Echo hold-out** (`[training] label_queue_echo`, on) never offers a turn that was Vulpine's own voice heard back. The **wake-less quota** reserves slots in each 12-turn sitting for turns with no wake word (`label_queue_wakeless_slots` 6), and the **uniform sample** fills some at random (`label_queue_uniform_slots` 3); a label there carries `offered` (`uniform`, `wakeless`).

**Capture ring** / **sound inbox** / **sound head** (`sound_capture.rs`, `<state>/sound_inbox/`, `<state>/sound_heads/`):
The **capture ring** is the last `[sound] ring_seconds` of a session's ambient audio, in memory only. A **capture** freezes a few seconds into the owner-only **sound inbox** when a class enabled for labeling fires, when the operator says "tag that as the neighbor's dog", or from the Admin's Capture now; the operator labels clips in the Admin. A **sound head** (named for the class it splits, `dog-bark`) is a Create ML classifier trained on those labels by `fox9-sound-head-trainer` and loaded by the sidecar as engine `head:<name>`; each label but `neither` becomes a custom class (`dog-bark-neighbors`).
_Avoid_: recording (nothing is recorded until a capture), dataset (the inbox is the operator's labeling queue), fine-tune (only the head is trained)

**Notify** (`pi_notify`, `crate::notify::post`):
A short plain line that reaches the operator where they are: on their board as the governor's `brain_notify` source, spoken when the room allows. A **push** sends it to their phone through a **transport** (the Home Assistant companion app via `homectl notify`, or ntfy) when no session of theirs takes it within 5 s, when the board has not spoken it by its TTL, or at once when **urgent**. A line holds at most 200 characters and no id, hex, path, file name or link, and is deduped and limited per hour; `[notify]` is the switch and names the transports.
_Avoid_: alert (a camera line's word), notification for the governor's surface-only `Notify` tier, message (messaging send)

**Wake** / **held reply** (`push_wake.rs`, `[push]`):
A **wake** is one textless APNs `pushtotalk` push (`{"v":1,"kind":"reply"}`) to the token a phone registered with `wake_token`; iOS starts the app, which re-dials. A **held reply** is a reply's audio kept in its owner's replay ring for 30 s after the link drops; the wake goes once per held reply, and the redial asks for it with `resume_playback`. A token may name its build (`apns_environment`, `bundle_id`: `[push] bundle_id` or its `.dev` sibling), so one gateway wakes a development and a TestFlight phone alike.

**Phone room** (`phone_room.rs`): a paired phone that keeps a wake token is one more room speaker, `phone` (then `phone-2`, …), driver `phone`. A room speak to it (`speak { room }`, `pi_room_speak`, an announcement routed to a room) is rendered by `roomctl render`, held in the owner's replay ring as an **announcement turn** (`announce-<n>`), and woken with `{"v":1,"kind":"announce"}`; the phone's redial asks `resume_playback` with the alias `announce`.
_Avoid_: notification (a wake shows nothing and carries no words), push for the wake (a push is notify's transport line), VoIP push (CallKit's; PushToTalk is not one)

**Ambience** / **ambience play** (`roomctl ambience`, `pi_room_ambience`, `room_ambience.rs`):
A calming sound in one room for a while ("rain in the bedroom for forty minutes"). An **ambience play** is one sound synthesized by roomctl (rain, waves, brown-, pink- or white-noise) in one room for a set length, fading out at the end; a new play in a room replaces the old one. roomctl runs each play as a detached process whose stream is the timer, so a gateway restart loses nothing, and a play whose process died reads `lost`. The brain drives it with `pi_room_ambience`; the Admin's Room speakers section shows `roomctl ambience status`, read after each change and every 15 s.
_Avoid_: ambient (the ambient sidecar and caption listen to the room; ambience plays into it), music (`pi_home_act play_station`), sleep timer

**Webhook source** / **webhook intake** (`webhook_intake.rs`, `[webhooks]`, `<state>/webhooks/events.jsonl`):
A **webhook source** is a sender the operator allowed (a doorbell service, a build, a monitor), listed under `[webhooks] sources` with its path name, spoken label, the env variable holding its secret and the operator's words per event **kind** (ADR 0051). The **webhook intake** is the gateway's loopback listener `POST /hooks/<source>`, reachable from outside only through a Cloudflare tunnel route. It verifies the Standard Webhooks signature, refuses replays and stale timestamps, stores the event owner-only, and has the local decision model pick a **route** (`notify_urgent`, `notify`, `log_only`, `drop`, else the source's fallback). A payload is never spoken, and nothing listens until a source is listed.
_Avoid_: hook (the gateway's lifecycle hooks), alert (a camera line's word), the outbound webhook receiver of ADR 0011 (the brain's work intake)

**Overlay** / **fleet control server** / **link sample** / **link matrix** / **route connector** / **degraded** and **severed host** (ADR 0053, `deploy/fleet-control/`):
The **overlay** is the WireGuard network every fleet host joins: Tailscale's open-source client under a self-hosted Headscale. The **fleet control server** is one Compute Engine VM running Headscale with its DERP relay and STUN, the outside ntfy and the outside watcher, declared with Alchemy in `deploy/fleet-control/`. A **link sample** is one probe of one (from, to, path) with a closed error set; the **link matrix** folds them per pair. A host is **degraded** when its first path is down but another is up (or the overlay path is relayed), and **severed** when no path from the gateway host is up. The **route connector** (`fleetctl connect`, planned) is the one resolver every ssh in Vulpine dials through.
_Avoid_: tailnet (Tailscale's hosted product; ours is self-hosted), VPN, mesh for the overlay, VPS for anything but the fleet control server

**Reach** / **reach route** / **paired device** (ADR 0053's addendum):
**Reach** carries one Vulpine client session (a WebSocket, a `vulpine-glyphctl` call, Admin frames, an ACP session) from a client machine to the gateway across networks, through the machine's `vulpine-relay` and one helper on the gateway host, so clients dial loopback. A **reach route** is one way to open that pipe: `lan`, `iroh` (direct or through Vulpine's own iroh-relay), `headscale`, `wireguard`, `cloudflare`, `ssh` (the default) or a user's `command`; the route race picks among them. A **paired device** is a client machine whose iroh key the gateway accepts, paired by a one-use Admin invitation and revoked there. The **same-host path** (`[reach] same_host`, off) does the same over the helper's Unix socket for a client on the gateway's host, with its key in `reach-local/` and the path word `local`.
_Avoid_: overlay for reach (the overlay is the host IP layer), tunnel, VPN, mesh

**House Snapshot** (`house.v1`, `pi_house_now`):
One typed read of the house now, built from the room presence and the home bridge's state in memory: the operator's room, who is home, rooms with occupancy, lights and players, devices that are on, and recent camera events as labels and ages. Each source is `ok`, `stale` or `unknown`; the snapshot never carries a zone, a frame, an event id or an interior camera's event.
_Avoid_: house state (the home bridge's per-subject store), home recap (`pi_home_recap`, what changed over hours), world model

**Compatibility Directory** (`.vulpine/`):
The `.vulpine/` directory inside an Agent workspace that holds optional voice-session configuration and assets for the Voice Gateway. A workspace that holds only `.foxline/` is refused at bind; rename it: `mv .foxline .vulpine`.
_Avoid_: `.fox9`, `.voice-agents`, `.agents/voice`

**Pi Directory**:
The `.pi/` directory inside an Agent workspace that contains Pi-specific configuration for the Brain.
_Avoid_: `.agents` for Pi-specific config

**Catalog**:
The `catalog/` directory: selectable Agent workspaces (`catalog/agents/`), Persona packages (`catalog/personas/`), shared Pi configuration and extensions with the generated brain-tool catalog (`catalog/pi/`, `catalog/pi/tool-catalog.json`) and retrieval admission definitions (`catalog/retrieval/`). Each entry's manifest there is its single authority, and an entry installed outside Git is pinned by content digest. The Catalog itself runs nothing: entries resolve into the session's composition. A client that names the old `agents/<agent>` workspace, or a runtime root with the old `personas/` layout, binds read-only with one deprecation line.
_Avoid_: Loadout (a selected voice-session policy), Rig (a possible resolved composition), plugin directory, config dump

**Parked package** (`_parked/`):
A Catalog package taken out of service but kept in the tree, under `<kind root>/_parked/<name>/` (`catalog/personas/_parked/`) with a README naming why. `_parked` is reserved: the Catalog index skips it, no client names a workspace under it, and the gateway never resolves a persona from it. The Catalog carries one Agent, `operator`, and one Persona, `cunningham` (the Operator); the other personas are parked. To bring one back, move it up one level and run `just catalog::index`.
_Avoid_: archived, retired (both imply gone), deleted

**Catalog index**:
The derived, typed list of every Catalog package: its kind (`agent`, `persona`, `pi_extension`, `retrieval_sources`), id, declared version, root, entry points and content digest. It lives outside the Catalog at `tools/catalog/index.json`, written only by `just catalog::index` (`tools/catalog/catalog_index.py`). `just catalog::validate` checks it against the contract in `tools/catalog/README.md`, with a typed failure naming one package. The gateway reads it for the Admin's Catalog section (`GetCatalog`), which shows its `"migrated": true` when it reads `catalog/`. Being listed enables nothing.
_Avoid_: manifest (one package's own file), registry (implies enablement)

**Voice Mode Loadout**:
The agent-specific configuration used only for voice sessions, including allowed tools, extensions, skills, adapter choices, lifecycle policy, and voice interaction constraints.
_Avoid_: Agent config, codec config

**Interaction Mode**:
The Gateway-resolved, session-owned turn-admission policy, distinct from detector rollout, Persona, Voice Profile and
Speech Ownership. Built-in `radio` requires a wake for each microphone request, even with the detector Off; trusted
text is admitted. Gateway receipts report the installed policy and generation, and Client Core validates that
readback. Under `radio` a wake-less final is admitted only inside one of five gateway-opened windows (Follow-up,
Plain-speech answer, Home answer, Verb-confirm and Call); outside them it is dropped `not_armed`, whatever the
loadout's `dialogue_mode` (wake-free only off `radio`). The Call window keeps Vigil wake-free.
_Avoid_: detector mode, global conversation mode, theme

**Voice Profile**:
A named, Persona-owned TTS reference choice. Persona selects presentation identity; Voice Profile selects the exact voice reference within that Persona. The Voice Gateway resolves both, reports the effective voice and its provenance, and may lock selection when a deployment binds an exact override or uncatalogued fallback.
_Avoid_: speaker (ambiguous), theme voice, Agent voice

**Frontend Tool**:
A capability implemented by the connected frontend that the Brain can request through the Voice Gateway during a voice session.
_Avoid_: Browser tool, UI command

**Capability Tier**:
One of the three places a capability lives (ADR 0050): a Gateway Verb (closed, matched by the gateway at the commit, no Brain round), a Catalog Tool (a schema in the Brain's prefill) or a Skill (instructions over catalog tools, no code). A capability moves between tiers by usage and latency, on a suggestion to the operator, never automatically.
_Avoid_: core vs non-core (the catalog, not the core set, bounds what a Skill may use)

**Catalog Tool**:
A tool row in the tool catalog (`catalog/pi/tool-catalog.json`), whatever its provenance: core, first-party plugin or user extension. The catalog is the source of truth for what a Skill may call; a row carries provenance, capabilities, an approval class and its prefill cost.
_Avoid_: core brain tool (as the test of whether a Skill may use it)

**Skill**:
A named set of instructions (SKILL.md with `tools:` and `facts:`) that composes Catalog Tools for an exploratory task such as "which day is garbage day". It holds no code; a missing tool degrades it at bind, never crashes it.
_Avoid_: plugin, extension (those add tools; a Skill adds none)

**Setup Census**:
The Gateway's one read of what is and is not set up: a row per connector, grant and integration with its state (`ok`, `not_set_up`, `degraded`, `off`) and one plain-words next step, built from the Health rows and the effective config with no probe of its own, plus every shipped config switch that is off, with its doc comment. The Admin's Setup section and `brain_vulpine_report {topic: setup | features}` read it.
_Avoid_: connector census (it covers grants and models too), doctor (the doctor is the install's CLI check)

**Backchannel**:
What keeps the operator informed and in control while long work runs (ADR 0050): progress lines, conversation that continues during background work, and a steer channel and transcript feed from the main conversation to the work.
_Avoid_: status updates, keepalive

**Confirmation Capability**:
A frontend-advertised ability to render an exact Gateway challenge and return an explicit human decision. A confirmation is single-use and bound to its action, capability, pane, Gateway session, nonce, and expiry; it never transfers mutation execution to the frontend or Brain.
_Avoid_: Pi confirmation, model confirmation, frontend command

**Speech Ownership**:
Which side runs a speech stage for a session, negotiated in frontend capabilities at `hello`: gateway-owned (the default) or client-owned. Client-owned STT or TTS changes neither turn authority nor the Brain path; the gateway always owns the session (ADR 0003).
_Avoid_: Browser STT, WASM mode, client-mode (say client-owned STT/TTS or speech ownership)

**Voice Extension**:
A Pi extension loaded only for voice sessions by the Voice Gateway, either from bundled standard extensions or project-local `.vulpine/extensions/` paths.
_Avoid_: Default Pi extension, frontend plugin

**Extension contract** (ADR 0059):
A versioned, typed shape where an implementation the user supplies attaches to vulpine. Each has a doc under `docs/contracts/`, one owner, a registry, a built-in, a conformance sample and an Admin row: hardpoint.v1 and one `hardpoint.<slot>.v<N>` per slot, hooks.v1, tool.v1, skill.v1, connector.v1, panel-card.v1 and visual.v1. Each carries its own `major.minor`: a minor never breaks a conforming extension, and a major is a new file kept beside the old one for the deprecation window (two minor releases or 90 days, whichever is longer).
_Avoid_: plugin API (one universal API is what it is not), SDK

**Extension**:
An implementation of one Extension contract, loaded by that contract's one owner: a TTS hardpoint implementation, a script Observe consumer, a Pi extension, a skill. Always qualified by its contract; a thing that implements no extension contract is not an extension, however it is installed. User extensions run out of process, with declared capabilities that never widen what the loadout admits.
_Avoid_: plugin (unqualified), add-on

**Hardpoint** (ADR 0024's term; the registry is ADR 0059's):
A closed, owner-defined runtime slot where exactly one dependency is mounted per scope: `stt`, `tts`, `wake`, `decision`, `brain`, `voice`, `avatar`, `render`, `room`, `memory`, `retrieval`. An implementation is a `hardpoint` Catalog entry bound under the loadout's `[hardpoints]`, and the owner qualifies it with the slot's probe before it claims ready. On a failure the owner binds the built-in fallback and reports degraded. A Hook cannot fill a missing Hardpoint.
_Avoid_: adapter (the out-of-process tier of ADR 0034, which an implementation may use), provider, backend

**Hook** (ADR 0024's term; the user door is ADR 0059's):
A named lifecycle boundary (`session.end.after`) owned and invoked by the one subsystem that commits the transition. Its class is Observe: it runs after the commit and cannot delay or alter it. The owner hands the typed event to a consumer: the built-in `admin_receipt`, a user's script or a webhook. Every attempt leaves a receipt. Gate (before the commit, narrowing only) and Mutate (an owned effect with a settlement receipt) are reserved classes, not built.
_Avoid_: webhook (the inbound intake of ADR 0051), callback, event listener, frame processor

**Conformance suite** (ADR 0059):
One sample extension per Extension contract, written the way a user would write it and run against the gateway's real bind and dispatch paths. It checks that a minor never breaks a conforming extension.
_Avoid_: contract tests (those pin vulpine's own side), ADR 0024's V0-V4 conformance (the program's acceptance evidence)

**Brain**:
The Pi RPC agent process that owns agent reasoning, tool use, skills, extensions, prompt behavior, and model-provider access for an agent session.
_Avoid_: LLM server, assistant logic

**Held Brain Turn**:
A Brain turn whose close waits while Pi recovers it (an auto-retry, or an overflow compaction that retries). It is traced `brain_turn_held {reason}`; if it outlives `[brain] retry_hold_ms` the Gateway closes it with `brain_turn_closed {reason: retry_hold_expired}` and the provider line.
_Avoid_: retry turn, stalled turn

**Start-Over Abort**:
What a spoken "start over" does to a Brain turn that is still running: the Gateway aborts it on the session loop's next pass (Pi's `abort`, `brain_turn_closed {reason: start_over}`), drops its answer unspoken with no `brain_done`, and restarts the Brain at once (`brain_restarted {after: aborted}`). A Held Brain Turn is aborted the same way. The one wait is a tool call in flight: the restart is deferred (`brain_restart_deferred {reason: tool_in_flight}`) until the tool's result, then the generation is aborted (`after: tool_end`), bounded by the turn's deadline.
_Avoid_: start-over wait, deferred restart (for the whole turn)

**Brain Continuity ID**:
A server-owned opaque identifier for the exact persistent Pi conversation bound to an Agent, workspace, loadout, model, Persona context, tool policy and Pi launch, distinct from the transport session UUID. A WebSocket reconnect or a Pi restart under the same Gateway process keeps it; a radio hang-up rotates it. A Gateway restart can recover Pi conversation continuity.
_Avoid_: client session ID, WebSocket session, conversation name

**Client Owner** (ADR 0024 admission contract):
A Gateway-minted durable identity that separates one Client Core instance's Brain conversations from other clients with
the same composition. A reconnect bearer credential authorizes resumption (`Hello.client` is only a display label), and
each admitted reconnect renews the attachment generation, wake destination, mutation authority and speculative gate;
an attachment of unknown lifetime after a Gateway restart is quarantined. The browser Client Core keeps the credential
in a per-instance sessionStorage slot, which survives a reconnect and a same-tab reload but not an app restart.
_Avoid_: client label, browser origin, composition identity, shared conversation

**Background Brain Work Receipt**:
The Gateway's lifecycle record for one voice-requested objective owned by an exact Brain Continuity ID: a
`fox9-work-…` ID, a state (`accepted`, `running`, `completed`, `cancelled`, `failed`) and one terminal Client Core
event, delivered within five minutes. Each attempt runs in its own ephemeral Pi process on the selected model with
`--no-tools`, `--no-extensions`, `--no-skills`, no context files, no approval and no persistent session. A loadout's
`tools.background_toolset` may grant a read-only tier (`herdr-readonly`, the Herdr status reads with file and web
reads, or `research-readonly`, those plus Vulpine's docs and code search), and `brain.background_command` runs a
compact-shaped objective on an on-device provider. A foreground voice turn preempts and requeues the work. The ledger
is durable (`background-work.redb`): after a Gateway restart accepted work stays queued and running work fails as
`background_work_gateway_restarted`. The receipt holds no transcript and grants no session, shell, MCP, approval or
client-ID authority.
_Avoid_: client job ID, detached Pi session, background voice runtime, transcript

**Progress line** (ADR 0050 §9.A):
One short templated line about long work that the Gateway speaks on its own: a foreground cue when a brain turn's tool
has run quietly for 10 s (then at most one per 20 s, three per turn), or a background job's elapsed-time line at 2 and
10 minutes through the announcement governor as the `progress` source. It is under ten words, with no id, digit, path
or tool wire name. "How's it going" is the `progress` verb, answered from the same ledger with no brain turn.
`[announcements] progress = false` turns all three off.
_Avoid_: filler, status ping, heartbeat

**Herdr Machine**:
A fleet host herdr reaches, declared in a host row's `herdr` block of the fleet manifest and reconciled by `fleetctl herdr-machines plan|apply`, never added by hand. Its `allow` list names the voice verbs that may reach it; close and kill never do. Under herdr-core (`hc`, the default `[herdr] backend`; ADR 0055) it is an **hc machine**: saved with hc's `machine.add` on the gateway host, reached by terminal address (`<machine>/t1`), with no enabled flag (`enabled: false` plans a remove) and a name of 1-32 characters of `a-z0-9-_.`. Under herdr 0.9 (`backend = "herdr09"`, the rollback) it is a saved SSH machine (label, ssh target, remote session, enabled flag).
_Avoid_: remote host (say herdr machine when herdr is the reach), herdr hosts list (`VULPINE_HERDR_HOSTS`)

**Machine Carrier**:
How the gateway's herdr client reaches one herdr machine under herdr 0.9: `local` (its own Unix socket) or `machine` (`herdr --machine <label> <api command>`, herdr's own transport). Under herdr-core (the default; ADR 0055) there is no carrier: every call goes to the local hc socket and names the machine in its terminal address.
_Avoid_: tunnel, remote socket

**Herdr Gate**:
The forced command on the gateway's dedicated herdr key at each herdr machine. Under herdr-core (the default) it is an hc gate that runs only that host's pinned `hc connect` for the manifest's session; `machine.exec` rides that connection, and the gateway's own fixed argv keeps exec to the approve program. Under herdr 0.9 it runs only that host's herdr binary with the subcommands herdr's machine transport uses, and refuses `update`, `server stop`, any install and any other argv.
_Avoid_: herdr key (the key is the credential, the gate is what it may run)

**Terminal Address**:
What names one herdr-core (`hc`) terminal: `t7` on the gateway's own core, `<machine>/t7` on an hc machine. It is the value of every `pane` / `pane_id` protocol field, keys the owned-pane ledger and binds the approval id (`<address>:sha256:<prompt>`). A terminal is never reused; workspace and tab are labels.
_Avoid_: pane id (a herdr 0.9 word; say terminal address under hc), terminal id (herdr 0.9's internal id)


**Herdr.app**:
The window over herdr-core (`herdr-app`): spaces, tabs, panes and JS mods, kept per machine in the core's `herdr-app` document. It shows any terminal labeled `herdr.space` / `herdr.tab`, so gateway-started agents are visible to the operator. Vulpine never edits its document; it calls `herdr-app do` only to move the focus.
_Avoid_: herdr (the 0.9 multiplexer), the core (hc itself, headless)

**Caller Tier**:
How much a voice command may do on one fleet host, named from its herdr `allow` list: View reads; Control also types into its agents (prompt, approve) and moves the focus; Operate also starts agents there. A herdr block may name `tier` in place of `allow`; a host's tier is the tier of the strongest verb it grants. The brain's herdr tools check it before any remote read or send (`machine_not_allowed`), and the Admin's Herdr hosts card shows it.
_Avoid_: permission level, access level (those are the artifact database's words)

**Presence Token**:
The herdr pane metadata token `vulpine_hold_<holder>` (brain, courier) a Vulpine sender puts on a pane while it types into it, with a 30 s ttl so a dead holder lets go by itself. Another holder's token refuses a send (`pane_held`); the room courier steps aside from such a pane until its next idle observation.
_Avoid_: lock (nothing blocks herdr or the operator; it is a courtesy every Vulpine sender reads)

**Herdr Owned Pane**:
A Gateway-minted opaque `ownership_id` for one pane created by `brain_herdr_create_agent_pane`. The durable BrainPool
ledger (`herdr-owned-panes.redb`, owner-only, written before each effect) binds it to one Brain continuity and the
exact workspace, tab, pane, terminal and cwd; only that record can authorize an agent start or a rollback close. After
a Gateway restart a record authorizes nothing until one `pane.get` proves the live pane exact; a mismatched or
mid-effect record is quarantined.
_Avoid_: caller-selected start pane, WebSocket-owned pane, generic close handle

**Herdr Agent Start Receipt**:
The Gateway's synchronous result for one `brain_herdr_start_agent` call. It binds the Brain continuity and live Pi tool
call to a server-owned `ownership_id`, a bounded name and a closed agent kind, takes the workspace and pane only from
the BrainPool ledger, and reports the exact workspace, tab, pane, terminal, agent, name and kind. It holds no close
target, command, argv, cwd, environment, model, timeout, transcript or pane output.
_Avoid_: shell launch, generic agent spawn, caller-selected Herdr start

**Herdr Owned Cancellation Receipt**:
The Gateway's synchronous result for `brain_herdr_cancel_owned_agent`. The request carries only a server-minted
`ownership_id`; the Gateway checks it against the live tool call, the Brain continuity and the owned-pane ledger,
verifies the exact started pane and agent, and closes only that pane. `cancelled` needs a native `{ type: "ok" }` or an
exact `pane_not_found`; an ambiguous transport quarantines the ownership. It never carries a caller-chosen close
target, key sequence, process name, transcript or pane output.
_Avoid_: arbitrary pane close, Ctrl-C cancellation, process kill, global sweep

**Herdr Close Receipt**:
The Gateway's answer to one confirmed `brain_herdr_close` of a named pane or workspace the Gateway does not own. The
ask returns a read-back and a single-use code bound to an exact inventory digest (what closes, which terminals, what
survives); the operator's exact words (`close <name>`), heard by the Gateway, approve it. The redeem re-reads the
session, saves each closing pane's recent output to the private store, closes, and reports `closed` only when the
target is gone and every survivor is present. Any doubt is a HOLD with a closed reason, and nothing closes.
_Avoid_: kill pane, bulk close, model-confirmed close, owned-agent cancel

**Herdr Lifecycle Receipt**:
Bounded Gateway evidence for one exact monitored Herdr target and pane: status, Brain continuity ID, observer generation, observation time, freshness, and terminal state. It excludes pane output and transcript text. Blocked/done receipts may trigger fixed Gateway speech; they are not Brain self-reports.
_Avoid_: agent transcript, model completion claim, generic Herdr event

**Herdr Work Graph**:
The read-only Gateway projection `brain_herdr_work_graph` returns for the calling Brain continuity alone: capped work,
ownership, started-agent and pane nodes from the owned-pane ledger, their current lifecycle generation and freshness,
and deduplicated blocked/done attention, in a deterministic bounded order. Each publication gives the current attention
records short spoken handles (`blocked-1`, `finished-1`) that the next read retires. Blocked and done are lifecycle
attention, never verified task success. It holds no transcript, pane output, cwd or path contents, generic Herdr
events, stale generations, other continuities' records or inferred dependency.
_Avoid_: Herdr snapshot, global task graph, transcript graph, scheduler view

**Herdr Spoken Handle**:
A short label minted inside one Herdr Work Graph publication, such as "first blocked agent": display and speech
metadata for the current continuity and generation, not a pane ID or mutation credential. It is never reused after
another graph read, a session change or a reconnect.
_Avoid_: durable agent alias, fuzzy session selector, mutation handle

**Herdr Agent Message Native HOLD**:
The Gateway's refusal to type into an agent itself: it exposes no `brain_herdr_prompt_agent` and accepts no
agent-message operation, because herdr has no atomic compare-and-prompt that checks the agent's identity at the
commit. The brain's extension-side `pi_herdr_prompt` is outside this boundary: it sends one operator-dictated message
through the Herdr CLI, re-reads the pane with `agent get` just before the send, and accepts only an ack naming the same
terminal.
_Avoid_: inferred pane identity, post-write validation, accepted message receipt, generic agent bus

**Herdr Semantic Wait**:
A Gateway-owned asynchronous wait, asked with `brain_herdr_wait`, on one monitored Herdr target, pane, Brain
continuity and observer generation. Pi gets an immediate admission; the Gateway later publishes one typed terminal
event when a closed set of agent statuses or one bounded literal pane marker matches. It settles once, as matched,
timed out, canceled, unavailable or stale generation, and never forwards pane excerpts or grants generic Herdr or shell
authority.
_Avoid_: generic event wait, regex wait, client-owned wait, pane transcript

**Stability label**:
One of four words every external surface carries in the API catalog (`docs/contracts/api-surfaces.toml`, rendered as `docs/reference/api-surfaces.md`): `public` (a third party may build on it; a breaking change is a new contract file, ALPN version or protocol number), `owner` (the operator's own tools and machines; may change in any release), `internal` (plumbing between vulpine's own parts) and `experimental` (draft or off by default). Public in v1 are the frontend Protocol 5, decision.v1, the Extension contracts, the hardpoint worker wires, the agent connector and the reach ALPNs `vulpine/pair/1`, `vulpine/ws/1` and `vulpine/voice/1`. The Admin protocol is owner-only and the relay frames are internal.
_Avoid_: stable / unstable, supported (say which label)

**Protocol**:
The authoritative frame schema for the Voice Gateway WebSocket: control messages, server events, capability negotiation, audio frame format and session lifecycle. It is defined once in Rust (`crates/protocol`), consumed natively by Rust frontends and generated as TypeScript for TS frontends; nothing hand-mirrors it.
_Avoid_: API, wire format, message types

**Client Core**:
The per-platform module that connects a Frontend Skin to a Voice Gateway: WebSocket lifecycle and reconnect, microphone capture, PCM playback scheduling, capability negotiation and Persona/Agent session state. There is one per runtime platform, sharing the Protocol, not code: the TypeScript one (`packages/voice-client`, AudioContext) serves Vigil and browsers, and the Rust one (`crates/phone_core`, platform audio behind a trait) serves Vulpine on iPhone (in development) and, surface by surface, the Glyph (ADR 0074).
_Avoid_: client library, SDK (say Client Core), frontend logic

**Route race**:
How a Client Core reaches one gateway several ways at once (`packages/voice-client`). A frontend with `routes` (Glyph: `[vulpine] routes`, such as the LAN address and the loopback relay hop) opens them all and keeps the first whose gateway `hello` arrives. The win is a `route_won {url_kind: loopback|lan|remote, route_index, routes, ms, losers}` diagnostic; a total loss is `route_race_failed`, then the ordinary reconnect. The configured `url` stays the owner identity, and with no `routes` it is dialed alone. When the shell knows a url's reach route (`routeReach`), `route_won` and the hello carry `reach {route, via, rtt_ms, from}` (closed words and a fleet label, never an address), shown in the Admin's Live sessions row as "reach: the laptop, iroh direct, 41 ms".
_Avoid_: failover (the race is simultaneous, not one route after another), multi-gateway (every route reaches the SAME gateway)

**Frontend Skin**:
The presentation and shell of a voice frontend: visuals, interaction model and OS integration. Vigil is a fullscreen or second-screen web skin; Glyph is an unobtrusive, Siri-shaped overlay skin, a Tauri webview moving to GPUI surface by surface behind Labs (ADR 0074). A Frontend Skin imports a Client Core and owns only presentation and shell, never gateway protocol or audio-pipeline logic. A new skin is a new `apps/` member that imports a Client Core (`@voidfab/vulpine-voice-client`, or `crates/phone_core` for a GPUI skin); there is no runtime skin loading.
_Avoid_: app, UI, frontend (say Frontend Skin when distinguishing presentation from the Client Core)

**Sidecar window**:
A native window drawn by another process that a Frontend Skin owns: it starts with the skin's session, follows it, and
exits when the skin closes its stdin. The Glyph's is the conversation window (`convo-gpui`, drawn in GPUI). It is one
more protocol client, never a second skin.
_Avoid_: helper app, second app, plugin window

**Sidecar envelope**:
The bounded tree a sidecar window draws (`docs/contracts/sidecar-envelope.v1.md`, draft): closed-vocabulary nodes with
stable ids and stable accessibility labels, one snapshot then patches carrying a generation and a base revision, hard
limits (1 MiB, 4,096 nodes, depth 64), and a resync on a gap. Checked by `crates/sidecar_envelope`.
_Avoid_: view protocol, UI wire (it is not the gateway's wire)

**Admin** (the Gateway window):
The native local operator surface for schema-governed configuration, desired, effective and live runtime identity,
health and topology, bounded telemetry, structured errors, media routes, runtime inventories and operator jobs
(ADR 0016). It reads typed Gateway and deployment projections but owns no voice session, Brain path, transport,
provider credentials, arbitrary filesystem or process authority, or production activation. Vigil's and Glyph's
Operations panels are compact per-session views, not other control planes. It ships inside the host app, Vulpine
Gateway.app.
_Avoid_: Admin Frontend Skin, Gateway dashboard, Glyph settings, second control plane

**Vulpine.app / Vulpine Gateway.app**:
The two Mac apps a user installs. Apps are named brand plus role. **Vulpine.app** is the client (bundle id
`com.voidfab.vulpine`, executable `vulpine`, cask `vulpine`); the Glyph Frontend Skin runs in it.
**Vulpine Gateway.app** is the host (bundle id `com.voidfab.vulpine.gateway`, executable `vulpine-gateway`, cask
`vulpine-gateway`); it holds the gateway and draws the Admin in GPUI (the app is `apps/admin-shadow`, its
identity in `apps/admin-shadow/bundle.json`). Its helpers take `com.voidfab.vulpine.gateway.<helper>` (`.agent` for
the SMAppService LaunchAgent, `.grants` for the TCC helper). A display name may carry a space; an executable, a
scripted name or a cask never does. **Glyph** and **Vigil** are **looks**: names inside settings for how the client
draws, never app names. `docs/naming.md` has the table.
_Avoid_: Glyph.app, Vulpine Admin.app, "the Glyph app"

**vulpine-glyphctl**:
The client's command line: it drives the running Vulpine.app over its owner-only control socket. It ships inside the
bundle (`Vulpine.app/Contents/MacOS/vulpine-glyphctl`), and Diagnostics → Command line puts a shim for it on the PATH.
The alias `glyphctl` still works; started by that name it prints one deprecation line on stderr, with the same stdout.
Wire values that spell the alias stay (`VULPINE_TOOL_ORIGIN=glyphctl`, the `glyphctl-<n>` request ids).

**vulpine-<noun> helper**:
A runtime helper the gateway, a launchd job or a roll spawns, named for what it belongs to (ADR 0063): `vulpine-brain`
(`brainctl`), `vulpine-herdr` (`herdrctl`), `vulpine-fleet` (`fleetctl`), `vulpine-provider` (`providerctl`),
`vulpine-room` (`roomctl`), `vulpine-home` (`homectl`), `vulpine-vision` (`visionctl`), `vulpine-audio` (`audioctl`, the output-device adapter),
`vulpine-call` (`callctl`), `vulpine-speech` (`speechctl`), `vulpine-record` (`recordctl`, the Glyph's capture
recorder) and `vulpine-screen` (`screenctl`; the screen agent itself is `fox9grants screen` inside
VulpineGrants.app). The old name in parentheses still works as an alias and prints one deprecation line on stderr;
the **renamed-helper table** (`runtime-tools.toml` `[[renamed]]`) is the list, and a helper's
`just install-vulpine-<noun>` recipe, where it has one, installs both names. Config keys, env variables and wire values that spell an old name stay (`[fleet] fleetctl`,
`[room_speakers] roomctl`, `[audio_output] audioctl`, `[calls] callctl`, `VULPINE_BRAINCTL`, the `fleetctl/1` hello).
_Avoid_: brainctl, herdrctl, fleetctl, providerctl, roomctl, homectl, visionctl, wechatctl, audioctl, callctl, speechctl, recordctl (outside the aliases and the records)

**Shadow Admin**:
The folder and crate name (`apps/admin-shadow`) of the **GPUI Admin**: the Admin drawn in GPUI (ADR 0060) and
installed as Vulpine Gateway.app, the one Admin control plane.
_Avoid_: Shadow Admin for the installed app (say the GPUI Admin, or Vulpine Gateway), Tauri Admin or TS Admin (both are gone), Admin pop-out

**ScreenContext presence feed**:
The operator's front app on the frontend's machine as typed brain input: its bundle id, a coarse category (`editor`,
`browser`, `terminal`, `chat`, `media`, `other`) and the seconds since the last input. The Glyph sends it as
`screen_context_report` on change (at most 1 Hz) while Operations > Session > Brain > "Share the front app with the
brain" is on (the default); the gateway attaches it to each brain turn as `screen_context`. It is never a window
title, text or pixels, and is separate from the on-demand OCR and Accessibility reads.
_Avoid_: screen sharing, activity tracking, screen context (alone: that names the OCR read too)

**Room presence**:
Which room the operator is in, coarse and bounded (`Presence.room`): one gateway-wide room with its source and age,
from observations ranked explicit > frontend turn > ble > occupancy > media (`away` clears it). `ble` is a frontend's
Bluetooth LE scanner (the puck's bridge) hearing the operator's own phone or watch (`presence_observation`); the bridge
resolves the devices by IRK, so only the room crosses. It routes announcements and replies to a room speaker; it is
never a track, and no location leaves the LAN.
_Avoid_: location, tracking, occupancy (that is one source, a home sensor's)

**Media route**:
One of a frontend's audio paths (its `microphone`, its `speaker`) as the Admin sees it: a generation (the frontend's
acquisition count; a device change, reset or reacquire starts the next) and that generation's state (`probing`,
`denied`, `unavailable`, `stale`, `replacing`, `active`, `degraded`, `stopping`, `settled`). The frontend reports it
as `media_route_report`, kept per route on its session's Admin row. It is a projection of the Client Core, the only
capture and playback owner, and never names a device id or label.
_Avoid_: device state, mic status (both lose the generation)

**Invocation Alias**:
The spoken wake "Fox Nine", canonicalized to `fox9`. Shadow Detected is evidence only. It is not Brain STT and does not by itself commit a turn.
_Avoid_: wake word as a second detector, hotword engine

**Invocation Endpoint Evidence**:
Session-bound diagnostic evidence emitted beside the authoritative EOU, EOB or finalize boundary: the endpoint kind,
the encoder frame, the event time and an absent confidence (the C API exposes no calibrated pre-commit score). It
cannot commit a turn, interrupt playback, dispatch Brain work or replace the endpoint and reset lifecycle.
_Avoid_: endpoint decision, confidence score, turn boundary


**Barge-in**:
Cancel current assistant playback. Product target: only the Invocation Alias, so radio/music/other voices do not stop TTS. Silero VAD may still endpoint ordinary turns when the assistant is not speaking.
_Avoid_: any-speech cancel as the product

**Armed request**:
After Detected, the following authoritative STT final is the user request. Ambient speech before Detected is not a Brain turn. An armed dump longer than 240 characters (`MAX_ARMED_REQUEST_CHARS` in `turn.rs`) does not consume the arm. After Detected, `niner over` closes the request span.
_Avoid_: Detected-as-prompt

**Invocation command**:
A closed phrase after the alias (`over and out`, `roger`/`copy`, `sitrep`, and the other gateway verbs listed in [voice commands](/docs/install-and-operate/voice-commands)). Gateway-owned, not free-form NL. Hang-up is `over and out`. `niner over` is a request closer, not a command.
_Avoid_: Brain-parsed voice macros

**Visual Theme (legacy term)**:
The old name for a Glyph **Avatar** (ADR 0036), kept by the persisted id and the `glyphctl` wording. In new work say Avatar for what renders presence and Theme for the color, type and material data.
_Avoid_: skin (say Avatar for the in-skin presence renderer; Frontend Skin for the app)

**Shell**:
The OS-integration layer of a Frontend Skin: window policy (fullscreen or always-on overlay), global shortcuts, tray, and platform audio or accessibility hooks. Glyph's Shell is a Tauri app (overlay and tray) whose windows are moving to one GPUI process (ADR 0074); Vigil's is the browser. A Shell reaches the Client Core only through its interface and never touches the Protocol.
_Avoid_: native layer, platform code (say Shell)

**Frontier agent**:
A consumer agent with its own cloud computer and memory (Claude, ChatGPT and its dots, a Grok Bot, or a user's own MCP client) linked to vulpine as a fleet member, never as the brain (ADR 0057). It is declared in `agents.json` under a subject `agent/<name>` with a spoken label and scopes; vendor names live only there and in its helper.
_Avoid_: brain (a frontier model as the brain is a Pi provider setting), adapter (say frontier agent for the member, driver for how work reaches it)

**Vulpine connector**:
The one remote MCP endpoint every frontier agent calls (`runtime/agent_link`, `vulpine-agent-link`; ADR 0057 §2): Streamable HTTP on loopback behind one tunnel path, OAuth 2.1 with the operator's link code, seven closed tools. Its effects reach the house only through the gateway's agent door; whatever an agent says is spoken as "From <label>: …".
_Avoid_: agent API, bot endpoint

**Handoff**:
Work the operator hands a frontier agent ("tell Claude to …"): a typed `agentctl handoff` receipt delivered by a driver (`inbox`, `webhook`, `email`, `managed_session`; ADR 0057 §3). The agent pulls an inbox handoff through the connector and returns a result.
_Avoid_: dispatch (that is herdr's pane work), task (say handoff for this direction)

## Presentation glossary (current)

These terms follow the ADR 0036 and ADR 0037 presentation seams.



**Chassis**:
The body of a Glyph overlay (ADR 0036): window placement, layout grammar and its own clickable objects. A Chassis receives named slots (face, caption, toast, panel) and places them; it never reads the Protocol. `classic` is the disc-and-capsule; Island, Halo, Familiar, Ribbon and Printer are the others. One Chassis per Glyph at a time, switched live (`vulpine-glyphctl chassis`, Operations → Body); the native shell places the window for it (floating, top-center, bottom edge or the whole display).
_Avoid_: skin, frame, layout (say Chassis)

**Avatar**:
The swappable presence renderer in a Chassis's face slot (ADR 0036), fed one `GlyphPresence` projection: phase, levels, mood, reduced motion. Orb, Cast, Scanner and Phonogram are Avatars; an Avatar may have variants (orb experiments, cast engines, Iris, Sigil, Scanner, Line) and declares its own hit selector. An Avatar renders the active Persona; it does not own it. Avatar Actions address it.
_Avoid_: Visual Theme in new work, orb (Orb is one Avatar)

**Face Layer**:
The wrapper around every Avatar in a face slot (ADR 0036). It adds the face's opacity (20–100 %) and the Ring light without changing the face's size.
_Avoid_: glow, face overlay, avatar frame

**Ring light**:
The lit rim drawn around every face in the mood color: a circle for Cast and Phonogram, a rounded square for the Scanner. The Orb keeps its own ring. The rim's brightness shows the phase, a soft light spreads around it, an arc fills while the operator speaks and a comet runs the rim while Vulpine thinks. It is on by default and switched from Operations → Look.
_Avoid_: glow, inner glow, halo (Halo is a Chassis)

**Face choices**:
The operator's face picks (ADR 0036): a variant for each Avatar, a pinned mood, the opacity and the Ring light. The defaults are Iris, Seal, Scanner, Line, mood auto, 100 % and ring on. They are kept in Glyph's native state dir beside the Chassis choice, and read and set by `vulpine-glyphctl face`, `vulpine-glyphctl look` and Operations → Look.
_Avoid_: face settings, theme prefs

**Orb style**:
One style of the orb-styles registry (`apps/orb-styles`: the Classic disc and orbkit's fourteen MIT orbs, each with a plain name such as Phosphor or Dither) in which the Glyph's native orb draws its idle, listening, thinking and speaking states. One choice per Glyph, `classic` by default, kept as `orb-style.txt` beside the Chassis choice and set by `vulpine-glyphctl orb-style`, the GPUI Admin's Glyph section or the gateway's `orb_style` verb. It applies to the Orb Avatar's Classic disc variant; a Glyph Theme paints the rest.
_Avoid_: orb theme, orb skin, orb look (a look is a post pass over a frame)

**Labs**:
The Glyph's one switch for its experiments, `[glyph] labs`, off by default. On, the Glyph shows the "Labs & diagnostics" settings group, the Labs-only Orb styles (Bricks, Voxel) and the conversation window's experiments (it starts with `--labs`). Each experiment keeps its own switch inside Labs. Switched live by Operations → App → Labs or `vulpine-glyphctl labs on|off`; the GPUI Admin shows it read only.
_Avoid_: debug mode, feature flags (one switch, not a flag per element), beta

**Mood pinning**:
The operator fixing the mood color of every face. A pinned mood overrides the mood the gateway sends; Auto follows Vulpine's own mood.
_Avoid_: mood override, persona mood (the Persona's mood comes from the gateway)

**Glyph Theme**:
Color, type, material and sound-cue data that paints a Chassis and its Avatar (ADR 0036). It is data only, so it may load at runtime; its form is the base16 `ThemeManager` palette.
_Avoid_: Visual Theme (that is the old word for Avatar)

**Vigil Frame**:
The layout of one Vigil screen (ADR 0037): where the two Portraits sit, the frequency and soft keys, how the conversation reads, and where plugins ring. Vigil's counterpart to a Chassis. Eros, Minimal and eight legacy frames (Classic, Restored, Sons of Liberty, Transceiver, Briefing, Porcelain, Lacquer and Night glass) are registered (`apps/vigil/src/frame/registry.tsx`); `auto` starts Eros on every device.
_Avoid_: skin, chassis (say Chassis for Glyph)

**Portrait**:
A persona's portrait art (base, two mouth frames, blink) as a Vigil Frame draws it, lit by the ADR 0032 phase and filled with static while tuning or on error (ADR 0037). The operator Portrait is labeled You.
_Avoid_: avatar (say Avatar for Glyph's presence renderer)

**Glyph Plugin**:
A bundled module that reduces client events into state and renders into Chassis slots at three densities: glance, peek, panel (ADR 0036). Herdr attention and background receipts are plugins. Plugins register at build time; nothing loads code at runtime. The contract and reducers live in `@voidfab/vulpine-voice-client/presentation` and serve Vigil Frames too (ADR 0037).
_Avoid_: extension, widget, skin plugin

## Decision model, brain lanes, speech and the install (current)

The terms for the decision model, the brain lanes, speech and the install are on [their own page](/docs/the-voice-path/runtime-glossary).

