Repository documentation, file by file.

Defines Boomai's purpose (local-first AI workspace) and the reliability thesis behind MAKER/MDAP.

Explains the daemon/desktop split, the API surface, and how the pieces fit together for orchestration.

Lists setup steps and contributor reading order, which anchor the docs and architecture files.

MIT license grant and warranty disclaimer.

Establishes the repo's legal usage terms for all source files.

Applies to the daemon, desktop, and docs unless otherwise noted.

Describes disclosure process and points to a security contact.

Reinforces local-first defaults and the separation between deterministic tools and probabilistic reasoning.

Documents expected response timelines for reports.

Sets behavioral expectations for contributors and collaborators.

Defines reporting pathways for violations (mirrors security contact).

Lists unacceptable behavior and enforcement approach.

Rust workspace root; declares members for the daemon and Tauri desktop runtime.

Ensures shared dependency resolution across server + desktop crates.

Uses resolver = "2" for the workspace.

Auto-generated lockfile for Rust dependencies.

Pins exact versions used by boomai-daemon and Tauri crates for reproducible builds.

Should not be edited manually.

cargo-deny policy covering advisories, license allowlist, and source restrictions.

Documents known advisory exceptions, mostly Tauri transitive deps.

Defines license allowlist and source registry rules.

Defines formatting conventions for Rust code (width, heuristics, newline style).

Keeps daemon code consistent across contributors.

Standardizes formatting across all Rust crates.

Explains the reliability cliff in long-horizon agents.

Summarizes MAKER/MDAP and the tiered tool stack used by the daemon.

Provides a high-level system map that connects to architecture.md.

Deep dive on daemon components, agent pipeline, and MCP integration.

Defines the execution lanes and how tools, voting, and validation interact.

References core types used across handlers and the UI API client.

Step-by-step setup for Rust, Node, Ollama, daemon, and desktop app.

Matches the runtime expectations used by desktop/src/lib/api.ts.

Documents the default daemon port and desktop auto-connect behavior.

Contribution guidelines and priority areas (MAKER, MCP, orchestration).

Lists pre-PR checks that align with deny.toml and rustfmt.toml.

Calls out manual testing and workflow expectations.

Roadmap for orchestration scaling, consensus improvements, and MCP exposure.

Highlights upcoming features that connect to ToolRouter and MCP work.

Outlines phased plans for reliability, lazy UX, and ecosystem growth.

Defines SemVer-ish policy for 0.x releases and tag strategy.

Matches current daemon versioning in boomai-daemon/Cargo.toml.

Describes release steps and CI expectations.

Primary product image asset.

Used in README and other high-level docs.

Represents the product in documentation visuals.

Blue variant brand image.

Referenced in CODE_OF_CONDUCT.md.

Used for community and contributor-facing docs.

Purple variant brand image.

Referenced in contributing materials.

Alternate theme for contributor docs.

Sand variant brand image.

Referenced in SECURITY.md.

Used to visually tag security-related docs.

Defines the shared data model for chat, execution status, and MAKER context.

ModelConfig and model structs are consumed by handlers and the desktop API client.

ExecutionPolicy is used by the orchestrator to choose between tool stubs, single probe, or Maker voting.

Normalizes all model calls into a single request/response schema.

Supports tool specs, truncation policy, routing hints, and response formats.

Used by ProviderRunner and HttpProvider to call OpenAI-style endpoints.

Trait contract for any model provider backend.

Implemented by core/providers/http.rs and used by ProviderRunner.

Allows new provider backends without changing orchestrator logic.

Implements ModelProvider using HTTP POST to /chat/completions.

Maps provider errors into ProviderErrorKind and records latency.

Used as the default provider in main.rs via ProviderRegistry.

Module export for HttpProvider.

Keeps provider implementations grouped under core/providers/.

Centralized error type for provider failures (timeout, auth, rate limit, etc.).

Separates user-facing message from internal diagnostics for safe UI exposure.

Used by ProviderRunner and HttpProvider to normalize failures.

Wraps ModelProvider with concurrency limits and timeouts.

Optionally enforces a global limiter across all providers.

Called by ProviderRegistry during orchestrator and handler requests.

Stores providers and their runners; picks a default provider.

Used by agents and the orchestrator to run model calls.

Updated by config handlers when model settings change.

Defines the capability model used to gate tool access.

CapabilityRequest includes caller, taint level, and step identifiers.

Referenced by ToolRequest and future tool execution policy.

Encodes trust boundaries (Trusted/UserProvided/RetrievedUntrusted).

