Where Things Live

Where Things Live

Flat lookup table for “I need to add/find X — where does it go?”. Optimized for LLM tool-call efficiency: skim by left column, jump to the right column.

If your concept doesn’t appear here, add the row in the same PR — that keeps the table accurate and prevents the next assistant from having to guess. The full crate roster with layer assignments lives in layers.toml.

For directory sprawl, sparse folders, and non-Rust artifact provenance, see Repository layout sprawl audit (2026).

Repository roots (navigation)

Grouped map of top-level trees — use this before inventing a new parallel folder (for example another docker/ or tools/).

Group	Paths	Notes
Rust workspace	Cargo.toml, crates/	Implementation + vox-arch-check / layers.toml. vox-arch-check does not recurse into target/, .git/, node_modules/, etc. when scanning (see [arch_check.walk_prune]). Reclaim disk from stale artifacts: cargo clean or scripts/clean-build-artifacts.vox (syntax-checked in CI via cargo run -p vox-cli -- check scripts/clean-build-artifacts.vox). For crates under workspace.exclude in root Cargo.toml, set CARGO_TARGET_DIR to the repo target/ when running cargo --manifest-path … so Cargo does not grow a second crates/.../target/.
Contracts	contracts/, contracts/index.yaml	SSOT bundles; path changes require index + consumer updates.
Unified policy catalog	contracts/policy/policy-registry.v1.yaml	SSOT for the cross-domain policy registry. Model + loader live in vox-config (policy::registry); the generator, drift gate (vox ci policy-registry-parity), and vox policy CLI live in vox-cli (commands/ci/policy_registry.rs, commands/policy/, feature-gated behind completion-toestub).
Per-branch policy run status (overlay)	.vox/policy-status/<branch>.json store (gitignored)	Model + reader in vox-config (policy::status: PolicyRunReport, load_status, load_status_for_branches); writer + capture seams in vox-cli (commands/policy/status_writer.rs, per-gate dispatch wrapper in commands/ci/run_body.rs, code-audit emit in commands/diagnostics/stub_check/); --json per-rule emitter in vox-arch-check (json_report.rs). Read via vox policy status [--branch b]…; unrun rules show unknown (honest grey).
Vox Graph corpus registry + freshness	contracts/retrieval/vox-graph-corpora.v1.yaml	Loader + assess_corpus_status in vox-config; read-only CLI vox search graph status in vox-cli (commands/graphify/, deprecation alias). Tier D cache target: .vox/cache/vox-graph/<corpus_id>/. Legacy graphs may still live under graphify-out/ (see graphify-integration-research-2026-06-16.md).
Docs (source)	docs/src/ under repo docs/	Narrative SSOT; .md doctests.
Docs (site)	docs-astro/	Astro build; sidebar from frontmatter.
Apps & editors	apps/	GUI surfaces — registry in contracts/frontend/surface-ownership.v1.yaml.
Examples / fixtures	examples/, tests/fixtures/	Non-production sandboxes and bundles. Goldens under examples/golden/ include clean_build_stdlib_reference.vox (pointer to scripts/clean-build-artifacts.vox).
Automation	scripts/*.vox	Prefer vox run over new shell/Python glue.
CI / hooks	.github/workflows/, lefthook.yml	Runner wiring; see CI docs under docs/src/ci/.
Deploy / compose	infra/, docker/, root docker-compose.yml	Overlap is intentional (different compose working dirs); eval SSOT called out in deploy docs.
Build-time Node helper	apps/build-tools/render-durable-animation/	Invoked from scripts/render-durable-animation.vox.

Quick reference: subsystem → crate (by layer)

L0 — pure types

Crate	One-line scope
vox-arch-check	CI guard binary; enforces layers.toml. Walk-based rules skip artifact trees (built-in + optional [arch_check.walk_prune]); Rule 8 staleness uses one batched git log when available.
vox-ast	Pure-data Vox AST (decl/expr/stmt/pattern/types/scalar_mapping/span); serde-only L0 leaf extracted from vox-compiler and re-exported there as vox_compiler::ast. Depend on this (not vox-compiler) if you only need the declaration AST — e.g. vox-db’s DDL emitter.
vox-build-meta	Build-time helper emitting VOX_BUILD_NUMBER / VOX_GIT_HASH; use as [build-dependencies] only.
vox-db-types	Pure-data L0 leaf for vox-db: row types, IDs, schema descriptors.
vox-kb-facets	L0 KB facet contract: Facets, effective_training_eligible, summary block, provenance validators, taxonomy loader and facet backlog (KB Phase 4).
vox-llm-config	SSOT for LLM/AI setting-key metadata; pure-data, zero workspace deps.
vox-mesh-types	Pure-data mesh transport types.
vox-orchestrator-types	Pure-data L0 leaf for vox-orchestrator: agent/task IDs, file affinity, switch actions, provider catalogs, VCS capability tokens (WorkingTreeWrite, BranchCreate, etc.).
workspace-hack	Cargo-hakari unification crate; do not edit by hand.

L1 — primitives & utilities

Crate	One-line scope
vox-foundation	Utility umbrella: cheap trace ids, exponential backoff, AgentOS mutation kinds (was vox-primitives), daemon wire-protocol types (was vox-protocol), tracing_subscriber bootstrap presets (was vox-tracing-init). Excluded from workspace-hack for fast-leaf compile.
vox-bounded-fs	UTF-8 file reads capped by vox-scaling-policy max_file_bytes_hint.
vox-tauri-codegen	Hint-only Tauri 2 packaging under target/generated/tauri-packaging/ (tauri.conf.json + runtime-capabilities.projection.json from contracts/capability/runtime-capabilities.v1.yaml; not a full src-tauri crate yet).
vox-crypto	Pure-Rust crypto primitives (chacha20poly1305 AEAD, ed25519, x25519); sole crypto SSOT per AGENTS.md §Cryptography Policy.
vox-grammar-export	Exports the Vox grammar artifact for downstream tooling.
vox-hf-layout	SSOT: Hugging Face config.json layout parsing for MENS (vox-populi::mens::tensor::hf_load) and vox-plugin-mens-candle-cuda.
vox-identity	Identity primitives: signing keys, trust ledger entries.
vox-mesh-transport	iroh QUIC mesh transport: persisted mesh identity, EndpointId trust allowlist, and the job wire protocol.
vox-jsonschema-util	Shared JSON Schema compile + validate helpers for CLI, contracts, and tooling.
vox-redact	Regex-based redaction of secrets and PII from log lines and JSON values.
vox-language-surface	SSOT for keyword/decorator surface strings (LSP completions, grammar docs); zero deps to avoid a vox-compiler ↔ vox-grammar-export cycle. vox_compiler::language_surface re-exports it.
vox-llm-config	SSOT for LLM/AI setting-key metadata. Pure-data, zero workspace dependencies.
vox-openai	OpenAI integrations: wire-format types (chat_completion.rs) + SSE streaming (sse.rs) in one L1 crate.
vox-package-types	Pure-data L1 leaf for vox-package: manifest, lockfile, package_kind, resolver types.
vox-plugin-api	Shared API surface for Vox plugins: ABI version, traits, manifest types, error types.
vox-plugin-sdk	Authoring SDK for code plugins: re-exports the stable ABI + the declare_plugin! glue macro (ABI-neutral, byte-identical exports).
vox-plugin-types	Pure-types surface for the vox plugin system: manifests, skill types, state-backend trait.
vox-telemetry	L1 telemetry facade: METRIC_TYPE_* constants, TelemetryRecorder trait, record_event! macro, TelemetryConfig (Phase D: org-policy hard-off + VOX_TELEMETRY=on/off/debug), per-task TaskAggregate, record_task_started. Zero domain dependencies.
vox-telemetry-otlp	L3 feature-gated OTLP egress: project_event (variant→category projection, privacy transforms), redact_event (taxonomy-allowlist guard, second layer), to_otlp_log (OTLP/HTTP logs JSON encoder). remote feature adds the async uploader. Only binary surfaces (vox-cli) register it — domain crates depend on vox-telemetry only.
vox-runtime	Umbrella runtime foundation: RuntimeProfile (Desktop vs Mobile), lifecycle traits, VoxConfig. Consumed by downstream runtime crates and the uniffi mobile bridge. Zero internal deps.
vox-http-client	Shared HTTP client presets (user-agent, timeouts) for CLI, runtime, and AI transports.
vox-rename-registry	Rename registry (RenameKind, RenameRegistry, RegistryError) and primitive-tag lookup (primitive_tags::all_primitives, is_primitive). L0 — zero workspace deps. Re-exported via vox_compiler::parser::renames and vox_compiler::lowering_shared::primitive_tags.
vox-shell-stdlib-types	Shared data types for the Vox shell stdlib surface (std.fs.*). VoxFileRecord — the canonical file-metadata type used by both the compiler interpreter path and vox-actor-runtime codegen path. L0 — only serde dep.
vox-research-events	Typed SCIENTIA research event types and PreregistrationV1.
vox-rule-pack	Declarative YAML rule-pack loader for code-audit detector patterns and Scientia heuristics. Zero heavy deps.
vox-scaling-policy	Compile-time and runtime accessors for scaling SSOT (contracts/scaling/policy.yaml); includes donations_vox for mesh donations.vox parse/pretty-print (folded from retired vox-mesh-policy).
vox-mesh-policy	Donations.vox mesh policy parser and WorkerDonationPolicy type; migration to vox-scaling-policy::donations_vox in progress.
vox-secrets	Central secret resolution and compatibility adapters for Vox.
vox-build-queue	Fair FIFO build queue, cargo resolution, and build metrics library for the vox-cargo-shim build broker. Layer 1.

L2 — domain libraries

Crate	One-line scope
vox-capability-registry	Transport-independent capability registry (YAML SSOT) + Mens chat tool descriptors.
vox-config	Centralized configuration and env/default resolution for Vox tooling; project_manifest parses [workspace] / [bundle] slices from Vox.toml for vox compile.
vox-config-derive	Proc-macro companion for #[derive(VoxConfig)]; zero runtime deps.
vox-constrained-gen	Grammar-constrained inference engine — Earley/PDA backends, deadlock watchdog, stream-of-revision.
vox-doc-inventory	Generate and verify docs/agents/doc-inventory.json (schema v3) without Python.
vox-eval	Evaluation metrics — deterministic scoring of model outputs / Vox samples (format/safety/quality/parse) + MENS CompileVerdict. Not the interpreter; --interp lives in vox-compiler/src/eval/.
vox-graph-reader	Vox Graph structural reader: BFS traversal, shortest path, god-nodes ranking, and cross-manifest diff.
vox-journal	Generic append-only JSON Lines file journal; crash-safe via per-record sync_data (default) or deferred-to-lifecycle sync for the mobile profile, replays on open. Durable substrate for workflow/actor runtimes and the mobile vox-runtime-rn (deps vox-runtime).
vox-llm-egress	Sanctioned LLM provider wire; pure egress (deps = vox-http-client + reqwest), no config/secret resolution.
vox-effort-audit	AI-judged audit of git commit history; walks commits, calls model-agnostic judge facade, emits ranked findings JSONL + report. CLI: vox audit effort.
vox-effort-route	Routes effort-audit findings to verified, drafted enforcement artifacts (AGENTS.md rule / lint detector spec / arch rule / CI gate / corpus example / Vox script). CLI: vox audit effort-route.
vox-llm-egress	Sanctioned LLM provider wire; pure egress (deps = vox-http-client + reqwest), no config/secret resolution.
vox-mcp-registry	Compile-time MCP tool registry and capability profiles (PROFILES, ActiveProfile, authorize_tool) from contracts YAML (SSOT).
vox-llm-egress	Sanctioned LLM provider wire; pure egress, no config/secret resolution.
vox-project-scaffold	Shared Vox.toml + src/main.vox + skill scaffolding for vox init and MCP.
vox-repository	Repository discovery, stable identity, layout probes, and agent scope helpers for external and internal Vox workspaces.
vox-similarity	Pure simhash/minhash/LSH near-duplicate similarity core for discovery + marketplace dedup.
vox-skill-runtime	Abstract sandbox runtime trait for skill execution. Implementations ship as plugins (wasm, container).
vox-free-ai (planned)	Free-AI provider cascade (Ollama/Gemini/OpenRouter) with cost accounting; no game mechanics. Extracted from vox-gamify. See the crate-build disentanglement suite (docs/superpowers/plans/2026-06-19-crate-build-disentanglement-suite-index.md).

L3 — heavy domain crates

Crate	One-line scope
vox-actor-runtime	Process-oriented runtime: actors, mailboxes, supervision, scheduling, LLM/Mens activity primitives.
vox-cli-core	Shared internals for the vox CLI binary (argv parsing helpers, exit-code policy).
vox-code-audit	AI code quality stub detector — finds stubs, magic values, empty bodies, missing references, and DRY violations.
vox-drift-check	Workspace drift and pattern-repetition linter (multi-language: Rust, TypeScript, Vox).
vox-codegen	Codegen + WebIR + hir_export extracted from vox-compiler. Consumes analysis types from vox-compiler.
vox-rn-codegen	React Native + Expo TypeScript codegen extracted from vox-codegen.
vox-codegen/src/projection_bundle.rs	project_bundle_from_hir — SSOT assembly of WebIR, AppContract, RuntimeProjection, ShellProjection, and RequiredRuntimeCapabilities for emitters.
vox-compiler/src/shell_projection.rs	Typed shell/mobile primitive projection from HIR (@back_button, @deep_link, @push).
vox-compiler/src/required_capabilities.rs	HIR-derived sorted capability id list for packaging / filtered Tauri runtime-capabilities.projection.json.
vox-scientia-jsonschema-codegen	Offline cargo run tool: contracts/scientia/*.schema.json → vox-research-events typify bundle (schema_types.generated.rs).
vox-compiler	Unified Vox compiler: lexer, parser, AST, HIR, typechecker, and codegen. MENS decorators @inference, @training_step, @distributed_train parse in parser/descent, effects + CUDA gate in typeck/. Orientation: vox-compiler-architecture-research-2026.md.
vox-compiler/src/eval/shell_stdlib.rs	Interpreter (--interp) mirror of shell‑tier std.* builtins — must stay aligned with vox-actor-runtime (Cargo cycle prevents a direct dep; shared types extracted to vox-shell-stdlib-types). See vox-shell-stdlib-ssot-2026.md.
vox-actor-runtime/src/builtins/mod.rs	SSOT Rust lowering targets for std.fs / std.process / structured formats (std.csv, std.toml, std.yaml, std.io) used by native codegen.
Static web scraping (Scrape.* builtins)	vox_scrape_* in vox-actor-runtime/src/builtins/mod.rs (fetch/fetch_html/select/select_attr — reqwest + scraper CSS, no browser); registered in builtin_registry.rs. Native-codegen only (no interp/WASI); effect Net. For JS-rendered pages use Browser.* (vox-plugin-browser, chromiumoxide CDP). See scoping doc.
vox-shell-stdlib-ssot-2026.md	Architecture SSOT: argv‑first shell‑tier stdlib vs host shells / vox_run_shell.
vox-container-types	Pure OCI types: ContainerRuntime trait, BuildOpts/RunOpts, RuntimePreference, exec_grammar parser. L0; no I/O.
vox-container	OCI container runtime backends (Docker + Podman CLI) and detect_runtime. L3; re-exports all types from vox-container-types.
vox-corpus	Training data contracts, preflight, corpus SSOT, and Mens dataset metadata.
vox-db	Codex / VoxDb facade: schema migrations, store ops, Turso/libSQL access for the Vox workspace.
vox-sql	Engine-agnostic SQL surface for app data-plane backends: SqlDialect/SqlBackend, AnySqlBackend::connect_from_app_env (VOX_APP_DB_URL -> VOX_DB_URL fallback), migrate::AppAutoMigrator, and normalized SqlValue/row contracts (with P5 DDL + migrate smoke tests under crates/vox-sql/tests/).
vox-deploy-codegen	Deployment artifact codegen: Dockerfile, Compose, K8s, Fly, Coolify, systemd. Pure text generation.
vox-doc-pipeline	Docs lint + doctest helpers for docs/src/; Starlight sidebar and RSS are built at docs-astro publish time (see root AGENTS.md).
vox-package	Vox package manager runtime: content-addressed artifact cache, registry HTTP client, workspace discovery.
vox-quantize	Data-free k-quant PTQ engine (SafeTensors → Candle GGML quantized SafeTensors; GPU-first, CPU fallback).
vox-populi — inference	MENS Mn-T2: InferenceBackend trait + multi-backend dispatcher (Candle CPU/CUDA/Metal, llama.cpp RPC, Ollama). Merged from retired vox-inference. Feature inference / mens-candle-qlora.
vox-populi — distributed_training	MENS Mn-T1/Mn-T6: TrainingSession, signed GradientShard / CheckpointBundle, OperationKind::TrainingCheckpoint mapping. Merged from retired vox-distributed-training.
vox-ml-cli	ML / Oratio / Populi / telemetry CLI binary (vox-ml-cli); Mens training, GPU features, optional workflow glue.
vox-forge	Platform-agnostic Git forge API — GitHub, Gitea, Forgejo (GitLab deprecated/unsupported as of 2026-06-03).
vox-gamify	Gamification layer — companions, quests, battles, and free AI integration.
vox-git	Pure-Rust Git bridge using gix (no C, no libgit2).
vox-vcs	VCS backend abstraction: VcsBackend trait + in-memory CasFallback; the single home for all jj_lib:: calls (the jj-lib 0.42 JjBackend lands in a later phase). Injected as a trait object into vox-compiler to avoid L3 coupling.
vox-oauth-pkce	RFC 8252 loopback-server OAuth + RFC 7636 PKCE flow for in-app free-tier key provisioning; provider-agnostic pkce core (verifier/challenge/state generation) plus a per-provider driver module (openrouter, added in a later task).
vox-lsp	Vox Language Server (stdio JSON-RPC). Capability matrix: vox-lsp-capabilities-ssot-2026.md.
vox-openclaw-runtime	OpenClaw client + ARS runtime adapter, executor, context bundles, hooks.
vox-research-shim	DEI research pipeline and model-selection sub-systems (A-12 wedge). SCIENTIA orchestrator, claim/verify/persist, BroadcastEmitter, ScientiaMeshSubscriber, and selection:: (FreeTierRouter, ModelScorer, task_routing). Uses vox_orchestrator::types::RoutingProfile.
vox-orchestrator	Multi-agent file-affinity router. types::RoutingProfile (7 routing intent variants), ModelTier (Unknown→Local→Free→Fast→Light→Pro→Elite, generated from model-routing.v1.yaml), CostPreference::Economy (default — free-by-default policy). Extraction plan: see 2026-05-15-orchestrator-tier-d-plan.md.
vox-orchestrator-driver	Thin L3 driver for embedding vox-orchestrator in CLI and MCP hosts.
vox-orchestrator-mcp	MCP (Model Context Protocol) tool layer for vox-orchestrator. Extracted in 2026-05-08 reorg Phase 4. MCP LLM inference bridge — provider routing, free-tier policy, and per-vendor HTTP adapters — lives in-tree at src/llm_bridge/ (a standalone vox-mcp-llm-bridge extraction was registered in layers.toml but never actually performed; removed as stale — reinstate only alongside real extraction work).
vox-orchestrator-models	Model usage accounting (usage, usage_policy) and the contextual-bandit calibration (calibration) split out of vox-orchestrator (build-loop plan Part B; models/ and the provider catalogs follow in B4). vox-orchestrator re-exports each module, so vox_orchestrator::usage::… paths are unchanged.
vox-orchestrator-queue	Locks, oplog, and affinity tracking for vox-orchestrator. Extracted in 2026-05-08 reorg Phase 5.
vox-orchestrator-test-helpers	Test-only fixtures and mocks for vox-orchestrator: MockBulletinBoard, load_golden_fixture.
vox-speech	Speech-to-text (Oratio) — transcript refinement, routing and in-process Sherpa-ONNX STT. Candle Whisper lives in vox-plugin-speech, reached through a host-registered transcriber (Phase 3 D-08/D-12).
vox-plugin-catalog	SSOT catalog of all first-party Vox plugins and distribution bundles.
vox-plugin-host	Host-side plugin discovery, loading, and registry.
vox-plugin-test-harness	Shared test utilities for plugin authors: fluent Plugin.toml manifest builders (CodeManifestBuilder, SkillManifestBuilder) and PluginDir temp-directory helper.
vox-populi	Vox Populi: multi-node worker registry, HTTP control plane, and Mens native ML (Candle QLoRA; Burn was fully removed 2026-05-08, see burn-necessity-audit-2026-05-08.md).
vox-populi-types	Pure-data types for the Populi mesh layer: NodeRecord, PopuliRegistryFile, PopuliRegistryError, and stateless helpers. L2 — no async runtime, no database. (ADR-042)
vox-publisher	Unified news syndication and publishing for Vox. SCIENTIA mesh intake from orchestrator research events: research_mesh.rs (+ contract contracts/scientia/research-mesh-intake.v1.schema.json).
vox-scientia	SCIENTIA cluster umbrella — all Phases A–H as sub-modules: producers (Phase A signal emitters), replay (Phase B re-executor), manuscript (Phases C+3+4 IMRaD/LaTeX scaffolders), critic_gate (Phase D gate), class_routing (Phase E venue routing), findings_site (Phase G HTML builder), dashboard (Phase H JSON builders).
vox-search	Local-first retrieval execution: memory hybrid, repo inventory, Codex chunks, policy, and optional lexical/vector backends.
vox-terminal-core	UI-agnostic terminal+agent engine: block model, input router, PTY host, OSC-633 parser, Vox-interpreter adapter, orchestrator adapter, transcript sink. Front-ends (vox-term TUI, GUI Console) render its blocks/events; neither reimplements the agent loop. Layer 3.
vox-term	Headless-capable ratatui TUI front-end for vox-terminal-core — renders its blocks/events (app loop, terminal setup, theming, vt, palette/input/blocks widgets); does not reimplement the agent loop. kind = "binary", Layer 4.
vox-llm-config	LLM configuration types and registry — unified SSOT for model settings shared across vox-orchestrator and vox-gui. Layer 3.
vox-llm-egress	LLM egress layer — provider routing, request construction, and response parsing for outbound LLM calls. Layer 3.
vox-skills	Skill marketplace and plugin architecture for the Vox agent system.
vox-skill-discovery	Local on-demand discovery + dedup engine: repeated .vox blocks, installed-skill dedup, MCP SSOT drift (advisory).
vox-tensor	Pure-CPU JSONL data loaders / training-pair types (Burn extracted 2026-05-08).
vox-test-harness	Shared compiler/tooling test fixtures plus workspace_paths (repo_root_for_tests), env_scratch (scoped set_var/remove_var), temp_root (tempfile::TempDir).
vox-wasm-engine	Single-source-of-truth Wasmtime engine + WASI execution for Vox programs and skill plugins.
vox-wire-format-validator	CI guard: enforces Wire Format v1 SSOT and Contract IR implementation parity.
vox-workflow-runtime	Interpreted workflow execution MVP (local + mens activity hooks).
vox-runtime-rn	uniffi-bridged Rust runtime for Vox mobile (React Native + Expo); cross-compiles to iOS/Android, generates TS TurboModule bindings. Bridges vox-runtime + vox-journal to JS; consumed out-of-tree by clients/runtime-rn.
vox-tauri-stt	Tauri 2 on-device speech-to-text plugin — wire format, guest JS facade, Android/iOS native sources.

L5 — surfaces

Crate	One-line scope
vox-cli	Vox command-line interface: compile, run, bundle, and workspace diagnostics.
vox-langtool	DB-free CLI for the Vox language: check, fmt, run, build (no database runtime required).
vox-cli-ci	CI guard checks extracted from vox-cli (line-endings, workflow-concurrency-guard, and related).
vox-cli-contracts	Trait seam between vox-cli and vox-cli-ci (CheckProvider, GateStatusWriter, TerminalPolicyValidator, HeavyGuardHost); zero tokio.
vox-cli-research	commands/research/ extracted from vox-cli (infra + eval, mesh intake); consumed exclusively by vox-cli.
vox-cli-review	CodeRabbit batch-PR review flow (vox review coderabbit) extracted from vox-cli; consumed exclusively by vox-cli.
vox-cli-share	utils/share (marketplace share/publish) extracted from vox-cli; consumed exclusively by vox-cli.
vox-cli-tests	End-to-end vox build/vox new CLI integration harness (test-only L5; assert_cmd subprocess + tsc/cargo check).
vox-integration-tests	Cross-crate integration test harness (test-only L5).
vox-orchestrator-d	Vox orchestrator daemon binary. Extracted from vox-orchestrator in 2026-05-08 reorg Phase 4.
vox-gui	Tauri desktop shell; depends on vox-cli / vox-orchestrator.
Axis Drive (vox gui drive)	Dedicated debug Axis + loopback drive bus. Contract contracts/gui/axis-drive.v1.yaml; Rust crates/vox-gui/src/drive/; CLI crates/vox-cli/src/commands/gui/; host crates/vox-gui/ui/src/components/drive/AxisDriveHost.tsx. Not Drive Console.
Remote Axis (GUI ↔ vox serve)	Backend/BackendState, GatewayClient, TOFU pin, invoke gate in crates/vox-gui/src/remote/; commands crates/vox-gui/src/commands/axis_remote.rs; manifest contracts/gui/command-backends.v1.yaml (CI: vox ci gui-catalog-parity); UI hooks/useBackendStatus.tsx, components/layout/SurfaceUnavailable.tsx, Settings → Server.
vox-audit	CR-L gate runner binary (vox audit <thing>); implements the JSON report shape from contracts/ci/vox-audit-contract.v1.yaml.
voxup	Desktop & CLI environment installer.
vox-cargo-shim	Scoped daemonless cargo shim that fair-queues builds within a vox worktree (the build broker binary). Layer 5.

Common tasks → exact path

I want to…	The right place
List / edit / cancel / reprioritize queued tasks	Daemon RPCs orch.list_tasks / orch.edit_task in orch_daemon/mod.rs; Tauri wrappers in crates/vox-gui/src/commands/control_plane.rs; GUI surface crates/vox-gui/ui/src/components/surfaces/Tasks/
Tune LLM/OpenRouter concurrency	[llm] section of VoxConfig (crates/vox-config/src/config/); AIMD throttle in vox-actor-runtime::llm
Query aggregated mesh resources	GET /v1/populi/resources/summary → aggregate_resources in vox-populi .../handlers/nodes.rs
Make scaling honor local CPU/RAM	crates/vox-orchestrator/src/services/local_resources.rs (feature system-metrics) + decide_scaling in services/scaling.rs
Near-duplicate task detection	crates/vox-orchestrator/src/services/similarity.rs (consumed in orch_daemon SUBMIT_TASK)
Multi-tab chat sessions	crates/vox-gui/ui/src/lib/sessions.ts + components/layout/SessionTabs.tsx; session_id threads through AgentTask/events/A2A envelope
Omni-search the palette (settings/docs/windows)	crates/vox-gui/ui/src/components/layout/paletteSources.ts + settings/settingsIndex.ts + docs_index.rs
Add an MCP tool	crates/vox-orchestrator-mcp/src/<group>_tools.rs (e.g. git_tools.rs); register dispatch in mcp/dispatch.rs; add its row to catalog.v1.yaml with mcp.exposure, mcp.requires, and side_effect_class (gate: vox ci operations-sync --target mcp)
Add or change a capability profile (tool slice + subsystems)	Manifest contracts/profiles/<id>.v1.yaml (compiled into PROFILES by vox-mcp-registry/build.rs); decision fn authorize_tool in profile.rs; host guard vox-orchestrator-mcp/src/profiles.rs; reference capability-profiles.md
Run Vox headless with one capability slice	vox serve --profile in commands/serve.rs; vox mcp --profile in commands/mcp.rs; bundle defaults profiles = [...] in catalog.toml
Tool-call receipts (issue/fulfill around every MCP dispatch; claim verification)	Ledger tool_receipt.rs; wrap handle_tool_call_with_receipt in dispatch.rs; tool vox_verify_task_claims in receipt_tools.rs; chat chips in ChatTurnEventRow.tsx (ADR-029)
Resource locks for hopper tasks	Manager locks/resource.rs; ResourceGate in orchestrator/safety.rs; acquire/park/retry in orchestrator/dispatch.rs; chat rail chips via useChatExecutionData.ts (ADR-025)
Measure retrieval quality / gate a retrieval change; inspect or rebuild the KB index	CLI vox kb eval|status|reindex in crates/vox-cli/src/commands/kb.rs (status and reindex call the daemon through commands/daemon_tool.rs, never an in-process writer); metrics engine crates/vox-search/src/kb_eval/ (kb_eval); KB ids and the heading_path encoding in crates/vox-search/src/kb_ids.rs; golden set under contracts/kb/eval/ (BEIR format — never index it or paste from it); baseline contracts/kb/retrieval-baseline.v1.json (tighten-only)
KB Library index (chunker, corpus walker, indexer, Tantivy lexical leg)	crates/vox-search/src/library/ (chunk.rs, corpus.rs, lexical.rs, mod.rs); rows and manifest in crates/vox-db/src/store/ops_memory/library.rs, table kb_index_state. The lexical leg is Tantivy because the turso FTS5 probe found no FTS5 module.
KB MCP tools and kb:// resources	Tools vox_kb_search, vox_kb_get, vox_kb_cite, vox_kb_status, vox_kb_reindex in crates/vox-orchestrator-mcp/src/kb_tools/library.rs (catalog ids kb.search … kb.reindex); kb://doc / kb://chunk resources in kb_resources.rs of the same crate
Trust tier vocabulary (ContextTrustTier, FindingTier, node-type taint mapping)	crates/vox-orchestrator-types/src/trust.rs (trust); re-exported by vox-db and the orchestrator envelope. No Default; parse is fail-closed.
KB text sanitizer and newtypes (sanitize, SanitizedText, ContentHash, FindingOrigin, FindingStatus)	crates/vox-db-types/src/kb_text.rs (kb_text), reachable as vox_db::kb_text; red-team cases under contracts/kb/redteam/
Findings inbox table and CRUD (kb_findings)	crates/vox-db/src/store/ops_memory/kb_findings.rs; read-only legacy VoxKB readers in kb_legacy.rs of the same directory
Findings capture pipeline, GUI side-door helpers, legacy VoxKB migration	crates/vox-orchestrator-mcp/src/kb_tools/findings.rs (capture_finding, file_gui_finding, file_publish_draft, migrate_legacy_kb_entries)
Web-hit capture trait (what the search web leg hands to the inbox)	crates/vox-search/src/capture.rs (capture)
Promotion eligibility verdict (fail-closed Crossref check)	crates/vox-search/src/trust.rs (trust)
KB taxonomy vocabulary and facet schema (topic / domain prefLabels, altLabels, Facets)	contracts/documentation/kb-taxonomy.v1.yaml, contracts/documentation/kb-facets.v1.schema.json, crates/vox-kb-facets/
Facet lint and backlog ratchet (facet-* rule ids, shrink-only allowlist)	crates/vox-doc-pipeline/src/pipeline/facets.rs, facet_backlog.rs; contracts/documentation/kb-facet-backlog.v1.yaml; vox-doc-pipeline --seed-facet-backlog / --tighten-facet-backlog
GUI facet type	crates/vox-gui/ui/src/generated/kbFacets.generated.ts, regenerated by vox ci config-gui-codegen --kb-facets
General (non-Vox) curated knowledge pages	docs/src/library/ (docs category Library); indexed by the KB Library index
Add an HTTP route (orchestrator)	crates/vox-orchestrator-mcp/src/services/routes/
Add a CLI subcommand	crates/vox-cli/src/commands/<group>.rs + register in commands/mod.rs
Add a CI subcommand under vox ci	crates/vox-cli/src/commands/ci/
Add a new CI/db guard	crates/vox-cli/src/commands/ci/<name>.rs + register in cmd_enums.rs and run_body.rs. Mirror db_schema_coverage.rs.
Add a speech-to-code audit artifact	Contracts under contracts/speech-to-code/; narrative findings under docs/src/architecture/vox-speech-*-2026.md; cross-crate tests under crates/vox-integration-tests/tests/speech_*.
AI-first language fixtures (taxonomy + seed catalog + lifecycle)	contracts/agentos/ai-first-fixtures.v1.yaml (JSON Schema: contracts/agentos/ai-first-fixtures.v1.schema.json) + narrative SSOT ai-first-fixtures-research-2026.md.
Local act configuration (catalog image pin, platform map)	.actrc (repo root)
Extend vox ci pre-push modes / timing JSON	crates/vox-cli/src/commands/ci/pre_push.rs — add Step to build_steps or extend PrePushOpts
vox ci dev-loop-audit (AI/local compile-loop diagnostics)	crates/vox-cli/src/commands/ci/dev_loop_audit.rs
vox ci docs-reality-audit (doc/code audit artifacts + metrics)	crates/vox-cli-ci/src/docs_reality_audit.rs + contracts/reports/docs-reality-audit/
vox ci parse-status (golden parse matrix → examples/PARSE_STATUS.md)	crates/vox-cli/src/commands/ci/parse_status.rs
Find the canonical path for GUI surfaces (interop app, experimental visualizer, fixtures, VS Code host)	contracts/frontend/surface-ownership.v1.yaml — apps/interop/marquee_app, apps/experimental/visualizer, tests/fixtures/frontend/test_app_bundle, apps/editor/vox-vscode
Vox Console discovery engine — exposure ledger / spaced repetition (FSRS) / suggestion ranking	crates/vox-gamify/src/discovery/ (fsrs.rs, rank.rs, ledger.rs); backed by the discovery_state table (registered in vox-db manifest).
Vox Console terminal / discovery Tauri commands	PTY sessions in crates/vox-gui/src/commands/pty.rs (portable-pty); suggest/help/record in crates/vox-gui/src/commands/discovery.rs. Register in main.rs generate_handler!.
Vox Console UI surface (terminal, input editor, discovery rail, agent strip)	crates/vox-gui/ui/src/components/surfaces/Console/ — child of the workspace surface; registered as console (live_backend) in contracts/gui/surface-registry.v1.yaml, mounted via surfaceComponents.tsx + lib/navigation.ts.
Vox Console OSC 633/133 block segmentation (command/output blocks, exit-status dot, block-aware send-to-agent)	pure reducer + render helper in crates/vox-gui/ui/src/components/surfaces/Console/osc633.ts; xterm OSC handler + status decoration in TerminalTab.tsx; shell-integration injection (shell_integration_snippet, pwsh/bash) in crates/vox-gui/src/commands/pty.rs.
GUI browser preview + agent CDP live view	crates/vox-gui/ui/src/components/surfaces/Browser/ + crates/vox-gui/src/commands/browser.rs — narrative vox-gui-browser-support-2026.md
Agent browser snapshot + refs / named profiles / Chrome attach / chat research loop	Snapshot/refs/profiles/attach: 2026-09-07-agent-browser-driver-design.md. Chat pixels: 2026-09-08-chat-harness-research-loop-design.md — tool_images.rs, MCP Content::image, LlmChatMessage.content_parts, skill assets/skills/browser-research/. Frames via vox_config::paths::browser_frames_cache_dir() (Tier D).
Browser operator HITL (CallerContext, yield, park, screenshot mute)	Planned: vox-orchestrator-mcp browser_lock.rs + browser_hitl.rs; spec docs/superpowers/specs/2026-09-08-browser-hitl-design.md. Do not grow browser_tools.rs / agent_loop.rs.
GUI visual AI review (advisory, never gates)	crates/vox-orchestrator-mcp/src/visus_review/ (binary gui-visual-review) + capture spec crates/vox-gui/ui/e2e/visual-review.spec.ts — narrative gui-visual-ai-review.md
Add a Db<Entity>Id newtype	crates/vox-db-types/src/ids.rs (use the string_id! macro).
Add a DB store operation	crates/vox-db/src/<concept>.rs (impl block on VoxDb)
Add a pure-data DB row type	crates/vox-db-types/src/store_types/ (NOT vox-db)
Add a pure-data DB type	crates/vox-db-types/src/
Add a large-BLOB column (embeddings, files, media)	Prefer file/object storage with a path+hash pointer column over inline BLOB in SQLite. embeddings.vector (crates/vox-db/src/schema/domains/knowledge.rs) is the existing exception, kept inline because at present it holds ~0 real rows. Guardrail: if embeddings ever exceeds ~10k rows, or any single BLOB in it exceeds a few MB (a 1536-dim f32 vector is ~6KB, so a few MB implies a badly oversized embedding), move vector out to file/object storage and replace the column with a path+hash pointer — SQLite BLOB storage and VACUUM/backup costs degrade with large inline blobs at that scale. Not an issue today; treat this as a threshold to watch, not a task to do now.
Add an orchestrator type (Agent/Task/etc.)	crates/vox-orchestrator-types/src/agent_types/
Add an orchestrator policy module (D1–D10)	crates/vox-orchestrator/src/<module>.rs + register in lib.rs + add row to this table
Add a research-pipeline stage (claims/gate/planner/provider/types/verifier)	crates/vox-orchestrator/src/orchestrator/task_dispatch/research_dispatch.rs (autonomous research, multi-wave CRAG loop, triplet grounding) and crates/vox-orchestrator/src/orchestrator/task_dispatch/. web_gather delegates to vox-search (WebSearchDispatcher, CragRouter); planner/claims/verifier remain Phase 0a stubs until vox-claim-extractor. CLI: vox research run; MCP: vox_research_run. Telemetry bridge / policy feedback / mesh tap: crates/vox-research-shim/src/research/{research_event_metrics_bridge.rs, search_policy_feedback.rs, mesh_subscriber.rs}; narrative research-scientia-telemetry-channels.md.
Orchestrator policy façade (all D1–D10)	crates/vox-orchestrator/src/orchestrator_policy.rs
Circuit breaker — doom-loop detection (D6)	crates/vox-orchestrator/src/circuit_breaker.rs
Confidence fusion — Socrates trigger (D3)	crates/vox-orchestrator/src/confidence_fusion.rs
Tier cascade — model routing (D1)	crates/vox-orchestrator/src/tier_cascade.rs
Registry-backed model resolution (Thompson arms, privacy-local filter)	crates/vox-orchestrator/src/registry_model_resolve.rs
Inference tier/modality config for routing (InferenceConfig, TierProfile)	crates/vox-orchestrator/src/mode.rs
Embedded orchestration feature flags (YAML → runtime gates)	crates/vox-orchestrator/src/orchestration_feature_flags.rs
Plan-mode trigger — React vs. plan (D2)	crates/vox-orchestrator/src/planning/plan_mode_trigger.rs
Risk matrix — HITL escalation (D5+D9)	crates/vox-orchestrator/src/risk_matrix.rs
Privacy classifier — sensitivity detection (D8)	crates/vox-orchestrator/src/privacy_classifier.rs
Cache predictor — prefix cache routing (D7)	crates/vox-orchestrator/src/cache_predictor.rs
Budget gate — token/cost limits (D7)	crates/vox-orchestrator/src/budget_gate.rs
Chat turn trace (turn events, routing decision)	contract contracts/gui/turn-event-kinds.v1.json; producers crates/vox-orchestrator-mcp/src/chat_tools/chat/{agent_loop,turn_events}.rs; provenance crates/vox-orchestrator/src/models/provenance.rs; GUI crates/vox-gui/ui/src/lib/turnEvents.ts (model and mode label owner), lib/turnTrace.ts, components/surfaces/Chat/TurnTrace.tsx
Notices — model and routing rule (toast vs notification center), store, coalescing	crates/vox-gui/ui/src/lib/notices.ts; crates/vox-gui/ui/src/lib/noticeStore.ts; crates/vox-gui/ui/src/hooks/useNoticeCenter.ts
Notification center (the status bar’s bell and drawer)	crates/vox-gui/ui/src/components/common/NotificationCenter.tsx
Engine event severity (decided in Rust, exhaustive)	crates/vox-orchestrator/src/events_severity.rs
Agent-event annotation and the activity-appended event	crates/vox-gui/src/commands/event_annotate.rs
Routing reference and quality priors (derived scales with provenance)	crates/vox-orchestrator/src/models/reference.rs
Selection ranking and exclusion reasons	crates/vox-orchestrator/src/models/ranking.rs
Routing health (checked at every catalog refresh)	crates/vox-orchestrator/src/models/health.rs
Routing explainer (GUI: why a model, why not the others)	crates/vox-gui/src/commands/routing_explain.rs; crates/vox-gui/ui/src/components/surfaces/Models/RoutingExplainer.tsx
Compaction trigger — strategy selection (D7)	crates/vox-orchestrator/src/compaction_trigger.rs
Calibration — drift detection + bandit (D10)	crates/vox-orchestrator/src/calibration.rs
Sub-agent dispatch — spawn vs. inline (D4)	crates/vox-orchestrator/src/subagent_dispatch.rs
Attention interruption calibrator (learns from logged outcomes)	crates/vox-orchestrator/src/attention/calibrator.rs
Orchestrator policy metric_type constants	crates/vox-telemetry/src/types.rs — METRIC_TYPE_* constants
Telemetry master switch + org-policy hard-off	crates/vox-telemetry/src/config.rs — TelemetryConfig::from_env(), org_policy_disabled() (reads /etc/vox/telemetry-policy.toml), is_master_enabled(). Resolution order: org policy → VOX_TELEMETRY env var → per-category vars → default.
Telemetry debug sink (stderr JSON dump)	crates/vox-cli/src/lib.rs — StderrDebugSink; registered when VOX_TELEMETRY=debug.
Telemetry sink backed by VoxDb	crates/vox-db/src/telemetry_sink.rs — ResearchMetricsSink; handles ModelCall, TaskRootSummary, BuildSummary, Error, AiFixture.
LLM retry-loop error events	crates/vox-orchestrator-mcp/src/llm_bridge/infer.rs — emit_llm_error_event() helper + retry_attempt counter; emitted at each fallback site and terminal failure.
Orchestrator feature flags	contracts/orchestration/feature-flags.v1.yaml
AgentOS MCP → mutation_kind SSOT (orchestrator + std.agentos in Vox)	crates/vox-agentos-mutation/
AgentOS ACI envelope + mutation classification (MCP)	crates/vox-orchestrator-mcp/src/aci/
AgentOS guardrail kernel / checkpoint / intent planner	crates/vox-orchestrator/src/agentos/
AgentOS policy ledger (MCP mutation_kind → orchestrator risk overlay)	crates/vox-orchestrator/src/agentos/policy_runtime.rs
AgentOS shell backend adapters (contract-first)	crates/vox-cli/src/commands/runtime/shell/backends/
Semantic filesystem / intent retrieval bridge	crates/vox-search/src/semantic_fs/
AgentOS ACI contracts	contracts/aci/agent-computer-interface.v1.yaml + agent-computer-interface.v1.schema.json
Add a code-audit detection rule	crates/vox-code-audit/src/detectors/<rule>.rs
Add a skill manifest field	crates/vox-plugin-types/src/skill_manifest.rs
Parse a SKILL.md (YAML spec frontmatter + legacy TOML)	crates/vox-plugin-host/src/skill_parser.rs (parse_skill_md)
Discover bare SKILL.md skill dirs (agentskills.io interop layout)	crates/vox-plugin-host/src/external_skills.rs (discover_external_skills)
Standard skill discovery roots (.vox/.agents/.claude × ws+home)	crates/vox-config/src/paths.rs (skill_search_roots)
Skill disclosure into the chat system prompt (tier-1 catalog + pinned body)	crates/vox-orchestrator-mcp/src/chat_tools/skill_catalog.rs; wired in chat_tools/mod.rs build_system_prompt_with_skill
Ingest external skills into the CLI registry	crates/vox-cli/src/commands/extras/ars/registry.rs (install_external_skills)
Add a plugin manifest field	crates/vox-plugin-types/src/plugin_manifest.rs
Add a queue / lock / oplog method	crates/vox-orchestrator-queue/src/{locks,oplog,affinity}/
Add an LLM provider adapter	crates/vox-orchestrator-mcp/src/llm_bridge/providers/<name>.rs
Interpreter runtime value representation & memory model (copy-on-write)	crates/vox-compiler/src/eval/value.rs (VoxValue; List/Object/Tuple hold Rc<Vec<…>>, Fn.body is Rc) + crates/vox-compiler/src/eval/env.rs (Scope frames are Rc<HashMap>). No GC — pure value semantics via Rc + Rc::make_mut CoW; VoxValue is intentionally !Send (single-threaded interp). See vox-memory-model-audit-and-value-optimization-2026-06-05.md.
Receiver-imposed interpreter capabilities (CapabilitySet — --caps/// vox:caps grammar, canonical fs roots, gated namespace checks)	crates/vox-compiler/src/eval/caps.rs. Interpreter::caps is non-optional; the six production embedders (CLI run/repl/play, vox-langtool run, vox-terminal-core eval, vox-orchestrator-mcp workspace dispatch) each assign it explicitly right after Interpreter::new(...) — see production_embedders_assign_caps_explicitly in that file.
Per-script memory ceiling (counting allocator enforcing --max-memory)	crates/vox-cli/src/mem_limit.rs (arm, #[global_allocator]; _exit / TerminateProcess on overflow). Declared from crates/vox-cli/src/lib.rs.
InterpExecutor — dispatch interpreter execution across the mesh transport	Planned — lands in a later PR (mesh-phase3 PR 5). crates/vox-mesh-transport/src/interp_executor.rs does not exist yet; see previous row.
Isolation / capability model reference doc (grammar, embedder defaults, fs-root canonicalization rules)	docs/src/reference/isolation.md (category: Language Reference). Parser SSOT remains CapabilitySet in crates/vox-compiler/src/eval/caps.rs.
Project-scoped VOX.md memory (workspace DNA injected at session start; @path imports, depth-5 cap, cycle-guarded)	crates/vox-orchestrator/src/memory/project_file.rs (load_project_context) + MemoryManager::bootstrap_context_with_project / project_context (crates/vox-orchestrator/src/memory/manager.rs). Mirrors Claude Code’s CLAUDE.md; distinct from the account-scoped long-term MEMORY.md.
@versioned / @tracked decorator + interpreter repo.* VCS store (auto-snapshot-on-success)	Decorator spine in crates/vox-compiler/: lexer token (src/lexer/token.rs AtVersioned/AtTracked) → parser (src/parser/descent/decl/head.rs is_versioned) → FnDecl.is_versioned (crates/vox-ast/src/decl/fundecl.rs) → HirFn.is_versioned + uses vcs injection (src/hir/lower/decl.rs) → VoxValue::Fn { name, is_versioned } (src/eval/value.rs); the auto-repo.snapshot() hook fires on successful return in both call paths (src/eval/mod.rs Interpreter::call + src/eval/expr.rs Call arm) against the in-memory RepoStore (src/eval/repo.rs). Interpreter-only (--mode interp); inert in the compiled arms. See vcs-as-vox-language-feature-jujutsu-2026.md §4.3.
Add a code generator (Rust target)	crates/vox-codegen/src/codegen_rust/
Add a code generator (TypeScript target)	crates/vox-codegen-ts/src/
Naked-objects admin UI codegen (opt-in table → list/detail/edit React)	crates/vox-codegen-ts/src/admin_emit.rs
VUV contrast / color-vocabulary guarantee (gray-on-white refuses compile)	crates/vox-codegen/src/web_ir/validate_palette.rs + palette SSOT contracts/tokens/tailwind-palette.v1.json; canonical WCAG fn vox_compiler::tokens::wcag21_contrast_ratio
VUV occlusion / tier-inversion guarantee (Z-tiers, escape-hatch checks)	crates/vox-codegen/src/web_ir/validate_layer.rs; tiers in vox_compiler::hir::nodes::layer (LayerTier, may_parent_surfaces); z-ladder ZTier::z_value() in web_ir/mod.rs
Add a “this VUV bug must be impossible” regression case	Add examples/forbidden/<case>.vox with a // expect-error: <code> header; crates/vox-compiler/tests/forbidden_corpus_test.rs runs it through the full pipeline
Add a layer rule / arch-check rule	crates/vox-arch-check/src/main.rs + extend layers.toml schema
Add an architectural exception (allowed inversion)	Append [[known_inversions]] block in layers.toml with a reason
Add a new workspace crate	Update Cargo.toml [workspace.dependencies] AND add a row to layers.toml — vox-arch-check will fail otherwise
BundleRef / Bundle / BundleStore (P2-T1)	crates/vox-package/src/bundle.rs
WorkflowDrainStarted / WorkflowDrainState (P2-T3)	crates/vox-orchestrator/src/drain_oplog/workflow_drain.rs
activity_result_cache — table DDL + SQL constants (P2-T5)	crates/vox-db/src/ddl/activity_result_cache.rs
SCIENTIA claim extraction pipeline (VeriScore, MiniCheck, T1→T2)	crates/vox-claim-extractor/
SCIENTIA drift linter — workspace pattern-repetition checks	crates/vox-drift-check/
SCIENTIA UK AISI Inspect adapter, atomic-NEI novelty, ChronoFact, EvidenceConflict	crates/vox-inspect-bridge/
SCIENTIA nanopublication signing — spec-compliant RSA/ORCID, Trusty URI (upstream nanopub crate)	crates/vox-scientia/src/nanopub/spec.rs
SCIENTIA pre-registration — signing, deviation detection, Bayesian stopping	crates/vox-prereg/
SCIENTIA research event types and ResearchEventEmitter trait (L1)	crates/vox-research-events/
SCIENTIA RO-Crate 1.2 JSON-LD builder — CFF, CodeMeta, TOP-Level-2, ACM badges	crates/vox-ro-crate/
SCIENTIA novelty assessment seam (ChronoFilter + EvidenceConflict + NoveltySignalBreakdown wiring; assess_novelty())	crates/vox-publisher/src/scientia_novelty_assess.rs
SCIENTIA semantic similarity for prior art (cosine + Embedder seam)	crates/vox-publisher/src/scientia_semantic.rs
SCIENTIA embedding cache (vox-db scientia_embedding_cache table)	crates/vox-db/src/store/ops_embedding_cache.rs
SCIENTIA automated discovery producers — commit watcher + code-uniqueness signal	crates/vox-publisher/src/scientia_producers/ (commit_watcher.rs, code_uniqueness.rs)
SCIENTIA discovery inbox + scientia.discovery.surfaced WS topic	vox-db scientia_discovery_inbox table + crates/vox-orchestrator-mcp/src/http_gateway/scientia_feed.rs
SCIENTIA archive-run orchestrator (autofill-gate → approval → Zenodo → Software Heritage → receipt)	crates/vox-publisher/src/archive_run.rs (executor: crates/vox-cli/src/commands/db/publication/archive_run.rs)
SCIENTIA GUI surfaces — NoveltyEvidencePanel, DiscoveryInbox, ArchivePanel	crates/vox-gui/ui/src/components/surfaces/Scientia/ (Tauri commands: crates/vox-gui/src/commands/scientia_review.rs)

L0/L1 split: if your consumer only needs row/param TYPES (no async, no connection), depend on vox-db-types directly — not on vox-db. The full vox-db crate transitively pulls in turso and tokio.

Plugins (L4 — cdylib only; never compile-time deps for L0..L3)

If you’re writing a plugin (concrete sandbox, ML backend, GPU probe, etc.), it goes in a new crates/vox-plugin-<name>/ and depends on vox-plugin-api. Don’t depend on vox-orchestrator or vox-cli from a plugin.

Plugin crate	Provides
vox-plugin-browser	Browser automation plugin (chromiumoxide CDP).
vox-plugin-gamify (planned)	Gamification cdylib plugin: implements the Gamification extension point trait (quests/battles/XP/companions). Loaded dynamically by vox-cli-core; not a compile-time dep. See the crate-build disentanglement suite (docs/superpowers/plans/2026-06-19-crate-build-disentanglement-suite-index.md).
vox-plugin-cloud (planned)	CloudSync plugin stub: HF Hub / S3 model artifact sync.
vox-plugin-mens-candle-cuda	ML training backend plugin: Candle + CUDA. Implements MlBackend.
vox-plugin-mens-candle-metal	MENS Apple Silicon Metal execution plugin.
vox-plugin-mens-candle-core	Device-agnostic Candle QLoRA training/inference code shared by vox-plugin-mens-candle-metal and vox-plugin-mens-candle-cuda (config, manifest/model-card types, HF key/layout mapping, merge, preflight, telemetry, device-kind resolution). No cdylib entry point; rlib only. L4 because only those two plugins link it and its Candle deps are unconditional, which keeps Candle out of CORE L0–L3.
vox-plugin-nvml-probe	Hardware probe plugin: NVML for NVIDIA GPU introspection.
vox-plugin-speech	Speech-to-text + AudioCapture plugin: Candle Whisper backend + mic capture surface (both extensions in one plugin).
vox-plugin-populi-mesh	Populi mesh transport plugin (composite: code + skill).
vox-plugin-publication	Publication plugin: RSS/Atom ingest with dedup, Reddit/YouTube publish, scholarly job feeds.
vox-plugin-runtime-container	Skill-runtime plugin: Docker + Podman backends for vox-skill-runtime.
vox-plugin-runtime-wasm	Skill-runtime plugin: wasmtime-based WASI sandbox (default for pure-compute skills).
vox-plugin-webhook	Webhook plugin: HTTP listener with HMAC signature verification (GitHub, Discord, Slack; GitLab deprecated). Inlines the full webhook gateway (inbound handler, outbound delivery, channel adapters, bridge) in the webhook submodule — no separate library crate. Hosts drain events through the WebhookInbox poll extension; the opt-in hopper intake poller lives in vox-orchestrator-mcp (src/server_state/webhook_intake.rs), enabled by an [orchestrator.webhook] section (Phase 3 D-10/D-13).

When to NOT add a new crate

The default answer to “should this be a new crate?” is no. Add to an existing crate unless one of these is true:

Binary-only tools

Crates with kind = "binary" in layers.toml (e.g., vox-arch-check, vox-populi, vox-orchestrator-d) don’t need a [workspace.dependencies] entry in the root Cargo.toml — they’re consumed via cargo run -p <name>, not as library dependencies. The “Add a new workspace crate” instruction below applies to libraries only.

• The new code has zero callers in any existing crate (likely a plugin)
• The new code is pure types (no async, no DB) AND will have ≥3 consumers (consider an L0 or L1 crate)
• A subsystem in an existing crate has grown past its max_loc budget and is asking to be split (see Phase 4–5 of the reorg outcome)

vox-arch-check’s orphan detector flags new crates with no consumers. If you add one, expect that warning to land on your PR until you wire it up — that’s working as intended.

Skill-only plugins (no Cargo.toml — exempt from layers.toml)

These live under crates/ but are not Cargo crates. Each has a Plugin.toml and one or more .skill.md files. They are loaded at runtime via the plugin host, not compiled as Rust library crates.

Dir	Purpose
crates/vox-plugin-host/tests/fixtures/noop-skill/	No-op stub skill fixture for plugin-host integration tests (not a workspace crate).
crates/vox-plugin-skill-compiler/	Compiler skill — wraps vox compile as a Vox skill.
crates/vox-plugin-skill-git/	Git skill — wraps common git operations as Vox skills.
crates/vox-plugin-skill-memory/	Memory skill — CLAUDE.md / MEMORY.md management as a Vox skill.
crates/vox-plugin-skill-orchestrator/	Orchestrator skill — agent lifecycle management via Vox skill API.
crates/vox-plugin-skill-rag/	RAG skill — retrieval-augmented generation pipeline as a Vox skill.
crates/vox-plugin-skill-testing/	Testing skill — test-run orchestration as a Vox skill.
crates/vox-plugin-skill-testing-validate/	Test-validate skill — validates test outputs against expected results.
crates/vox-plugin-skill-v0/	Legacy v0 skill format shim — compatibility bridge.

Planned but not yet landed

Crates documented in architecture plan docs but with no directory on disk yet. The [planned] table in layers.toml is the canonical index; each row there points to the plan document that owns the work.

Do not create a new crate whose name matches these before checking the linked plan document — the design context and API shape are likely already specified.

SCIENTIA pipeline phases

These will be folded into vox-scientia sub-modules when implemented (Phase I onwards):

Planned crate	Notes
vox-claim-extractor	SCIENTIA claim extraction: VeriScore, MiniCheck, T1→T2.
vox-inspect-bridge	UK AISI Inspect adapter, atomic-NEI novelty, ChronoFact.
vox-prereg	Pre-registration: Trusty URI signing, deviation detection.
vox-ro-crate	RO-Crate 1.2 JSON-LD metadata builder.
vox-scientia-ingest	SCIENTIA corpus ingestion pipeline.

Orchestrator extractions

Planned crate	Notes
vox-cli-ci	Planned — not yet landed. vox ci subcommand extraction from vox-cli/src/commands/ci/ (22K LoC, 74 files). Blocked by 3 shared modules that must move to vox-cli-core first. See 2026-05-15-cli-ci-extraction-plan.md.
vox-orchestrator-core	Planned — not yet landed. Extract src/orchestrator/ (12,825 LoC) + Orchestrator struct into new crate. Blocked by Rust coherence (all inherent impl blocks must co-move with the struct); minimum co-move set ~17K LoC. See 2026-05-15-orchestrator-tier-d-plan.md.
vox-orchestrator-cap-mint	Sealed-trait façade for capability minting (P3-T6).

Mesh / release packaging

Planned crate	Notes
vox-mesh-models	Mesh model registry aggregation types.
vox-agentos-mutation	AgentOS mutation-kind SSOT — code currently lives in vox-primitives::agentos_mutation. Extract when fan-in ≥ 3.
vox-checksum-manifest	SHA-256 release asset verification.
vox-release-artifacts	.tar.gz/.zip packaging helpers for vox compile.
vox-assets	[bundle.assets] manifest validation + staged copy tree.

HTTP surface planned

Planned crate	Notes
vox-http-envelope	Wire-format v1 §6 JSON error envelope for generated Axum handlers.

Misc

Planned crate	Notes
vox-share	Public-URL tunneling (Cloudflare Quick Tunnels, localhost.run, Tailscale).
vox-ssg	Folded into vox-cli/src/utils/ssg/ (L4) by 9d385a60b (2026-05-12); not a planned crate and not CORE.
vox-exec-grammar	Not a crate. The AST parser and risk classifier live in vox-container-types::exec_grammar, re-exported as vox_container::exec_grammar.
vox-install-policy	SSOT constants for Vox install/update surfaces.
vox-dashboard	Retired (deleted 2026-05-12, ADR-037 / ADR-045). Use vox-gui (Tauri 2).
vox-mens-eval	Mn-T12 eval harness types (CompileVerdict).