Used in CapabilityRequest to protect sensitive tool operations.

Set by the orchestrator when issuing tool requests.

Defines the standard request/response wrapper for tool calls.

Used by ToolRouter and MakerOrchestrator for internal stubs.

Provides a structured surface for future tool integrations.

Defines the Agent trait shared by DecomposerAgent and RouterAgent.

AgentContext is currently empty but reserved for future metadata.

Standardizes the async call signature across agent types.

Trait for converting internal structs into UI-safe versions.

Used by system.rs to expose SanitizedSystemProfile to the frontend.

Keeps sensitive data out of public API responses.

Core execution engine that classifies intents and chooses execution policy.

Decomposes complex prompts into steps and executes each with tools or Maker voting.

Calls ToolRouter for deterministic stubs and ProviderRunner for model voting.

Prompts the model to output the next atomic step for decomposition.

Used by MakerOrchestrator during DecomposeAndExecute flows.

Executes via ProviderRegistry default runner.

Model-driven router that decides whether to call tools or respond directly.

Used as a fallback for SingleProbe paths in the orchestrator.

Executes via ProviderRegistry default runner.

Classifies steps into Tool/Math/Reasoning and picks execution strategies.

Includes regex matchers for time and calculator stubs.

Feeds MakerOrchestrator with the chosen ExecStrategy.

Module exports for decomposer, router, and orchestrator.

Re-exports MakerOrchestrator for use in handlers.

Keeps agent APIs centralized under the agents module.

Defines MCP protocol types and JSON-RPC envelopes.

Shared by McpClient to encode/decode requests and responses.

Models tool list and server info structures.

Implements MCP client using stdio or SSE transports.

Handles initialize handshake and tool listing.

Managed by McpManager and exposed via config_mcp handlers.

Stores MCP clients by server id and manages lifecycle.

Used by handlers to add servers and list tools.

Keeps MCP clients available across requests.

Module export surface for MCP client/manager/types.

Keeps MCP implementation grouped under one namespace.

Referenced by main.rs and handlers.rs.

Daemon bootstrap: tracing, config load, provider registry, and MCP manager.

Spawns telemetry logging and sets up Axum routes in handlers.rs.

Creates AppState shared by orchestrator and handlers.

Reads BOOMAI_PORT from env and binds to 127.0.0.1.

Used by main.rs to configure the Axum listener.

Defaults to port 3030 when BOOMAI_PORT is not set.

Loads/saves ModelConfig and keeps a small history for rollbacks.

Stores API keys in OS keyring and strips them from disk JSON.

Called by handlers to save, reload, or rollback configs.

Axum handlers for system profile, config, MCP servers, local models, and chat.

Instantiates MakerOrchestrator for /chat requests.

Bridges between UI API calls and daemon services.

Shared state container holding config store, providers, MCP, and agents.

Cloned into handlers and orchestrator for access to services.

Defines the data flow between the HTTP layer and core orchestration.

Collects system profile with sysinfo and generates engine recommendations.

Exposes sanitized profile to the UI via /system/profile.

Used by onboarding to decide local vs cloud defaults.

Defines available local models and connects to Ollama for installs.

Syncs installed models and exposes data to config/local handlers.

Feeds model selection UI and local install workflows.

Implements race_to_k: parallel candidates and first-to-k voting.

Used by MakerOrchestrator for reliable reasoning paths.

Cancels remaining tasks once consensus is reached.

Placeholder tool router that currently denies all tool requests.

Referenced by MakerOrchestrator when requesting internal stubs.

Exports ToolRouter module.

Placeholder for future tool implementations.

Keeps tool routing isolated from core orchestration.

Defines the boomai-daemon crate (version 0.3.2) and its dependencies.

Core runtime includes axum, tokio, reqwest, keyring, and tracing for API + orchestration.

NPM scripts for dev/build/tauri plus dependency list.

Pins the desktop to React 19, Tauri 2, Tailwind 4, and Vite 7.

Matches build commands referenced by tauri.conf.json.

Auto-generated lockfile that pins NPM dependency versions.

Ensures the desktop build is reproducible across machines.

Should not be edited manually.

HTML shell for the React app with Boomai title/description.

Sets favicon and preconnects to Google Fonts to reduce FOUC.

Defines the root DOM node for React rendering.

PostCSS config enabling Tailwind as a plugin.

Supports the design system defined in src/index.css.

Keeps the CSS pipeline aligned with Tailwind v4.

Vite dev server config for Tauri (fixed ports, HMR settings).

Ignores src-tauri in watch to keep dev stable.

Pairs with tauri.conf.json devUrl.

TypeScript configuration for the React renderer.

Strict settings and bundler module resolution.

Enforces unused locals and parameters.

TypeScript config for Vite config file compilation.

Keeps build-time TS isolated from app code.

Used by Vite tooling during dev/build.

Template note from the initial Tauri + React scaffold.

Not part of Boomai product docs, but useful for tooling hints.

Lists recommended IDE plugins for Tauri development.

React entrypoint that mounts App into #root.

Imports src/index.css to apply the Boomai design system.

Bootstraps the entire desktop UI tree.

Controls high-level UI state: splash, onboarding, then main shell.

Routes between chat/library/automations/settings views.

Acts as the top-level state machine for the desktop UI.

Design tokens for paper/space/red/teal palette and typography.

Defines UI utilities (buttons, badges, cards) and animations.

Provides styling used by nearly every component.

Typed API client for daemon endpoints at localhost:3030.

Wraps system profile, config, MCP, local model, and chat requests.

The desktop UI uses this to communicate with the Rust daemon.

Centralizes API_BASE so components do not hardcode URLs.

Vite type definitions for TS tooling.

Keeps editor and build tooling aligned with Vite globals.

Standard Vite boilerplate for type safety.

Primary navigation shell with left rail and collapse toggle.

Hosts the main view content from App.tsx.

Controls nav highlighting for chat/library/automations/settings.

Boot splash with timed progress bar and version label.

Displayed before onboarding to signal app startup.

Uses a fixed duration timer to advance to onboarding.

Multi-step onboarding flow for system check and model setup.

Calls api.system and api.config to test providers and install local models.

Guides users to connect local or cloud engines before chat.

Main chat UI with suggestions, copy action, and loading state.

Sends messages to api.chat, which routes to daemon /chat.

Implements the product's primary interaction surface.

Simpler chat UI used as a legacy or reference implementation.

Also calls api.chat for daemon interactions.

Not currently wired into App.tsx routes.

Library placeholder with search input and empty state visuals.

Future integration point for MCP/FS-based document sources.

Uses the design system's empty-state motif.

Automations dashboard placeholder and empty state.

Future hook for cron/task orchestration surfaced by the daemon.

Includes the starburst motif animation.

Settings UI for provider configuration and shortcuts.

Connects to daemon configuration endpoints via api.ts in future iterations.

Includes placeholder panels for appearance and data/privacy.

Form for model configuration (base URL, model, API key).

Uses api.config.model.test and save to persist settings in the daemon.

Meant for onboarding or settings integration.

Local model installer and selector driven by daemon APIs.

Shows available/installed models and triggers install/uninstall calls.

Relies on local model metadata defined in boomai-daemon/src/local.rs.

MCP server management UI for connecting and listing tools.

Calls /config/mcp endpoints on the daemon.

Prepares the UI for MCP extensibility workflows.

Displays system profile and engine recommendations from the daemon.

Used during onboarding to suggest local vs cloud engine.

Renders sanitized data from system.rs.

Primary Boomai logo mark.

Used by the desktop app shell and splash screen.

Matches the in-app brand system.

Horizontal wordmark variant used on light backgrounds.

Used in marketing or header contexts.

Tauri logo asset.

Default scaffold asset; not core to product UI.

Kept for reference or template usage.

Vite logo asset.

Default scaffold asset; not core to product UI.

Kept for reference or template usage.

React logo asset.

Default scaffold asset; not core to product UI.

Kept for reference or template usage.

Tauri desktop runtime crate metadata and dependencies.

Adds HTTP/opener plugins for local API calls and links.

Versioned independently from the daemon crate.

Runs tauri_build during compile time.

Required for generating bindings and app metadata.

Standard Tauri build hook.

Defines product metadata, build commands, window size, and bundling.

Connects the Vite dev server to the Tauri shell.

Disables CSP to simplify local dev while using plugins.

Binary entrypoint for the Tauri app runtime.

Delegates to lib.rs run() to initialize plugins.

Includes Windows subsystem attribute for release builds.

Configures the Tauri builder and registers plugins.

Enables HTTP and opener usage from the frontend.

Produces the running desktop window via tauri::Builder.

Capability policy that allows HTTP requests to localhost.

Required for the UI to reach the daemon API on port 3030.

Defines the permissions attached to the main window.

App icon set across platforms and sizes.

Used by the Tauri bundler when building installers.

Includes PNG, ICO, and ICNS formats.