feat: Add new tools and configurations for Castle platform

- Introduced `uv.lock` for dependency management with various packages including `pytest`, `colorama`, and `pluggy`.
- Added `pyrightconfig.json` for Python type checking configuration.
- Expanded `recommendations.md` with detailed scaling recommendations and project management strategies.
- Created shared `ruff.toml` for consistent linting across projects.
- Developed `Castle Tools` with various utilities including Android backup, browser automation, document conversion, and search tools.
- Implemented `backup-collect` and `schedule` tools for system administration tasks.
- Enhanced `search` functionality with indexing and querying capabilities using Tantivy.
- Added comprehensive documentation for each tool, including usage examples and installation instructions.

.gitignore

@@ -0,0 +1,2 @@
+.venv
+__pycache__

CLAUDE.md

@@ -1,77 +1,131 @@
 # CLAUDE.md
 
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+This file provides guidance to Claude Code (claude.ai/code) when working
+with code in this repository.
 
-## Repository Overview
+## Overview
 
-Castle is a monorepo of four independent Python projects that form personal infrastructure services. Each project has its own `pyproject.toml`, `uv.lock`, and dependencies.
+Castle is a personal software platform — a monorepo of independent projects
+(services, tools, libraries) managed by the `castle` CLI. Components declare
+**what they do** (expose HTTP, manage via systemd, install to PATH) and roles
+are **derived**, not labeled.
 
-| Project | Purpose | Layout |
-|---------|---------|--------|
-| **central-context** | REST API for storing/retrieving UTF-8 content in buckets | `src/central_context/` |
-| **notification-bridge** | Cross-platform desktop notification forwarder | `notification_bridge/` (no src/) |
-| **devbox-connect** | SSH tunnel manager with auto-reconnect | `src/devbox_connect/` |
-| **mboxer** | MBOX to EML email converter | Single file `convert.py` |
+**Key principle:** Regular projects must never depend on castle. They accept standard
+configuration (data dir, port, URLs) via env vars. Only castle-components (CLI, gateway,
+event bus) know about castle internals.
 
-## Build & Development Commands
+## Castle CLI
 
-All projects use **uv** as the package manager. Commands must be run from each project's directory.
+The CLI lives in `cli/` and is installed via `uv tool install --editable cli/`.
+
+```bash
+castle list                              # List all components
+castle list --role service               # Filter by derived role
+castle info <component>                  # Show manifest details (--json for machine-readable)
+castle create <name> --type service      # Scaffold new project
+castle test [project]                    # Run tests (one or all)
+castle lint [project]                    # Run linter (one or all)
+castle sync                              # Update submodules + uv sync all
+castle run <component>                   # Run component in foreground
+castle logs <component> [-f] [-n 50]     # View component logs
+castle gateway start|stop|reload|status  # Manage Caddy reverse proxy
+castle service enable|disable <name>     # Manage individual systemd service
+castle service status                    # Show all service statuses
+castle services start|stop               # Start/stop everything
+castle migrate                           # Convert castle.yaml to new format
+```
+
+## Registry & Manifest Architecture
+
+`castle.yaml` at the repo root is the single source of truth. It uses a **manifest**
+model (`cli/src/castle_cli/manifest.py`) where components declare capabilities:
+
+- **`run`**: How to start it (RunSpec: `python_uv_tool`, `command`, `container`, `node`, `remote`)
+- **`expose`**: What it exposes (HTTP port, health endpoint)
+- **`proxy`**: How to proxy it (Caddy path prefix)
+- **`manage`**: How to manage it (systemd)
+- **`install`**: How to install it (PATH shim)
+- **`build`**: How to build it (commands, outputs)
+- **`triggers`**: What triggers it (manual, schedule, event, request)
+
+**Roles are derived** from these declarations:
+- `service` — has `expose.http`
+- `tool` — has `install.path` or is fallback
+- `worker` — has `manage.systemd` but no HTTP
+- `job` — has schedule trigger
+- `frontend` — has build outputs
+- `containerized` — uses container runner
+- `remote` — uses remote runner
+
+## Component Roles (replaces Project Types)
+
+| Role | Convention | Example |
+|------|-----------|---------|
+| **service** | FastAPI, pydantic-settings, lifespan, `/health` endpoint | central-context |
+| **tool** | argparse, stdin/stdout, exit codes, Unix pipes | devbox-connect |
+| **worker** | Systemd-managed, no HTTP | (none yet) |
+| **job** | Scheduled task | (none yet) |
+| **containerized** | Docker/Podman container | (none yet) |
+
+## Creating a New Project
+
+```bash
+castle create my-service --type service --description "Does something"
+cd my-service
+uv sync
+uv run my-service       # starts on auto-assigned port
+castle test my-service   # run tests
+castle service enable my-service  # register with systemd
+```
+
+The `castle create` command scaffolds the project, generates a CLAUDE.md, and registers
+it in `castle.yaml` as a `ComponentManifest`.
+
+## Infrastructure
+
+- **Gateway**: Caddy reverse proxy at port 9000, config generated from `castle.yaml`
+  into `~/.castle/generated/Caddyfile`. Dashboard served at root.
+- **Systemd**: User units generated under `~/.config/systemd/user/castle-*.service`
+- **Data**: Service data lives in `/data/castle/<service-name>/`, passed via env var.
+- **Secrets**: `~/.castle/secrets/` — never in project directories.
+
+## Per-Project Commands
+
+All projects use **uv**. Commands run from each project's directory:
 
-### central-context
 ```bash
-cd central-context
 uv sync                     # Install deps
-uv run central-context      # Run service (port 9000)
 uv run pytest tests/ -v     # Run tests
-uv run pytest tests/test_storage.py -v  # Single test file
-```
-
-### notification-bridge
-```bash
-cd notification-bridge
-uv sync --extra linux       # Install deps (use --extra windows on Windows)
-uv run notification-bridge  # Run service (port 9001)
-uv run pytest --cov=notification_bridge  # Run tests with coverage
-uv run ruff format .        # Format
 uv run ruff check .         # Lint
+uv run ruff format .        # Format
 ```
 
-### devbox-connect
-```bash
-cd devbox-connect
-uv sync                     # Install deps
-uv tool install .           # Install as CLI tool
-devbox-connect -c tunnels.yaml start     # Start tunnels
-devbox-connect -c tunnels.yaml status    # Show status
-devbox-connect -c tunnels.yaml validate  # Validate config
-```
+Services also support: `uv run <service-name>` to start.
 
-### mboxer
-```bash
-cd mboxer
-uv sync             # Install deps
-python convert.py   # Run converter (configure via .env)
-ruff check . --fix  # Lint
-```
+## Existing Components
 
-## Architecture
-
-**central-context** is the hub — notification-bridge forwards captured desktop notifications to it via its REST API. The API organizes content into buckets (filesystem directories), auto-names entries by SHA256 checksum, and stores JSON metadata sidecars alongside content files.
-
-**notification-bridge** uses a platform adapter pattern: `listeners/base.py` defines a `NotificationListener` protocol, with `linux.py` (D-Bus) and `windows.py` (WinRT) implementations. The server captures notifications and POSTs them to central-context.
-
-**devbox-connect** manages persistent SSH tunnels defined in YAML config. It supports two config formats: simple (flat list) and grouped (by host). Tunnels auto-reconnect with exponential backoff. Has Windows service support via NSSM.
-
-## Configuration
-
-- **central-context**: Env vars with `CENTRAL_CONTEXT_` prefix, pydantic-settings
-- **notification-bridge**: `.env` file (`CENTRAL_CONTEXT_URL`, `BUCKET_NAME`, `PORT`)
-- **devbox-connect**: YAML config file (`tunnels.yaml`)
-- **mboxer**: `.env` file (`MBOX_PATH`, `OUTPUT_DIR`)
+| Component | Roles | Port | Description |
+|-----------|-------|------|-------------|
+| central-context | service | 9001 | Content storage API (submodule) |
+| notification-bridge | service | 9002 | Desktop notification forwarder (submodule) |
+| devbox-connect | tool | — | SSH tunnel manager |
+| mboxer | tool | — | MBOX to EML converter (submodule) |
+| toolkit | tool | — | Personal utility scripts (submodule) |
+| protonmail | tool | — | ProtonMail email sync via Bridge |
+| event-bus | service | 9010 | Inter-service event bus |
 
 ## Code Style
 
-- **Linting/formatting**: ruff (project-specific configs in each `pyproject.toml`)
-- **devbox-connect**: 100-char line length, pyright type checking at standard level, Python 3.10+
-- **central-context / notification-bridge**: Python 3.13, FastAPI
-- **Testing**: pytest with pytest-asyncio for async tests
+- **Linting/formatting**: ruff — shared `ruff.toml` at repo root (100-char lines)
+- **Type checking**: pyright — shared `pyrightconfig.json` at repo root
+- **Testing**: pytest, pytest-asyncio for async tests
+- **Python**: 3.13 for services, 3.11+ minimum for tools/libraries
+
+## Agent Workflow
+
+When creating a new service or tool:
+1. `castle create <name> --type <type>` — scaffold and register
+2. Implement the project logic
+3. `castle test <name>` — verify tests pass
+4. `castle service enable <name>` — deploy as systemd service (services only)
+5. `castle gateway reload` — update reverse proxy routes

README.md

@@ -0,0 +1,107 @@
+# Castle
+
+A declarative local control plane. Castle manages a collection of independent services, tools, and libraries from a single CLI, with a unified gateway, systemd integration, and standardized project scaffolding.
+
+## Quick Start
+
+```bash
+# Install the castle CLI
+cd cli && uv tool install --editable . && cd ..
+
+# Sync all projects (git submodules + dependencies)
+castle sync
+
+# See what's here
+castle list
+
+# Start everything (all services + Caddy gateway)
+castle services start
+
+# Visit the dashboard
+open http://localhost:9000
+```
+
+## Creating Projects
+
+```bash
+castle create my-api --type service --description "Does something useful"
+cd my-api && uv sync
+castle test my-api
+castle service enable my-api
+```
+
+Three project types are supported:
+
+- **service** — FastAPI app with health endpoint, pydantic-settings, systemd unit, gateway route
+- **tool** — CLI tool with argparse, stdin/stdout, Unix pipe conventions
+- **library** — Python package with src/ layout, no entry point
+
+## CLI Reference
+
+```
+castle list [--type TYPE] [--json]    List all projects
+castle create NAME --type TYPE        Scaffold a new project
+castle test [PROJECT]                 Run tests (one or all)
+castle lint [PROJECT]                 Run linter (one or all)
+castle sync                           Update submodules + install deps
+castle gateway start|stop|reload      Manage Caddy reverse proxy
+castle service enable|disable NAME    Manage a systemd service
+castle service status                 Show all service statuses
+castle services start|stop            Start/stop everything
+```
+
+## Registry
+
+`castle.yaml` at the repo root is the single source of truth. It defines every project's type, port, gateway path, data directory, command, and environment variables. The CLI reads this for all operations — generating Caddyfiles, systemd units, and dashboard HTML.
+
+```yaml
+gateway:
+  port: 9000
+
+projects:
+  central-context:
+    type: service
+    port: 9001
+    path: /central-context
+    command: uv run central-context
+    working_dir: central-context
+    data_dir: /data/castle/central-context
+    description: Content storage API
+    health: /health
+    env:
+      CENTRAL_CONTEXT_DATA_DIR: ${data_dir}
+```
+
+## Architecture
+
+```
+castle.yaml          ← project registry
+cli/                 ← castle CLI (castle-component)
+central-context/     ← content storage API (git submodule)
+notification-bridge/ ← notification forwarder (git submodule)
+devbox-connect/      ← SSH tunnel manager
+mboxer/              ← MBOX converter (git submodule)
+toolkit/             ← personal utility scripts (git submodule)
+event-bus/           ← inter-service event bus (castle-component)
+ruff.toml            ← shared lint config
+pyrightconfig.json   ← shared type checking config
+```
+
+**Independence principle:** Regular projects never depend on castle. They accept configuration (data dir, port, URLs) via environment variables. Only castle-components (CLI, gateway, event bus) know about castle internals like `castle.yaml`. This keeps projects portable and independently publishable.
+
+**Gateway:** Caddy reverse proxy at port 9000. All services are accessible under one address (`localhost:9000/central-context/*` → `localhost:9001/*`). A dashboard with live health checks is served at the root.
+
+**Systemd:** The CLI generates user units under `~/.config/systemd/user/castle-*.service`. `castle services start` brings up everything in one command.
+
+**Data:** Service data lives in `/data/castle/<service-name>/`, outside the repo. Secrets live in `~/.castle/secrets/`.
+
+## Current Projects
+
+| Project | Type | Port | Description |
+|---------|------|------|-------------|
+| central-context | service | 9001 | Content storage API |
+| notification-bridge | service | 9002 | Desktop notification forwarder |
+| devbox-connect | tool | — | SSH tunnel manager |
+| mboxer | tool | — | MBOX to EML converter |
+| toolkit | tool | — | Personal utility scripts |
+| event-bus | castle-component | 9010 | Inter-service event bus |

castle.yaml

@@ -0,0 +1,295 @@
+gateway:
+  port: 9000
+components:
+  # ── Services ──────────────────────────────────────────────
+  central-context:
+    description: Content storage API
+    run:
+      runner: python_uv_tool
+      cwd: central-context
+      env:
+        CENTRAL_CONTEXT_DATA_DIR: /data/castle/central-context
+        CENTRAL_CONTEXT_PORT: "9001"
+      tool: central-context
+    manage:
+      systemd: {}
+    expose:
+      http:
+        internal:
+          port: 9001
+        health_path: /health
+    proxy:
+      caddy:
+        path_prefix: /central-context
+
+  notification-bridge:
+    description: Desktop notification forwarder
+    run:
+      runner: python_uv_tool
+      cwd: notification-bridge
+      env:
+        CENTRAL_CONTEXT_URL: http://localhost:9001
+        BUCKET_NAME: notifications
+        PORT: "9002"
+      tool: notification-bridge
+    manage:
+      systemd: {}
+    expose:
+      http:
+        internal:
+          port: 9002
+        health_path: /health
+    proxy:
+      caddy:
+        path_prefix: /notifications
+
+  dashboard-api:
+    description: Castle dashboard API
+    run:
+      runner: python_uv_tool
+      cwd: dashboard-api
+      env:
+        DASHBOARD_API_CASTLE_ROOT: /data/repos/castle
+      tool: dashboard-api
+    manage:
+      systemd: {}
+    expose:
+      http:
+        internal:
+          port: 9020
+        health_path: /health
+    proxy:
+      caddy:
+        path_prefix: /api
+
+  # ── Jobs ──────────────────────────────────────────────────
+  protonmail:
+    description: ProtonMail email sync via Bridge
+    run:
+      runner: command
+      argv: ["protonmail", "sync"]
+      cwd: protonmail
+      env:
+        PROTONMAIL_USERNAME: paul@payne.io
+        PROTONMAIL_API_KEY: ${secret:PROTONMAIL_API_KEY}
+    tool:
+      tool_type: python_standalone
+      category: email
+      source: protonmail/
+    triggers:
+      - type: schedule
+        cron: "*/5 * * * *"
+    manage:
+      systemd: {}
+    install:
+      path:
+        alias: protonmail
+
+  backup-collect:
+    description: Collect files from various sources into backup directory
+    run:
+      runner: command
+      argv: ["backup-collect"]
+      env:
+        DBACKUP: /data/backup
+    tool:
+      tool_type: python_standalone
+      category: system
+      source: tools/system/
+      system_dependencies: [rsync]
+    triggers:
+      - type: schedule
+        cron: "0 2 * * *"
+    manage:
+      systemd: {}
+
+  backup-data:
+    description: Nightly restic backup of /data to /storage
+    run:
+      runner: command
+      argv: ["backup-data"]
+      env:
+        RESTIC_REPOSITORY: /storage/restic-data
+        RESTIC_PASSWORD_FILE: /home/payne/.config/restic-password
+    tool:
+      tool_type: script
+      category: system
+    triggers:
+      - type: schedule
+        cron: "30 3 * * *"
+    manage:
+      systemd: {}
+
+  # ── Frontend ──────────────────────────────────────────────
+  dashboard:
+    description: Castle web dashboard
+    run:
+      runner: node
+      cwd: dashboard
+      script: dev
+    expose:
+      http:
+        internal:
+          port: 5173
+    build:
+      commands:
+        - ["pnpm", "build"]
+      outputs:
+        - dist/
+
+  # ── Standalone tools ──────────────────────────────────────
+  devbox-connect:
+    description: SSH tunnel manager with auto-reconnect
+    tool:
+      tool_type: python_standalone
+      category: system
+      source: devbox-connect/
+    install:
+      path:
+        alias: devbox-connect
+
+  mboxer:
+    description: MBOX to EML email converter
+    tool:
+      tool_type: python_standalone
+      category: email
+      source: mboxer/
+    install:
+      path:
+        alias: mboxer
+
+  # ── Category tools (per-category packages) ────────────────
+  android-backup:
+    description: Backup Android device using ADB
+    tool:
+      tool_type: python_standalone
+      category: android
+      source: tools/android/
+      system_dependencies: [adb]
+    install:
+      path:
+        alias: android-backup
+
+  browser:
+    description: Browse the web using natural language via browser-use
+    tool:
+      tool_type: python_standalone
+      category: browser
+      source: tools/browser/
+    install:
+      path:
+        alias: browser
+
+  docx-extractor:
+    description: Extract content and metadata from Word .docx files
+    tool:
+      tool_type: python_standalone
+      category: search
+      source: tools/search/
+      system_dependencies: [pandoc]
+    install:
+      path:
+        alias: docx-extractor
+
+  docx2md:
+    description: Convert Word .docx files to Markdown
+    tool:
+      tool_type: python_standalone
+      category: document
+      source: tools/document/
+      system_dependencies: [pandoc]
+    install:
+      path:
+        alias: docx2md
+
+  gpt:
+    description: OpenAI text generation utility
+    tool:
+      tool_type: python_standalone
+      category: gpt
+      source: tools/gpt/
+    install:
+      path:
+        alias: gpt
+
+  html2text:
+    description: Convert HTML content to plain text
+    tool:
+      tool_type: python_standalone
+      category: document
+      source: tools/document/
+    install:
+      path:
+        alias: html2text
+
+  md2pdf:
+    description: Convert Markdown files to PDF
+    tool:
+      tool_type: python_standalone
+      category: document
+      source: tools/document/
+      system_dependencies: [pandoc, texlive-latex-base]
+    install:
+      path:
+        alias: md2pdf
+
+  mdscraper:
+    description: Combine text files into a single markdown document
+    tool:
+      tool_type: python_standalone
+      category: mdscraper
+      source: tools/mdscraper/
+    install:
+      path:
+        alias: mdscraper
+
+  pdf-extractor:
+    description: Extract content and metadata from PDF files
+    tool:
+      tool_type: python_standalone
+      category: search
+      source: tools/search/
+    install:
+      path:
+        alias: pdf-extractor
+
+  pdf2md:
+    description: Convert PDF files to Markdown
+    tool:
+      tool_type: python_standalone
+      category: document
+      source: tools/document/
+      system_dependencies: [pandoc, poppler-utils]
+    install:
+      path:
+        alias: pdf2md
+
+  schedule:
+    description: Manage systemd user timers and scheduled tasks
+    tool:
+      tool_type: python_standalone
+      category: system
+      source: tools/system/
+    install:
+      path:
+        alias: schedule
+
+  search:
+    description: Manage self-contained searchable collections of files
+    tool:
+      tool_type: python_standalone
+      category: search
+      source: tools/search/
+    install:
+      path:
+        alias: search
+
+  text-extractor:
+    description: Extract content and metadata from text files
+    tool:
+      tool_type: python_standalone
+      category: search
+      source: tools/search/
+    install:
+      path:
+        alias: text-extractor

cli/pyproject.toml

@@ -0,0 +1,27 @@
+[project]
+name = "castle-cli"
+version = "0.1.0"
+description = "Castle platform CLI - manage projects, services, and infrastructure"
+requires-python = ">=3.11"
+dependencies = [
+    "pyyaml>=6.0.0",
+    "jinja2>=3.1.0",
+    "pydantic>=2.0.0",
+]
+
+[project.scripts]
+castle = "castle_cli.main:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/castle_cli"]
+
+[dependency-groups]
+dev = [
+    "pytest>=7.0.0",
+    "ruff>=0.11.0",
+    "pyright>=1.1.0",
+]

cli/src/castle_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Castle CLI - manage projects, services, and infrastructure."""
+
+__version__ = "0.1.0"

cli/src/castle_cli/commands/create.py

@@ -0,0 +1,121 @@
+"""castle create - scaffold a new project from templates."""
+
+from __future__ import annotations
+
+import argparse
+
+from castle_cli.config import load_config, save_config
+from castle_cli.manifest import (
+    CaddySpec,
+    ComponentManifest,
+    ExposeSpec,
+    HttpExposeSpec,
+    HttpInternal,
+    InstallSpec,
+    ManageSpec,
+    PathInstallSpec,
+    ProxySpec,
+    RunPythonUvTool,
+    SystemdSpec,
+)
+from castle_cli.templates.scaffold import scaffold_project
+
+
+def next_available_port(config: object) -> int:
+    """Find the next available port starting from 9001 (9000 is reserved for gateway)."""
+    used_ports = set()
+    for manifest in config.components.values():
+        if manifest.expose and manifest.expose.http:
+            used_ports.add(manifest.expose.http.internal.port)
+    # Also reserve gateway port
+    used_ports.add(config.gateway.port)
+
+    port = 9001
+    while port in used_ports:
+        port += 1
+    return port
+
+
+def run_create(args: argparse.Namespace) -> int:
+    """Create a new project."""
+    config = load_config()
+    name = args.name
+    proj_type = args.type
+
+    if name in config.components:
+        print(f"Error: component '{name}' already exists in castle.yaml")
+        return 1
+
+    project_dir = config.root / name
+    if project_dir.exists():
+        print(f"Error: directory '{name}' already exists")
+        return 1
+
+    # Determine port for services
+    port = args.port
+    if proj_type == "service" and port is None:
+        port = next_available_port(config)
+
+    # Package name: convert kebab-case to snake_case
+    package_name = name.replace("-", "_")
+
+    # Scaffold the project files
+    scaffold_project(
+        project_dir=project_dir,
+        name=name,
+        package_name=package_name,
+        proj_type=proj_type,
+        description=args.description or f"A castle {proj_type}",
+        port=port,
+    )
+
+    # Build manifest entry
+    env_prefix = package_name.upper()
+
+    if proj_type == "service":
+        manifest = ComponentManifest(
+            id=name,
+            description=args.description or f"A castle {proj_type}",
+            run=RunPythonUvTool(
+                runner="python_uv_tool",
+                tool=name,
+                cwd=name,
+                env={f"{env_prefix}_DATA_DIR": f"/data/castle/{name}"},
+            ),
+            expose=ExposeSpec(
+                http=HttpExposeSpec(
+                    internal=HttpInternal(port=port),
+                    health_path="/health",
+                )
+            ),
+            proxy=ProxySpec(caddy=CaddySpec(path_prefix=f"/{name}")),
+            manage=ManageSpec(systemd=SystemdSpec()),
+        )
+    elif proj_type == "tool":
+        manifest = ComponentManifest(
+            id=name,
+            description=args.description or f"A castle {proj_type}",
+            install=InstallSpec(path=PathInstallSpec(alias=name)),
+        )
+    else:
+        # library or other
+        manifest = ComponentManifest(
+            id=name,
+            description=args.description or f"A castle {proj_type}",
+        )
+
+    config.components[name] = manifest
+    save_config(config)
+
+    print(f"Created {proj_type} '{name}' at {project_dir}")
+    if port:
+        print(f"  Port: {port}")
+    print("  Registered in castle.yaml")
+    print("\nNext steps:")
+    print(f"  cd {name}")
+    print("  uv sync")
+    if proj_type == "service":
+        print(f"  uv run {name}  # starts on port {port}")
+    print(f"  castle test {name}")
+
+    return 0

cli/src/castle_cli/commands/dev.py

@@ -0,0 +1,118 @@
+"""castle test / castle lint - run dev commands across projects."""
+
+from __future__ import annotations
+
+import argparse
+import subprocess
+from pathlib import Path
+
+from castle_cli.config import CastleConfig, load_config
+
+
+def _get_project_dir(config: CastleConfig, project_name: str) -> Path:
+    """Get the directory for a component."""
+    if project_name not in config.components:
+        raise ValueError(f"Unknown component: {project_name}")
+    manifest = config.components[project_name]
+    cwd = manifest.run.cwd if manifest.run else None
+    working_dir = cwd or project_name
+    return config.root / working_dir
+
+
+def _has_pyproject(project_dir: Path) -> bool:
+    """Check if a project directory has a pyproject.toml."""
+    return (project_dir / "pyproject.toml").exists()
+
+
+def _run_in_project(
+    project_dir: Path, cmd: list[str], label: str
+) -> bool:
+    """Run a command in a project directory. Returns True on success."""
+    if not _has_pyproject(project_dir):
+        return True  # Skip projects without pyproject.toml
+
+    print(f"\n{'─' * 40}")
+    print(f"  {label}: {project_dir.name}")
+    print(f"{'─' * 40}")
+
+    result = subprocess.run(cmd, cwd=project_dir)
+    return result.returncode == 0
+
+
+def run_test(args: argparse.Namespace) -> int:
+    """Run tests for one or all projects."""
+    config = load_config()
+
+    if args.project:
+        project_dir = _get_project_dir(config, args.project)
+        tests_dir = project_dir / "tests"
+        if not tests_dir.exists():
+            print(f"No tests directory found for {args.project}")
+            return 1
+        success = _run_in_project(
+            project_dir,
+            ["uv", "run", "pytest", "tests/", "-v"],
+            "Testing",
+        )
+        return 0 if success else 1
+
+    # Run all
+    all_passed = True
+    for name, manifest in config.components.items():
+        cwd = manifest.run.cwd if manifest.run else None
+        working_dir = cwd or name
+        project_dir = config.root / working_dir
+        tests_dir = project_dir / "tests"
+        if not tests_dir.exists():
+            continue
+        if not _has_pyproject(project_dir):
+            continue
+        success = _run_in_project(
+            project_dir,
+            ["uv", "run", "pytest", "tests/", "-v"],
+            "Testing",
+        )
+        if not success:
+            all_passed = False
+
+    if all_passed:
+        print("\nAll tests passed.")
+    else:
+        print("\nSome tests failed.")
+    return 0 if all_passed else 1
+
+
+def run_lint(args: argparse.Namespace) -> int:
+    """Run linter for one or all projects."""
+    config = load_config()
+
+    if args.project:
+        project_dir = _get_project_dir(config, args.project)
+        success = _run_in_project(
+            project_dir,
+            ["uv", "run", "ruff", "check", "."],
+            "Linting",
+        )
+        return 0 if success else 1
+
+    # Run all
+    all_passed = True
+    for name, manifest in config.components.items():
+        cwd = manifest.run.cwd if manifest.run else None
+        working_dir = cwd or name
+        project_dir = config.root / working_dir
+        if not _has_pyproject(project_dir):
+            continue
+        success = _run_in_project(
+            project_dir,
+            ["uv", "run", "ruff", "check", "."],
+            "Linting",
+        )
+        if not success:
+            all_passed = False
+
+    if all_passed:
+        print("\nAll lint checks passed.")
+    else:
+        print("\nSome lint checks failed.")
+    return 0 if all_passed else 1

cli/src/castle_cli/commands/gateway.py

@@ -0,0 +1,186 @@
+"""castle gateway - manage the Caddy reverse proxy gateway."""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import subprocess
+
+from castle_cli.config import GENERATED_DIR, CastleConfig, ensure_dirs, load_config
+
+
+def _find_dashboard_dist(config: CastleConfig) -> str | None:
+    """Find the dashboard dist/ directory if it exists."""
+    dist = config.root / "dashboard" / "dist"
+    if dist.exists() and (dist / "index.html").exists():
+        return str(dist)
+    return None
+
+
+def _generate_caddyfile(config: CastleConfig) -> str:
+    """Generate Caddyfile content from castle config."""
+    lines = [f":{config.gateway.port} {{"]
+
+    # Reverse proxy for each component with proxy.caddy and expose.http
+    for name, manifest in config.components.items():
+        if not (manifest.proxy and manifest.proxy.caddy and manifest.proxy.caddy.enable):
+            continue
+        if not (manifest.expose and manifest.expose.http):
+            continue
+
+        caddy = manifest.proxy.caddy
+        http = manifest.expose.http
+        path_prefix = caddy.path_prefix or f"/{name}"
+        port = http.internal.port
+        host = http.internal.host or "localhost"
+
+        lines.append(f"    handle_path {path_prefix}/* {{")
+        lines.append(f"        reverse_proxy {host}:{port}")
+        lines.append("    }")
+        lines.append("")
+
+    # Dashboard SPA at root (must come after more-specific handle_path rules)
+    dashboard_dist = _find_dashboard_dist(config)
+    if dashboard_dist:
+        lines.append("    handle {")
+        lines.append(f"        root * {dashboard_dist}")
+        lines.append("        try_files {path} /index.html")
+        lines.append("        file_server")
+        lines.append("    }")
+    else:
+        # Fallback: serve from generated directory
+        fallback = GENERATED_DIR / "dashboard"
+        lines.append("    handle / {")
+        lines.append(f"        root * {fallback}")
+        lines.append("        file_server")
+        lines.append("    }")
+
+    lines.append("}")
+    return "\n".join(lines)
+
+
+def _write_generated_files(config: CastleConfig) -> None:
+    """Write generated Caddyfile."""
+    ensure_dirs()
+
+    caddyfile_path = GENERATED_DIR / "Caddyfile"
+    caddyfile_path.write_text(_generate_caddyfile(config))
+    print(f"  Generated {caddyfile_path}")
+
+    dashboard_dist = _find_dashboard_dist(config)
+    if dashboard_dist:
+        print(f"  Dashboard: {dashboard_dist}")
+    else:
+        print("  Dashboard: dist/ not found, using fallback")
+
+
+def run_gateway(args: argparse.Namespace) -> int:
+    """Manage the Caddy gateway."""
+    if not args.gateway_command:
+        print("Usage: castle gateway {start|stop|reload|status}")
+        return 1
+
+    config = load_config()
+
+    if args.gateway_command in ("start", "reload") and getattr(args, "dry_run", False):
+        return _gateway_dry_run(config)
+
+    if args.gateway_command == "start":
+        return _gateway_start(config)
+    elif args.gateway_command == "stop":
+        return _gateway_stop()
+    elif args.gateway_command == "reload":
+        return _gateway_reload(config)
+    elif args.gateway_command == "status":
+        return _gateway_status()
+
+    return 1
+
+
+def _gateway_dry_run(config: CastleConfig) -> int:
+    """Print generated Caddyfile and gateway unit without applying."""
+    from castle_cli.commands.service import _generate_gateway_unit
+
+    print("# Caddyfile")
+    print(_generate_caddyfile(config))
+    print()
+    print("# castle-gateway.service")
+    print(_generate_gateway_unit(config))
+    return 0
+
+
+def _gateway_start(config: CastleConfig) -> int:
+    """Generate config and start Caddy."""
+    if not shutil.which("caddy"):
+        print("Error: caddy is not installed.")
+        print("Install with: sudo apt install caddy")
+        return 1
+
+    print("Generating gateway configuration...")
+    _write_generated_files(config)
+
+    caddyfile = GENERATED_DIR / "Caddyfile"
+    print(f"\nStarting Caddy on port {config.gateway.port}...")
+
+    result = subprocess.run(
+        ["caddy", "start", "--config", str(caddyfile), "--adapter", "caddyfile"],
+    )
+
+    if result.returncode == 0:
+        print(f"Gateway running at http://localhost:{config.gateway.port}")
+    else:
+        print("Failed to start gateway.")
+
+    return result.returncode
+
+
+def _gateway_stop() -> int:
+    """Stop Caddy."""
+    if not shutil.which("caddy"):
+        print("Error: caddy is not installed.")
+        return 1
+
+    result = subprocess.run(["caddy", "stop"])
+    if result.returncode == 0:
+        print("Gateway stopped.")
+    return result.returncode
+
+
+def _gateway_reload(config: CastleConfig) -> int:
+    """Regenerate config and reload Caddy."""
+    print("Regenerating gateway configuration...")
+    _write_generated_files(config)
+
+    caddyfile = GENERATED_DIR / "Caddyfile"
+    result = subprocess.run(
+        ["caddy", "reload", "--config", str(caddyfile), "--adapter", "caddyfile"],
+    )
+
+    if result.returncode == 0:
+        print("Gateway reloaded.")
+    else:
+        print("Failed to reload gateway. Is it running?")
+
+    return result.returncode
+
+
+def _gateway_status() -> int:
+    """Show gateway status."""
+    if not shutil.which("caddy"):
+        print("Gateway: not installed")
+        return 1
+
+    result = subprocess.run(
+        ["pgrep", "-x", "caddy"],
+        capture_output=True,
+    )
+
+    if result.returncode == 0:
+        print("Gateway: running")
+        caddyfile = GENERATED_DIR / "Caddyfile"
+        if caddyfile.exists():
+            print(f"  Config: {caddyfile}")
+    else:
+        print("Gateway: stopped")
+
+    return 0

cli/src/castle_cli/commands/info.py

@@ -0,0 +1,116 @@
+"""castle info - show detailed component information."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from castle_cli.config import load_config
+
+# Terminal colors
+BOLD = "\033[1m"
+RESET = "\033[0m"
+CYAN = "\033[96m"
+DIM = "\033[2m"
+
+
+def run_info(args: argparse.Namespace) -> int:
+    """Show detailed info for a component."""
+    config = load_config()
+    name = args.project
+
+    if name not in config.components:
+        print(f"Error: component '{name}' not found in castle.yaml")
+        return 1
+
+    manifest = config.components[name]
+
+    if getattr(args, "json", False):
+        data = manifest.model_dump(exclude_none=True)
+        # Include CLAUDE.md content if it exists
+        cwd = manifest.run.cwd if manifest.run else None
+        claude_md = _find_claude_md(config.root, cwd or name)
+        if claude_md:
+            data["claude_md"] = claude_md
+        print(json.dumps(data, indent=2))
+        return 0
+
+    # Human-readable output
+    print(f"\n{BOLD}{name}{RESET}")
+    print(f"{'─' * 40}")
+    print(f"  {BOLD}roles{RESET}:       {', '.join(r.value for r in manifest.roles)}")
+    if manifest.description:
+        print(f"  {BOLD}description{RESET}: {manifest.description}")
+
+    # Run spec
+    if manifest.run:
+        print(f"  {BOLD}runner{RESET}:      {manifest.run.runner}")
+        if manifest.run.cwd:
+            print(f"  {BOLD}cwd{RESET}:         {manifest.run.cwd}")
+        if hasattr(manifest.run, "tool"):
+            print(f"  {BOLD}tool{RESET}:        {manifest.run.tool}")
+        elif hasattr(manifest.run, "argv"):
+            print(f"  {BOLD}argv{RESET}:        {manifest.run.argv}")
+        elif hasattr(manifest.run, "image"):
+            print(f"  {BOLD}image{RESET}:       {manifest.run.image}")
+        if manifest.run.env:
+            print(f"  {BOLD}env{RESET}:")
+            for key, val in manifest.run.env.items():
+                print(f"    {key}: {val}")
+
+    # Expose
+    if manifest.expose and manifest.expose.http:
+        http = manifest.expose.http
+        print(f"  {BOLD}port{RESET}:        {http.internal.port}")
+        if http.health_path:
+            print(f"  {BOLD}health{RESET}:      {http.health_path}")
+
+    # Proxy
+    if manifest.proxy and manifest.proxy.caddy:
+        caddy = manifest.proxy.caddy
+        if caddy.path_prefix:
+            print(f"  {BOLD}path{RESET}:        {caddy.path_prefix}")
+
+    # Manage
+    if manifest.manage and manifest.manage.systemd:
+        sd = manifest.manage.systemd
+        print(f"  {BOLD}systemd{RESET}:     enabled={sd.enable}, restart={sd.restart.value}")
+
+    # Install
+    if manifest.install and manifest.install.path:
+        pi = manifest.install.path
+        print(f"  {BOLD}install{RESET}:     path" + (f" (alias: {pi.alias})" if pi.alias else ""))
+
+    # Tags
+    if manifest.tags:
+        print(f"  {BOLD}tags{RESET}:        {', '.join(manifest.tags)}")
+
+    # Capabilities
+    if manifest.provides:
+        print(f"  {BOLD}provides{RESET}:")
+        for cap in manifest.provides:
+            print(f"    - {cap.type}" + (f" ({cap.name})" if cap.name else ""))
+    if manifest.consumes:
+        print(f"  {BOLD}consumes{RESET}:")
+        for cap in manifest.consumes:
+            print(f"    - {cap.type}" + (f" ({cap.name})" if cap.name else ""))
+
+    # Show CLAUDE.md if it exists
+    cwd = manifest.run.cwd if manifest.run else None
+    claude_md = _find_claude_md(config.root, cwd or name)
+    if claude_md:
+        print(f"\n{BOLD}{CYAN}CLAUDE.md{RESET}")
+        print(f"{CYAN}{'─' * 40}{RESET}")
+        print(f"{DIM}{claude_md}{RESET}")
+
+    print()
+    return 0
+
+
+def _find_claude_md(root: Path, working_dir: str) -> str | None:
+    """Read CLAUDE.md from project directory if it exists."""
+    claude_path = root / working_dir / "CLAUDE.md"
+    if claude_path.exists():
+        return claude_path.read_text()
+    return None

cli/src/castle_cli/commands/list_cmd.py

@@ -0,0 +1,81 @@
+"""castle list - show all registered components."""
+
+from __future__ import annotations
+
+import argparse
+import json
+
+from castle_cli.config import load_config
+from castle_cli.manifest import Role
+
+# Terminal colors
+BOLD = "\033[1m"
+RESET = "\033[0m"
+DIM = "\033[2m"
+
+ROLE_COLORS: dict[str, str] = {
+    Role.SERVICE: "\033[92m",  # green
+    Role.TOOL: "\033[96m",  # cyan
+    Role.WORKER: "\033[94m",  # blue
+    Role.JOB: "\033[95m",  # magenta
+    Role.FRONTEND: "\033[93m",  # yellow
+    Role.REMOTE: "\033[90m",  # dim
+    Role.CONTAINERIZED: "\033[33m",  # orange
+}
+
+
+def run_list(args: argparse.Namespace) -> int:
+    """List all components."""
+    config = load_config()
+
+    components = config.components
+
+    filter_role = getattr(args, "role", None)
+    if filter_role:
+        components = {
+            k: v for k, v in components.items() if filter_role in v.roles
+        }
+
+    if getattr(args, "json", False):
+        output = []
+        for name, manifest in components.items():
+            entry: dict = {
+                "name": name,
+                "roles": [r.value for r in manifest.roles],
+            }
+            if manifest.description:
+                entry["description"] = manifest.description
+            if manifest.expose and manifest.expose.http:
+                entry["port"] = manifest.expose.http.internal.port
+            output.append(entry)
+        print(json.dumps(output, indent=2))
+        return 0
+
+    if not components:
+        print("No components found.")
+        return 0
+
+    # Group by primary role (first in sorted list)
+    by_role: dict[str, list[tuple[str, object]]] = {}
+    for name, manifest in components.items():
+        primary_role = manifest.roles[0].value if manifest.roles else "other"
+        by_role.setdefault(primary_role, []).append((name, manifest))
+
+    # Display order
+    role_order = ["service", "tool", "worker", "job", "frontend", "remote", "containerized"]
+    for role_name in role_order:
+        items = by_role.get(role_name, [])
+        if not items:
+            continue
+        color = ROLE_COLORS.get(role_name, "")
+        print(f"\n{BOLD}{color}{role_name}s{RESET}")
+        print(f"{color}{'─' * 40}{RESET}")
+        for name, manifest in items:
+            port_str = ""
+            if manifest.expose and manifest.expose.http:
+                port_str = f"  :{manifest.expose.http.internal.port}"
+            desc = f"  {DIM}{manifest.description}{RESET}" if manifest.description else ""
+            print(f"  {BOLD}{name}{RESET}{port_str}{desc}")
+
+    print()
+    return 0

cli/src/castle_cli/commands/logs.py

@@ -0,0 +1,69 @@
+"""castle logs - view component logs."""
+
+from __future__ import annotations
+
+import argparse
+import subprocess
+
+from castle_cli.commands.service import UNIT_PREFIX
+from castle_cli.config import load_config
+
+
+def run_logs(args: argparse.Namespace) -> int:
+    """View logs for a component."""
+    config = load_config()
+    name = args.name
+
+    if name not in config.components:
+        print(f"Error: component '{name}' not found in castle.yaml")
+        return 1
+
+    manifest = config.components[name]
+
+    # Container logs
+    if manifest.run and manifest.run.runner == "container":
+        return _container_logs(name, args)
+
+    # Systemd logs (default for managed services)
+    if manifest.manage and manifest.manage.systemd:
+        return _systemd_logs(name, args)
+
+    print(f"Error: '{name}' has no log source (not systemd-managed or containerized)")
+    return 1
+
+
+def _systemd_logs(name: str, args: argparse.Namespace) -> int:
+    """Show journalctl logs for a systemd service."""
+    unit_name = f"{UNIT_PREFIX}{name}.service"
+    cmd = ["journalctl", "--user", "-u", unit_name]
+
+    lines = getattr(args, "lines", 50)
+    if lines:
+        cmd.extend(["-n", str(lines)])
+
+    if getattr(args, "follow", False):
+        cmd.append("-f")
+
+    result = subprocess.run(cmd)
+    return result.returncode
+
+
+def _container_logs(name: str, args: argparse.Namespace) -> int:
+    """Show container logs."""
+    import shutil
+
+    runtime = shutil.which("podman") or shutil.which("docker") or "podman"
+    container_name = f"castle-{name}"
+    cmd = [runtime, "logs"]
+
+    lines = getattr(args, "lines", 50)
+    if lines:
+        cmd.extend(["--tail", str(lines)])
+
+    if getattr(args, "follow", False):
+        cmd.append("-f")
+
+    cmd.append(container_name)
+
+    result = subprocess.run(cmd)
+    return result.returncode

cli/src/castle_cli/commands/run_cmd.py

@@ -0,0 +1,96 @@
+"""castle run - run a component in the foreground."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+import subprocess
+import sys
+
+from castle_cli.config import load_config, resolve_env_vars
+
+
+def run_run(args: argparse.Namespace) -> int:
+    """Run a component in the foreground (dev mode)."""
+    config = load_config()
+    name = args.name
+
+    if name not in config.components:
+        print(f"Error: component '{name}' not found in castle.yaml")
+        return 1
+
+    manifest = config.components[name]
+    run = manifest.run
+
+    if run is None:
+        print(f"Error: component '{name}' has no run spec")
+        return 1
+
+    # Build command
+    extra_args = getattr(args, "extra", []) or []
+    cmd = _build_command(run, extra_args)
+    if cmd is None:
+        print(f"Error: unsupported runner '{run.runner}' for foreground execution")
+        return 1
+
+    # Working directory
+    cwd = config.root / (run.cwd or name)
+    if not cwd.exists():
+        print(f"Error: working directory '{cwd}' does not exist")
+        return 1
+
+    # Merge environment
+    env = dict(os.environ)
+    resolved = resolve_env_vars(run.env, manifest)
+    env.update(resolved)
+
+    # Run in foreground
+    result = subprocess.run(cmd, cwd=cwd, env=env)
+    return result.returncode
+
+
+def _build_command(run: object, extra_args: list[str]) -> list[str] | None:
+    """Build command list from RunSpec."""
+    match run.runner:
+        case "python_uv_tool":
+            uv = shutil.which("uv") or "uv"
+            cmd = [uv, "run", run.tool]
+            cmd.extend(run.args)
+            cmd.extend(extra_args)
+            return cmd
+        case "python_module":
+            python = run.python or sys.executable
+            cmd = [python, "-m", run.module]
+            cmd.extend(run.args)
+            cmd.extend(extra_args)
+            return cmd
+        case "command":
+            cmd = list(run.argv)
+            cmd.extend(extra_args)
+            return cmd
+        case "container":
+            runtime = shutil.which("podman") or shutil.which("docker") or "podman"
+            cmd = [runtime, "run", "--rm", "-it"]
+            for cp, hp in run.ports.items():
+                cmd.extend(["-p", f"{hp}:{cp}"])
+            for vol in run.volumes:
+                cmd.extend(["-v", vol])
+            for key, val in run.env.items():
+                cmd.extend(["-e", f"{key}={val}"])
+            if run.workdir:
+                cmd.extend(["-w", run.workdir])
+            cmd.append(run.image)
+            if run.command:
+                cmd.extend(run.command)
+            cmd.extend(run.args)
+            cmd.extend(extra_args)
+            return cmd
+        case "node":
+            pm = run.package_manager
+            cmd = [pm, "run", run.script]
+            cmd.extend(run.args)
+            cmd.extend(extra_args)
+            return cmd
+        case _:
+            return None

cli/src/castle_cli/commands/service.py

@@ -0,0 +1,517 @@
+"""castle service / castle services - manage systemd service units."""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import subprocess
+from pathlib import Path
+
+from castle_cli.config import (
+    GENERATED_DIR,
+    CastleConfig,
+    ensure_dirs,
+    load_config,
+    resolve_env_vars,
+)
+from castle_cli.manifest import ComponentManifest, RestartPolicy
+
+SYSTEMD_USER_DIR = Path.home() / ".config" / "systemd" / "user"
+UNIT_PREFIX = "castle-"
+
+
+def _unit_name(service_name: str) -> str:
+    """Get the systemd unit name for a service."""
+    return f"{UNIT_PREFIX}{service_name}.service"
+
+
+def _timer_name(service_name: str) -> str:
+    """Get the systemd timer name for a scheduled service."""
+    return f"{UNIT_PREFIX}{service_name}.timer"
+
+
+def _get_schedule_trigger(manifest: ComponentManifest) -> object | None:
+    """Return the schedule trigger if one exists, else None."""
+    for t in manifest.triggers:
+        if getattr(t, "type", None) == "schedule":
+            return t
+    return None
+
+
+def _cron_to_oncalendar(cron: str) -> str:
+    """Best-effort conversion of cron expression to systemd OnCalendar.
+
+    Handles common patterns; falls back to using OnUnitActiveSec for the rest.
+    """
+    parts = cron.strip().split()
+    if len(parts) != 5:
+        return ""
+
+    minute, hour, dom, month, dow = parts
+
+    # */N minutes → run every N minutes
+    if minute.startswith("*/") and hour == "*" and dom == "*" and month == "*" and dow == "*":
+        return ""  # Use OnUnitActiveSec instead
+
+    # Specific time daily: "0 2 * * *" → "*-*-* 02:00:00"
+    if dom == "*" and month == "*" and dow == "*":
+        h = hour.zfill(2) if hour != "*" else "*"
+        m = minute.zfill(2) if minute != "*" else "*"
+        return f"*-*-* {h}:{m}:00"
+
+    return ""
+
+
+def _cron_to_interval_sec(cron: str) -> int | None:
+    """Extract interval seconds from */N cron patterns."""
+    parts = cron.strip().split()
+    if len(parts) != 5:
+        return None
+    minute, hour, dom, month, dow = parts
+    if minute.startswith("*/") and hour == "*" and dom == "*" and month == "*" and dow == "*":
+        try:
+            return int(minute[2:]) * 60
+        except ValueError:
+            return None
+    return None
+
+
+def _manifest_to_exec_start(manifest: ComponentManifest, root: Path) -> str:
+    """Convert a manifest's RunSpec to a systemd ExecStart command."""
+    run = manifest.run
+    if run is None:
+        raise ValueError(f"Component '{manifest.id}' has no run spec")
+
+    match run.runner:
+        case "python_uv_tool":
+            uv_path = shutil.which("uv") or "uv"
+            args_str = " ".join(run.args) if run.args else ""
+            cmd = f"{uv_path} run {run.tool}"
+            if args_str:
+                cmd += f" {args_str}"
+            return cmd
+        case "python_module":
+            python = run.python or shutil.which("python3") or "python3"
+            args_str = " ".join(run.args) if run.args else ""
+            cmd = f"{python} -m {run.module}"
+            if args_str:
+                cmd += f" {args_str}"
+            return cmd
+        case "command":
+            argv = list(run.argv)
+            resolved = shutil.which(argv[0])
+            if resolved:
+                argv[0] = resolved
+            return " ".join(argv)
+        case "container":
+            return _build_podman_command(manifest)
+        case "node":
+            pm = run.package_manager
+            cmd = f"{pm} run {run.script}"
+            if run.args:
+                cmd += " " + " ".join(run.args)
+            return cmd
+        case _:
+            raise ValueError(f"Unsupported runner '{run.runner}' for systemd unit")
+
+
+def _build_podman_command(manifest: ComponentManifest) -> str:
+    """Build a podman/docker run command from a container RunSpec."""
+    run = manifest.run
+    podman = shutil.which("podman") or shutil.which("docker") or "podman"
+    parts = [podman, "run", "--rm", f"--name=castle-{manifest.id}"]
+
+    for container_port, host_port in run.ports.items():
+        parts.append(f"-p {host_port}:{container_port}")
+    for vol in run.volumes:
+        parts.append(f"-v {vol}")
+    for key, val in run.env.items():
+        parts.append(f"-e {key}={val}")
+    if run.workdir:
+        parts.append(f"-w {run.workdir}")
+
+    parts.append(run.image)
+    if run.command:
+        parts.extend(run.command)
+    if run.args:
+        parts.extend(run.args)
+
+    return " ".join(parts)
+
+
+def _generate_unit(config: CastleConfig, name: str, manifest: ComponentManifest) -> str:
+    """Generate a systemd user unit file for a component."""
+    run = manifest.run
+    if run is None:
+        raise ValueError(f"Component '{name}' has no run spec")
+
+    working_dir = config.root / (run.cwd or name)
+    exec_start = _manifest_to_exec_start(manifest, config.root)
+
+    resolved_env = resolve_env_vars(run.env, manifest)
+    env_lines = ""
+    for key, value in resolved_env.items():
+        env_lines += f"Environment={key}={value}\n"
+
+    # Add PATH so tools are findable
+    env_lines += f'Environment="PATH={Path.home() / ".local/bin"}:/usr/local/bin:/usr/bin:/bin"\n'
+
+    sd = None
+    if manifest.manage and manifest.manage.systemd:
+        sd = manifest.manage.systemd
+
+    description = (sd and sd.description) or manifest.description or name
+    after = " ".join(sd.after) if sd and sd.after else "network.target"
+    wanted_by = " ".join(sd.wanted_by) if sd else "default.target"
+
+    is_scheduled = _get_schedule_trigger(manifest) is not None
+
+    if is_scheduled:
+        # Oneshot service for timer-driven jobs
+        unit = f"""[Unit]
+Description=Castle: {description}
+After={after}
+
+[Service]
+Type=oneshot
+WorkingDirectory={working_dir}
+ExecStart={exec_start}
+{env_lines}"""
+    else:
+        restart = (sd.restart if sd else RestartPolicy.ON_FAILURE).value
+        restart_sec = sd.restart_sec if sd else 5
+        unit = f"""[Unit]
+Description=Castle: {description}
+After={after}
+
+[Service]
+Type=simple
+WorkingDirectory={working_dir}
+ExecStart={exec_start}
+{env_lines}Restart={restart}
+RestartSec={restart_sec}
+"""
+
+    if sd and sd.no_new_privileges:
+        unit += "NoNewPrivileges=true\n"
+
+    unit += f"""
+[Install]
+WantedBy={wanted_by}
+"""
+    return unit
+
+
+def _generate_timer(name: str, manifest: ComponentManifest) -> str | None:
+    """Generate a systemd timer unit if the component has a schedule trigger."""
+    trigger = _get_schedule_trigger(manifest)
+    if trigger is None:
+        return None
+
+    description = manifest.description or name
+
+    # Try to convert cron to OnCalendar, fall back to OnUnitActiveSec
+    on_calendar = _cron_to_oncalendar(trigger.cron)
+    interval_sec = _cron_to_interval_sec(trigger.cron)
+
+    timer_lines = ""
+    if on_calendar:
+        timer_lines = f"OnCalendar={on_calendar}\n"
+    elif interval_sec:
+        timer_lines = f"OnBootSec=60\nOnUnitActiveSec={interval_sec}s\n"
+    else:
+        timer_lines = "OnBootSec=60\nOnUnitActiveSec=300\n"
+
+    return f"""[Unit]
+Description=Castle timer: {description}
+
+[Timer]
+{timer_lines}Persistent=false
+
+[Install]
+WantedBy=timers.target
+"""
+
+
+def _generate_gateway_unit(config: CastleConfig) -> str:
+    """Generate a systemd unit for the Caddy gateway."""
+    caddy_path = shutil.which("caddy") or "caddy"
+    caddyfile = GENERATED_DIR / "Caddyfile"
+
+    return f"""[Unit]
+Description=Castle Gateway (Caddy)
+After=network.target
+
+[Service]
+Type=simple
+ExecStart={caddy_path} run --config {caddyfile} --adapter caddyfile
+ExecReload={caddy_path} reload --config {caddyfile} --adapter caddyfile
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=default.target
+"""
+
+
+def _install_unit(unit_name: str, content: str) -> None:
+    """Write a systemd unit file."""
+    SYSTEMD_USER_DIR.mkdir(parents=True, exist_ok=True)
+    unit_path = SYSTEMD_USER_DIR / unit_name
+    unit_path.write_text(content)
+    subprocess.run(["systemctl", "--user", "daemon-reload"], check=False)
+
+
+def _remove_unit(unit_name: str) -> None:
+    """Remove a systemd unit file."""
+    unit_path = SYSTEMD_USER_DIR / unit_name
+    if unit_path.exists():
+        unit_path.unlink()
+        subprocess.run(["systemctl", "--user", "daemon-reload"], check=False)
+
+
+def run_service(args: argparse.Namespace) -> int:
+    """Manage individual services."""
+    if not args.service_command:
+        print("Usage: castle service {enable|disable|status}")
+        return 1
+
+    config = load_config()
+
+    if args.service_command == "enable":
+        if getattr(args, "dry_run", False):
+            return _service_dry_run(config, args.name)
+        return _service_enable(config, args.name)
+    elif args.service_command == "disable":
+        return _service_disable(args.name)
+    elif args.service_command == "status":
+        return _service_status(config)
+
+    return 1
+
+
+def run_services(args: argparse.Namespace) -> int:
+    """Manage all services together."""
+    if not args.services_command:
+        print("Usage: castle services {start|stop}")
+        return 1
+
+    config = load_config()
+
+    if args.services_command == "start":
+        return _services_start(config)
+    elif args.services_command == "stop":
+        return _services_stop(config)
+
+    return 1
+
+
+def _service_enable(config: CastleConfig, name: str) -> int:
+    """Enable and start a single service (or timer for scheduled jobs)."""
+    managed = config.managed
+    if name not in managed:
+        print(f"Error: '{name}' is not a managed service")
+        return 1
+
+    manifest = managed[name]
+    if not manifest.run:
+        print(f"Error: '{name}' has no run spec defined")
+        return 1
+
+    ensure_dirs()
+
+    # Generate and install the service unit
+    svc_unit = _unit_name(name)
+    svc_content = _generate_unit(config, name, manifest)
+    _install_unit(svc_unit, svc_content)
+
+    # Check for timer
+    timer_content = _generate_timer(name, manifest)
+    if timer_content:
+        timer_unit = _timer_name(name)
+        _install_unit(timer_unit, timer_content)
+
+        print(f"Enabling {name} (scheduled)...")
+        subprocess.run(["systemctl", "--user", "enable", timer_unit], check=False)
+        subprocess.run(["systemctl", "--user", "start", timer_unit], check=False)
+
+        result = subprocess.run(
+            ["systemctl", "--user", "is-active", timer_unit],
+            capture_output=True, text=True,
+        )
+        status = result.stdout.strip()
+        if status in ("active", "waiting"):
+            print(f"  {name}: timer active")
+        else:
+            print(f"  {name}: timer {status}")
+    else:
+        print(f"Enabling {name}...")
+        subprocess.run(["systemctl", "--user", "enable", svc_unit], check=False)
+        subprocess.run(["systemctl", "--user", "start", svc_unit], check=False)
+
+        result = subprocess.run(
+            ["systemctl", "--user", "is-active", svc_unit],
+            capture_output=True, text=True,
+        )
+        status = result.stdout.strip()
+        port_str = ""
+        if manifest.expose and manifest.expose.http:
+            port_str = f" (port {manifest.expose.http.internal.port})"
+        if status == "active":
+            print(f"  {name}: running{port_str}")
+        else:
+            print(f"  {name}: {status}")
+            print(f"  Check logs: journalctl --user -u {svc_unit}")
+
+    return 0
+
+
+def _service_disable(name: str) -> int:
+    """Stop and disable a service (and timer if present)."""
+    svc_unit = _unit_name(name)
+    timer_unit = _timer_name(name)
+
+    print(f"Disabling {name}...")
+
+    # Stop and disable timer if exists
+    timer_path = SYSTEMD_USER_DIR / timer_unit
+    if timer_path.exists():
+        subprocess.run(["systemctl", "--user", "stop", timer_unit], check=False)
+        subprocess.run(["systemctl", "--user", "disable", timer_unit], check=False)
+        _remove_unit(timer_unit)
+
+    subprocess.run(["systemctl", "--user", "stop", svc_unit], check=False)
+    subprocess.run(["systemctl", "--user", "disable", svc_unit], check=False)
+    _remove_unit(svc_unit)
+    print(f"  {name}: disabled")
+
+    return 0
+
+
+def _service_status(config: CastleConfig) -> int:
+    """Show status of all managed services."""
+    print("\nCastle Services")
+    print("=" * 50)
+
+    for name, manifest in config.managed.items():
+        is_scheduled = _get_schedule_trigger(manifest) is not None
+
+        if is_scheduled:
+            timer_unit = _timer_name(name)
+            result = subprocess.run(
+                ["systemctl", "--user", "is-active", timer_unit],
+                capture_output=True, text=True,
+            )
+            status = result.stdout.strip()
+            if status in ("active", "waiting"):
+                color = "\033[92m"
+            elif status == "inactive":
+                color = "\033[90m"
+            else:
+                color = "\033[91m"
+            reset = "\033[0m"
+            print(f"  {color}{status:10s}{reset}  {name} (timer)")
+        else:
+            unit_name = _unit_name(name)
+            result = subprocess.run(
+                ["systemctl", "--user", "is-active", unit_name],
+                capture_output=True, text=True,
+            )
+            status = result.stdout.strip()
+            if status == "active":
+                color = "\033[92m"
+            elif status == "inactive":
+                color = "\033[90m"
+            else:
+                color = "\033[91m"
+            reset = "\033[0m"
+
+            port_str = ""
+            if manifest.expose and manifest.expose.http:
+                port_str = f":{manifest.expose.http.internal.port}"
+            print(f"  {color}{status:10s}{reset}  {name}{port_str}")
+
+    # Gateway status
+    gw_unit = f"{UNIT_PREFIX}gateway.service"
+    result = subprocess.run(
+        ["systemctl", "--user", "is-active", gw_unit],
+        capture_output=True, text=True,
+    )
+    gw_status = result.stdout.strip()
+    color = "\033[92m" if gw_status == "active" else "\033[90m"
+    reset = "\033[0m"
+    print(f"  {color}{gw_status:10s}{reset}  gateway :{config.gateway.port}")
+
+    print()
+    return 0
+
+
+def _service_dry_run(config: CastleConfig, name: str) -> int:
+    """Print the generated systemd unit(s) without installing."""
+    managed = config.managed
+    if name not in managed:
+        print(f"Error: '{name}' is not a managed service")
+        return 1
+
+    manifest = managed[name]
+    if not manifest.run:
+        print(f"Error: '{name}' has no run spec defined")
+        return 1
+
+    svc_unit = _unit_name(name)
+    svc_content = _generate_unit(config, name, manifest)
+    print(f"# {svc_unit}")
+    print(svc_content)
+
+    timer_content = _generate_timer(name, manifest)
+    if timer_content:
+        print(f"# {_timer_name(name)}")
+        print(timer_content)
+
+    return 0
+
+
+def _services_start(config: CastleConfig) -> int:
+    """Start all managed services and gateway."""
+    ensure_dirs()
+
+    from castle_cli.commands.gateway import _write_generated_files
+
+    print("Generating gateway configuration...")
+    _write_generated_files(config)
+
+    if shutil.which("caddy"):
+        gw_unit_name = f"{UNIT_PREFIX}gateway.service"
+        gw_content = _generate_gateway_unit(config)
+        _install_unit(gw_unit_name, gw_content)
+        subprocess.run(["systemctl", "--user", "enable", gw_unit_name], check=False)
+        subprocess.run(["systemctl", "--user", "start", gw_unit_name], check=False)
+        print(f"Gateway: started on port {config.gateway.port}")
+    else:
+        print("Warning: caddy not installed, skipping gateway")
+
+    for name, manifest in config.managed.items():
+        if not manifest.run:
+            continue
+        _service_enable(config, name)
+
+    print(f"\nDashboard: http://localhost:{config.gateway.port}")
+    return 0
+
+
+def _services_stop(config: CastleConfig) -> int:
+    """Stop all managed services and gateway."""
+    for name, manifest in config.managed.items():
+        is_scheduled = _get_schedule_trigger(manifest) is not None
+        if is_scheduled:
+            timer_unit = _timer_name(name)
+            subprocess.run(["systemctl", "--user", "stop", timer_unit], check=False)
+        unit_name = _unit_name(name)
+        subprocess.run(["systemctl", "--user", "stop", unit_name], check=False)
+        print(f"  {name}: stopped")
+
+    gw_unit = f"{UNIT_PREFIX}gateway.service"
+    subprocess.run(["systemctl", "--user", "stop", gw_unit], check=False)
+    print("  gateway: stopped")
+
+    return 0

cli/src/castle_cli/commands/sync.py

@@ -0,0 +1,103 @@
+"""castle sync - sync submodules and install dependencies."""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import subprocess
+from pathlib import Path
+
+from castle_cli.config import ensure_dirs, load_config
+from castle_cli.manifest import ToolType
+
+
+def run_sync(args: argparse.Namespace) -> int:
+    """Sync submodules and install dependencies in all projects."""
+    config = load_config()
+    ensure_dirs()
+
+    # Update git submodules
+    print("Updating git submodules...")
+    result = subprocess.run(
+        ["git", "submodule", "update", "--init", "--recursive"],
+        cwd=config.root,
+    )
+    if result.returncode != 0:
+        print("Warning: git submodule update failed (may not be a git repo)")
+
+    # Run uv sync in each project that has a pyproject.toml
+    all_ok = True
+    synced_dirs: set[Path] = set()
+    for name, manifest in config.components.items():
+        cwd = manifest.run.cwd if manifest.run else None
+        working_dir = cwd or name
+        project_dir = config.root / working_dir
+        pyproject = project_dir / "pyproject.toml"
+
+        if not pyproject.exists() or project_dir in synced_dirs:
+            continue
+
+        print(f"\nSyncing {name}...")
+        result = subprocess.run(["uv", "sync"], cwd=project_dir)
+        if result.returncode != 0:
+            print(f"  Warning: uv sync failed for {name}")
+            all_ok = False
+        else:
+            print("  OK")
+        synced_dirs.add(project_dir)
+
+    # Install tools by type
+    uv_path = shutil.which("uv") or "uv"
+    installed_dirs: set[Path] = set()
+
+    for name, manifest in config.components.items():
+        if not manifest.tool:
+            continue
+
+        if manifest.tool.tool_type == ToolType.PYTHON_STANDALONE:
+            source = manifest.tool.source
+            if not source:
+                continue
+            project_dir = config.root / source
+            if not (project_dir / "pyproject.toml").exists():
+                continue
+            if project_dir in installed_dirs:
+                continue
+            print(f"\nInstalling {name}...")
+            result = subprocess.run(
+                [uv_path, "tool", "install", "--editable", str(project_dir),
+                 "--force"],
+                capture_output=True, text=True,
+            )
+            if result.returncode != 0:
+                if "already installed" in result.stderr.lower():
+                    print(f"  {name}: already installed")
+                else:
+                    print(f"  Warning: {result.stderr.strip()}")
+                    all_ok = False
+            else:
+                print(f"  {name}: OK")
+            installed_dirs.add(project_dir)
+
+        elif manifest.tool.tool_type == ToolType.SCRIPT:
+            # Verify script tools are accessible
+            alias = name
+            if manifest.install and manifest.install.path and manifest.install.path.alias:
+                alias = manifest.install.path.alias
+            if not shutil.which(alias):
+                source = manifest.tool.source
+                if source:
+                    script_path = config.root / source
+                    if script_path.exists():
+                        link = Path.home() / ".local" / "bin" / alias
+                        link.parent.mkdir(parents=True, exist_ok=True)
+                        if not link.exists():
+                            link.symlink_to(script_path)
+                            print(f"\n  Linked {alias} → {script_path}")
+
+    if all_ok:
+        print("\nAll projects synced.")
+    else:
+        print("\nSync completed with warnings.")
+
+    return 0

cli/src/castle_cli/commands/tool.py

@@ -0,0 +1,123 @@
+"""castle tool - manage tools."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from castle_cli.config import load_config
+
+BOLD = "\033[1m"
+RESET = "\033[0m"
+DIM = "\033[2m"
+CYAN = "\033[96m"
+
+
+def run_tool(args: argparse.Namespace) -> int:
+    """Manage tools."""
+    if not args.tool_command:
+        print("Usage: castle tool {list|info}")
+        return 1
+
+    if args.tool_command == "list":
+        return _tool_list()
+    elif args.tool_command == "info":
+        return _tool_info(args.name)
+
+    return 1
+
+
+def _tool_list() -> int:
+    """List tools grouped by category."""
+    config = load_config()
+    tools = {k: v for k, v in config.components.items() if v.tool}
+
+    if not tools:
+        print("No tools registered.")
+        return 0
+
+    by_category: dict[str, list[tuple[str, object]]] = {}
+    for name, manifest in tools.items():
+        cat = manifest.tool.category or "uncategorized"
+        by_category.setdefault(cat, []).append((name, manifest))
+
+    for category in sorted(by_category):
+        items = by_category[category]
+        print(f"\n{BOLD}{CYAN}{category}{RESET}")
+        print(f"{CYAN}{'─' * 40}{RESET}")
+        for name, manifest in sorted(items):
+            tt = manifest.tool.tool_type.value
+            ver = manifest.tool.version
+            desc = manifest.description or ""
+            deps = ""
+            if manifest.tool.system_dependencies:
+                deps = f"  {DIM}[{', '.join(manifest.tool.system_dependencies)}]{RESET}"
+            print(f"  {BOLD}{name:<20}{RESET} {ver:<6} {tt:<20} {desc}{deps}")
+
+    print()
+    return 0
+
+
+def _tool_info(name: str) -> int:
+    """Show detailed info about a tool, including .md documentation."""
+    config = load_config()
+    if name not in config.components:
+        print(f"Error: '{name}' not found")
+        return 1
+
+    manifest = config.components[name]
+    if not manifest.tool:
+        print(f"Error: '{name}' is not a tool")
+        return 1
+
+    t = manifest.tool
+
+    print(f"\n{BOLD}{name}{RESET}")
+    print(f"{'─' * 40}")
+    if manifest.description:
+        print(f"  {manifest.description}")
+    print(f"  {BOLD}type{RESET}:     {t.tool_type.value}")
+    print(f"  {BOLD}category{RESET}: {t.category or 'uncategorized'}")
+    print(f"  {BOLD}version{RESET}:  {t.version}")
+    if t.source:
+        print(f"  {BOLD}source{RESET}:   {t.source}")
+    if t.entry_point:
+        print(f"  {BOLD}entry{RESET}:    {t.entry_point}")
+    if t.system_dependencies:
+        print(f"  {BOLD}requires{RESET}: {', '.join(t.system_dependencies)}")
+
+    # Read and display .md documentation if available
+    if t.source:
+        md_path = _find_md_for_tool(config.root, t.source, name, t.category)
+        if md_path and md_path.exists():
+            content = md_path.read_text()
+            # Strip YAML frontmatter
+            if content.startswith("---\n"):
+                end = content.find("\n---\n", 4)
+                if end != -1:
+                    content = content[end + 5:]
+            content = content.strip()
+            if content:
+                print(f"\n{BOLD}{CYAN}Documentation{RESET}")
+                print(f"{CYAN}{'─' * 40}{RESET}")
+                print(f"{DIM}{content}{RESET}")
+
+    print()
+    return 0
+
+
+def _find_md_for_tool(root: Path, source: str, tool_name: str, category: str | None = None) -> Path | None:
+    """Find the .md documentation file for a tool source path."""
+    source_path = root / source
+    if source_path.is_file():
+        md = source_path.with_suffix(".md")
+        if md.exists():
+            return md
+    elif source_path.is_dir():
+        # Directory source — look for src/<category>/<tool_name>.md
+        py_name = tool_name.replace("-", "_")
+        if category:
+            md = source_path / "src" / category / f"{py_name}.md"
+            if md.exists():
+                return md
+    return None

cli/src/castle_cli/config.py

@@ -0,0 +1,217 @@
+"""Castle configuration and registry management."""
+
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+import yaml
+
+from castle_cli.manifest import ComponentManifest, Role
+
+
+def find_castle_root() -> Path:
+    """Find the castle repository root by walking up from cwd looking for castle.yaml."""
+    current = Path.cwd()
+    while current != current.parent:
+        if (current / "castle.yaml").exists():
+            return current
+        current = current.parent
+    # Fallback: check if castle.yaml is in a well-known location
+    default = Path("/data/repos/castle")
+    if (default / "castle.yaml").exists():
+        return default
+    raise FileNotFoundError(
+        "Could not find castle.yaml. Run castle from within the castle repository."
+    )
+
+
+CASTLE_HOME = Path.home() / ".castle"
+GENERATED_DIR = CASTLE_HOME / "generated"
+SECRETS_DIR = CASTLE_HOME / "secrets"
+
+
+@dataclass
+class GatewayConfig:
+    """Gateway configuration."""
+
+    port: int = 9000
+
+
+@dataclass
+class CastleConfig:
+    """Full castle configuration."""
+
+    root: Path
+    gateway: GatewayConfig
+    components: dict[str, ComponentManifest]
+
+    @property
+    def services(self) -> dict[str, ComponentManifest]:
+        """Return components with the SERVICE role."""
+        return {
+            k: v for k, v in self.components.items() if Role.SERVICE in v.roles
+        }
+
+    @property
+    def tools(self) -> dict[str, ComponentManifest]:
+        """Return components with the TOOL role."""
+        return {
+            k: v for k, v in self.components.items() if Role.TOOL in v.roles
+        }
+
+    @property
+    def workers(self) -> dict[str, ComponentManifest]:
+        """Return components with the WORKER role."""
+        return {
+            k: v for k, v in self.components.items() if Role.WORKER in v.roles
+        }
+
+    @property
+    def managed(self) -> dict[str, ComponentManifest]:
+        """Return components managed by systemd."""
+        return {
+            k: v
+            for k, v in self.components.items()
+            if v.manage and v.manage.systemd and v.manage.systemd.enable
+        }
+
+
+def resolve_env_vars(
+    env: dict[str, str], manifest: ComponentManifest
+) -> dict[str, str]:
+    """Resolve ${secret:NAME} references in env values."""
+    resolved = {}
+    for key, value in env.items():
+
+        def replace_var(match: re.Match[str]) -> str:
+            ref = match.group(1)
+            if ref.startswith("secret:"):
+                secret_name = ref[7:]
+                return _read_secret(secret_name)
+            return match.group(0)
+
+        resolved[key] = re.sub(r"\$\{([^}]+)\}", replace_var, value)
+    return resolved
+
+
+def _read_secret(name: str) -> str:
+    """Read a secret from ~/.castle/secrets/<name>. Returns placeholder if not found."""
+    secret_path = SECRETS_DIR / name
+    if secret_path.exists():
+        return secret_path.read_text().strip()
+    return f"<MISSING_SECRET:{name}>"
+
+
+def _parse_component(name: str, data: dict) -> ComponentManifest:
+    """Parse a components: entry directly into a ComponentManifest."""
+    data_copy = dict(data)
+    data_copy["id"] = name
+    return ComponentManifest.model_validate(data_copy)
+
+
+def load_config(root: Path | None = None) -> CastleConfig:
+    """Load castle.yaml and return parsed configuration."""
+    if root is None:
+        root = find_castle_root()
+
+    config_path = root / "castle.yaml"
+    if not config_path.exists():
+        raise FileNotFoundError(f"Castle config not found: {config_path}")
+
+    with open(config_path) as f:
+        data = yaml.safe_load(f)
+
+    gateway_data = data.get("gateway", {})
+    gateway = GatewayConfig(port=gateway_data.get("port", 9000))
+
+    components: dict[str, ComponentManifest] = {}
+    for name, comp_data in data.get("components", {}).items():
+        components[name] = _parse_component(name, comp_data)
+
+    return CastleConfig(root=root, gateway=gateway, components=components)
+
+
+def _clean_for_yaml(data: object, preserve_keys: set[str] | None = None) -> object:
+    """Recursively remove empty lists and non-structural empty dicts."""
+    if preserve_keys is None:
+        preserve_keys = _STRUCTURAL_KEYS
+    if isinstance(data, dict):
+        cleaned = {}
+        for k, v in data.items():
+            v = _clean_for_yaml(v, preserve_keys)
+            # Keep structural keys even if empty dict
+            if k in preserve_keys and isinstance(v, dict):
+                cleaned[k] = v
+                continue
+            # Skip empty collections
+            if isinstance(v, (list, dict)) and not v:
+                continue
+            cleaned[k] = v
+        return cleaned
+    elif isinstance(data, list):
+        return [_clean_for_yaml(item, preserve_keys) for item in data]
+    return data
+
+
+# Keys whose presence is structurally significant even with all-default values.
+# We serialize these as empty dicts `{}` so they survive a roundtrip.
+_STRUCTURAL_KEYS = {"manage", "systemd", "install", "path", "tool", "expose", "proxy", "caddy"}
+
+
+def _manifest_to_yaml_dict(manifest: ComponentManifest) -> dict:
+    """Serialize a manifest to a YAML-friendly dict, preserving structural presence."""
+    full = manifest.model_dump(mode="json", exclude_none=True, exclude={"id", "roles"})
+    minimal = manifest.model_dump(
+        mode="json", exclude_none=True, exclude={"id", "roles"}, exclude_defaults=True
+    )
+
+    def merge(full_val: object, min_val: object | None, key: str = "") -> object:
+        if isinstance(full_val, dict):
+            result = {}
+            for k, fv in full_val.items():
+                mv = min_val.get(k) if isinstance(min_val, dict) else None
+                if k in _STRUCTURAL_KEYS:
+                    merged = merge(fv, mv, k)
+                    if merged is not None:
+                        result[k] = merged
+                elif mv is not None:
+                    result[k] = merge(fv, mv, k)
+                elif isinstance(fv, dict):
+                    merged = merge(fv, None, k)
+                    if merged:
+                        result[k] = merged
+            return result if result else ({} if key in _STRUCTURAL_KEYS else result)
+        elif isinstance(full_val, list):
+            if min_val is not None:
+                return full_val
+            return []
+        else:
+            if min_val is not None:
+                return full_val
+            return None
+
+    result = merge(full, minimal)
+    return _clean_for_yaml(result)
+
+
+def save_config(config: CastleConfig) -> None:
+    """Save castle configuration to castle.yaml."""
+    data: dict = {"gateway": {"port": config.gateway.port}, "components": {}}
+
+    for name, manifest in config.components.items():
+        data["components"][name] = _manifest_to_yaml_dict(manifest)
+
+    config_path = config.root / "castle.yaml"
+    with open(config_path, "w") as f:
+        yaml.dump(data, f, default_flow_style=False, sort_keys=False)
+
+
+def ensure_dirs() -> None:
+    """Ensure castle directories exist."""
+    CASTLE_HOME.mkdir(parents=True, exist_ok=True)
+    GENERATED_DIR.mkdir(parents=True, exist_ok=True)
+    SECRETS_DIR.mkdir(parents=True, exist_ok=True)
+    os.chmod(SECRETS_DIR, 0o700)

cli/src/castle_cli/main.py

@@ -0,0 +1,212 @@
+"""Castle CLI entry point."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from castle_cli import __version__
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the argument parser."""
+    parser = argparse.ArgumentParser(
+        prog="castle",
+        description="Castle platform CLI - manage projects, services, and infrastructure",
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"castle {__version__}"
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # castle list
+    list_parser = subparsers.add_parser("list", help="List all components")
+    list_parser.add_argument(
+        "--role",
+        choices=["service", "tool", "worker", "job", "frontend", "remote", "containerized"],
+        help="Filter by role",
+    )
+    list_parser.add_argument(
+        "--json", action="store_true", help="Output as JSON"
+    )
+
+    # castle create
+    create_parser = subparsers.add_parser("create", help="Create a new project")
+    create_parser.add_argument("name", help="Project name")
+    create_parser.add_argument(
+        "--type",
+        choices=["service", "tool", "library"],
+        required=True,
+        help="Project type",
+    )
+    create_parser.add_argument(
+        "--description", default="", help="Project description"
+    )
+    create_parser.add_argument(
+        "--port", type=int, help="Port number (services only)"
+    )
+
+    # castle info
+    info_parser = subparsers.add_parser("info", help="Show component details")
+    info_parser.add_argument("project", help="Component name")
+    info_parser.add_argument(
+        "--json", action="store_true", help="Output as JSON"
+    )
+
+    # castle test
+    test_parser = subparsers.add_parser("test", help="Run tests")
+    test_parser.add_argument("project", nargs="?", help="Project to test (default: all)")
+
+    # castle lint
+    lint_parser = subparsers.add_parser("lint", help="Run linter")
+    lint_parser.add_argument("project", nargs="?", help="Project to lint (default: all)")
+
+    # castle sync
+    subparsers.add_parser("sync", help="Sync submodules and install dependencies")
+
+    # castle gateway
+    gateway_parser = subparsers.add_parser("gateway", help="Manage the Caddy gateway")
+    gateway_sub = gateway_parser.add_subparsers(dest="gateway_command")
+    gw_start = gateway_sub.add_parser("start", help="Start the gateway")
+    gw_start.add_argument(
+        "--dry-run", action="store_true", help="Print generated config without applying"
+    )
+    gateway_sub.add_parser("stop", help="Stop the gateway")
+    gw_reload = gateway_sub.add_parser("reload", help="Reload gateway configuration")
+    gw_reload.add_argument(
+        "--dry-run", action="store_true", help="Print generated config without applying"
+    )
+    gateway_sub.add_parser("status", help="Show gateway status")
+
+    # castle service (singular - manage individual services)
+    service_parser = subparsers.add_parser("service", help="Manage a service")
+    service_sub = service_parser.add_subparsers(dest="service_command")
+    enable_parser = service_sub.add_parser("enable", help="Enable and start a service")
+    enable_parser.add_argument("name", help="Service name")
+    enable_parser.add_argument(
+        "--dry-run", action="store_true", help="Print generated unit without installing"
+    )
+    disable_parser = service_sub.add_parser(
+        "disable", help="Stop and disable a service"
+    )
+    disable_parser.add_argument("name", help="Service name")
+    service_sub.add_parser("status", help="Show status of all services")
+
+    # castle services (plural - manage all services)
+    services_parser = subparsers.add_parser(
+        "services", help="Manage all services together"
+    )
+    services_sub = services_parser.add_subparsers(dest="services_command")
+    services_sub.add_parser("start", help="Start all services and gateway")
+    services_sub.add_parser("stop", help="Stop all services and gateway")
+
+    # castle logs
+    logs_parser = subparsers.add_parser("logs", help="View component logs")
+    logs_parser.add_argument("name", help="Component name")
+    logs_parser.add_argument(
+        "-f", "--follow", action="store_true", help="Follow log output"
+    )
+    logs_parser.add_argument(
+        "-n", "--lines", type=int, default=50, help="Number of lines to show (default: 50)"
+    )
+
+    # castle run
+    run_parser = subparsers.add_parser("run", help="Run a component in the foreground")
+    run_parser.add_argument("name", help="Component name")
+    run_parser.add_argument(
+        "extra", nargs=argparse.REMAINDER, help="Extra arguments passed to the component"
+    )
+
+    # castle tool
+    tool_parser = subparsers.add_parser("tool", help="Manage tools")
+    tool_sub = tool_parser.add_subparsers(dest="tool_command")
+    tool_sub.add_parser("list", help="List all tools by category")
+    tool_info_parser = tool_sub.add_parser("info", help="Show tool details")
+    tool_info_parser.add_argument("name", help="Tool name")
+
+    return parser
+
+
+def main() -> int:
+    """Main entry point."""
+    parser = build_parser()
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return 0
+
+    # Import command handlers lazily to keep startup fast
+    if args.command == "list":
+        from castle_cli.commands.list_cmd import run_list
+
+        return run_list(args)
+
+    elif args.command == "info":
+        from castle_cli.commands.info import run_info
+
+        return run_info(args)
+
+    elif args.command == "create":
+        from castle_cli.commands.create import run_create
+
+        return run_create(args)
+
+    elif args.command == "test":
+        from castle_cli.commands.dev import run_test
+
+        return run_test(args)
+
+    elif args.command == "lint":
+        from castle_cli.commands.dev import run_lint
+
+        return run_lint(args)
+
+    elif args.command == "sync":
+        from castle_cli.commands.sync import run_sync
+
+        return run_sync(args)
+
+    elif args.command == "gateway":
+        from castle_cli.commands.gateway import run_gateway
+
+        return run_gateway(args)
+
+    elif args.command == "service":
+        from castle_cli.commands.service import run_service
+
+        return run_service(args)
+
+    elif args.command == "services":
+        from castle_cli.commands.service import run_services
+
+        return run_services(args)
+
+    elif args.command == "logs":
+        from castle_cli.commands.logs import run_logs
+
+        return run_logs(args)
+
+    elif args.command == "run":
+        from castle_cli.commands.run_cmd import run_run
+
+        return run_run(args)
+
+    elif args.command == "tool":
+        from castle_cli.commands.tool import run_tool
+
+        return run_tool(args)
+
+    else:
+        parser.print_help()
+        return 1
+
+
+def cli() -> None:
+    """Entry point for the CLI."""
+    sys.exit(main())
+
+
+if __name__ == "__main__":
+    cli()

cli/src/castle_cli/manifest.py

@@ -0,0 +1,315 @@
+"""Castle component manifest — Pydantic models for the component registry."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Annotated, Literal, Union
+
+from pydantic import BaseModel, Field, computed_field, model_validator
+
+EnvMap = dict[str, str]
+
+
+class RestartPolicy(str, Enum):
+    NO = "no"
+    ON_FAILURE = "on-failure"
+    ALWAYS = "always"
+
+
+class TLSMode(str, Enum):
+    OFF = "off"
+    INTERNAL = "internal"
+    LETSENCRYPT = "letsencrypt"
+
+
+class Role(str, Enum):
+    TOOL = "tool"
+    SERVICE = "service"
+    WORKER = "worker"
+    FRONTEND = "frontend"
+    JOB = "job"
+    REMOTE = "remote"
+    CONTAINERIZED = "containerized"
+
+
+# ---------------------
+# Run specs (discriminated union)
+# ---------------------
+
+
+class RunBase(BaseModel):
+    runner: str
+    cwd: str | None = None
+    env: EnvMap = Field(default_factory=dict)
+
+
+class RunCommand(RunBase):
+    runner: Literal["command"]
+    argv: list[str] = Field(min_length=1)
+
+
+class RunPythonModule(RunBase):
+    runner: Literal["python_module"]
+    module: str
+    args: list[str] = Field(default_factory=list)
+    python: str | None = None
+
+
+class RunPythonUvTool(RunBase):
+    runner: Literal["python_uv_tool"]
+    tool: str
+    args: list[str] = Field(default_factory=list)
+
+
+class RunContainer(RunBase):
+    runner: Literal["container"]
+    image: str
+    command: list[str] | None = None
+    args: list[str] = Field(default_factory=list)
+    ports: dict[int, int] = Field(default_factory=dict)
+    volumes: list[str] = Field(default_factory=list)
+    workdir: str | None = None
+
+
+class RunNode(RunBase):
+    runner: Literal["node"]
+    script: str
+    package_manager: Literal["npm", "pnpm", "yarn"] = "pnpm"
+    args: list[str] = Field(default_factory=list)
+
+
+class RunRemote(RunBase):
+    runner: Literal["remote"]
+    base_url: str
+    health_url: str | None = None
+
+
+RunSpec = Annotated[
+    Union[RunCommand, RunPythonModule, RunPythonUvTool, RunContainer, RunNode, RunRemote],
+    Field(discriminator="runner"),
+]
+
+
+# ---------------------
+# Triggers
+# ---------------------
+
+
+class TriggerManual(BaseModel):
+    type: Literal["manual"] = "manual"
+
+
+class TriggerSchedule(BaseModel):
+    type: Literal["schedule"] = "schedule"
+    cron: str
+    timezone: str = "America/Los_Angeles"
+
+
+class TriggerEvent(BaseModel):
+    type: Literal["event"] = "event"
+    source: str
+    topic: str | None = None
+    queue: str | None = None
+
+
+class TriggerRequest(BaseModel):
+    type: Literal["request"] = "request"
+    protocol: Literal["http", "https", "grpc"] = "http"
+
+
+TriggerSpec = Union[TriggerManual, TriggerSchedule, TriggerEvent, TriggerRequest]
+
+
+# ---------------------
+# Systemd management
+# ---------------------
+
+
+class ReadinessHttpGet(BaseModel):
+    http_get: str
+    timeout_seconds: int = 2
+    interval_seconds: int = 2
+    success_codes: list[int] = Field(default_factory=lambda: [200])
+
+
+class SystemdSpec(BaseModel):
+    enable: bool = True
+    user: bool = True
+    description: str | None = None
+    after: list[str] = Field(default_factory=list)
+    requires: list[str] = Field(default_factory=list)
+    wanted_by: list[str] = Field(default_factory=lambda: ["default.target"])
+    restart: RestartPolicy = RestartPolicy.ON_FAILURE
+    restart_sec: int = 2
+    no_new_privileges: bool = True
+    readiness: ReadinessHttpGet | None = None
+
+
+class ManageSpec(BaseModel):
+    systemd: SystemdSpec | None = None
+
+
+# ---------------------
+# Install (PATH shims)
+# ---------------------
+
+
+class PathInstallSpec(BaseModel):
+    enable: bool = True
+    alias: str | None = None
+    shim: bool = True
+
+
+class InstallSpec(BaseModel):
+    path: PathInstallSpec | None = None
+
+
+# ---------------------
+# Tool spec
+# ---------------------
+
+
+class ToolType(str, Enum):
+    PYTHON_UV = "python_uv"
+    PYTHON_STANDALONE = "python_standalone"
+    SCRIPT = "script"
+
+
+class ToolSpec(BaseModel):
+    tool_type: ToolType = ToolType.PYTHON_UV
+    category: str | None = None
+    version: str = "1.0.0"
+    source: str | None = None
+    entry_point: str | None = None
+    system_dependencies: list[str] = Field(default_factory=list)
+
+
+# ---------------------
+# HTTP exposure + proxy
+# ---------------------
+
+
+class HttpInternal(BaseModel):
+    host: str = "127.0.0.1"
+    port: int = Field(ge=1, le=65535)
+    unix_socket: str | None = None
+
+
+class HttpPublic(BaseModel):
+    hostnames: list[str] = Field(min_length=1)
+    path_prefix: str = "/"
+    tls: TLSMode = TLSMode.INTERNAL
+
+
+class HttpExposeSpec(BaseModel):
+    internal: HttpInternal
+    public: HttpPublic | None = None
+    health_path: str | None = None
+
+
+class ExposeSpec(BaseModel):
+    http: HttpExposeSpec | None = None
+
+
+class CaddySpec(BaseModel):
+    enable: bool = True
+    path_prefix: str | None = None
+    extra_snippets: list[str] = Field(default_factory=list)
+
+
+class ProxySpec(BaseModel):
+    caddy: CaddySpec | None = None
+
+
+# ---------------------
+# Build spec
+# ---------------------
+
+
+class BuildSpec(BaseModel):
+    commands: list[list[str]] = Field(default_factory=list)
+    outputs: list[str] = Field(default_factory=list)
+
+
+# ---------------------
+# Capabilities
+# ---------------------
+
+
+class Capability(BaseModel):
+    type: str
+    name: str | None = None
+    meta: dict[str, str] = Field(default_factory=dict)
+
+
+# ---------------------
+# Component manifest
+# ---------------------
+
+
+class ComponentManifest(BaseModel):
+    id: str = ""
+    name: str | None = None
+    description: str | None = None
+
+    run: RunSpec | None = None
+
+    triggers: list[TriggerSpec] = Field(default_factory=list)
+
+    manage: ManageSpec | None = None
+    install: InstallSpec | None = None
+    tool: ToolSpec | None = None
+    expose: ExposeSpec | None = None
+    proxy: ProxySpec | None = None
+    build: BuildSpec | None = None
+
+    provides: list[Capability] = Field(default_factory=list)
+    consumes: list[Capability] = Field(default_factory=list)
+
+    tags: list[str] = Field(default_factory=list)
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def roles(self) -> list[Role]:
+        roles: set[Role] = set()
+
+        if self.run:
+            if self.run.runner == "remote":
+                roles.add(Role.REMOTE)
+            if self.run.runner == "container":
+                roles.add(Role.CONTAINERIZED)
+
+        if self.install and self.install.path and self.install.path.enable:
+            roles.add(Role.TOOL)
+
+        if self.tool:
+            roles.add(Role.TOOL)
+
+        if self.expose and self.expose.http:
+            roles.add(Role.SERVICE)
+
+        if (
+            self.manage
+            and self.manage.systemd
+            and self.manage.systemd.enable
+            and not (self.expose and self.expose.http)
+        ):
+            roles.add(Role.WORKER)
+
+        if self.build and (self.build.outputs or self.build.commands):
+            roles.add(Role.FRONTEND)
+
+        if any(getattr(t, "type", None) == "schedule" for t in self.triggers):
+            roles.add(Role.JOB)
+
+        if not roles:
+            roles.add(Role.TOOL)
+
+        return sorted(roles, key=lambda r: r.value)
+
+    @model_validator(mode="after")
+    def _basic_consistency(self) -> ComponentManifest:
+        if self.manage and self.manage.systemd and self.manage.systemd.enable:
+            if self.run and self.run.runner == "remote":
+                raise ValueError("manage.systemd cannot be enabled for runner=remote.")
+        return self

cli/src/castle_cli/templates/scaffold.py

@@ -0,0 +1,574 @@
+"""Project scaffolding - generates project files from templates."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def scaffold_project(
+    project_dir: Path,
+    name: str,
+    package_name: str,
+    proj_type: str,
+    description: str,
+    port: int | None = None,
+) -> None:
+    """Scaffold a new project from templates."""
+    if proj_type == "service":
+        _scaffold_service(project_dir, name, package_name, description, port or 9000)
+    elif proj_type == "tool":
+        _scaffold_tool(project_dir, name, package_name, description)
+    elif proj_type == "library":
+        _scaffold_library(project_dir, name, package_name, description)
+    else:
+        raise ValueError(f"Unknown project type: {proj_type}")
+
+
+def _scaffold_service(
+    project_dir: Path,
+    name: str,
+    package_name: str,
+    description: str,
+    port: int,
+) -> None:
+    """Scaffold a FastAPI service."""
+    src_dir = project_dir / "src" / package_name
+    tests_dir = project_dir / "tests"
+    src_dir.mkdir(parents=True)
+    tests_dir.mkdir(parents=True)
+
+    env_prefix = package_name.upper()
+
+    # pyproject.toml
+    _write(
+        project_dir / "pyproject.toml",
+        f'''[project]
+name = "{name}"
+version = "0.1.0"
+description = "{description}"
+requires-python = ">=3.13"
+dependencies = [
+    "fastapi>=0.115.0",
+    "uvicorn>=0.34.0",
+    "pydantic-settings>=2.0.0",
+    "httpx>=0.27.0",
+]
+
+[project.scripts]
+{name} = "{package_name}.main:run"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/{package_name}"]
+
+[dependency-groups]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.23.0",
+    "httpx>=0.27.0",
+]
+
+[tool.ruff.lint.isort]
+known-first-party = ["{package_name}"]
+''',
+    )
+
+    # __init__.py
+    _write(
+        src_dir / "__init__.py",
+        f'"""{description}."""\n\n__version__ = "0.1.0"\n',
+    )
+
+    # config.py
+    _write(
+        src_dir / "config.py",
+        f'''"""Configuration for {name}."""
+
+from pathlib import Path
+
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    """Service settings loaded from environment variables."""
+
+    data_dir: Path = Path("./data")
+    host: str = "0.0.0.0"
+    port: int = {port}
+
+    model_config = {{
+        "env_prefix": "{env_prefix}_",
+        "env_file": ".env",
+    }}
+
+    def ensure_data_dir(self) -> None:
+        """Create data directory if it doesn't exist."""
+        self.data_dir.mkdir(parents=True, exist_ok=True)
+
+
+settings = Settings()
+''',
+    )
+
+    # main.py
+    _write(
+        src_dir / "main.py",
+        f'''"""Main application for {name}."""
+
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+
+import uvicorn
+from fastapi import FastAPI
+
+from {package_name}.config import settings
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    """Application lifespan handler."""
+    settings.ensure_data_dir()
+    yield
+
+
+app = FastAPI(
+    title="{name}",
+    description="{description}",
+    version="0.1.0",
+    lifespan=lifespan,
+)
+
+
+@app.get("/health")
+async def health() -> dict[str, str]:
+    """Health check endpoint."""
+    return {{"status": "ok"}}
+
+
+def run() -> None:
+    """Run the application with uvicorn."""
+    uvicorn.run(
+        "{package_name}.main:app",
+        host=settings.host,
+        port=settings.port,
+        reload=False,
+    )
+
+
+if __name__ == "__main__":
+    run()
+''',
+    )
+
+    # tests/__init__.py
+    _write(tests_dir / "__init__.py", "")
+
+    # tests/conftest.py
+    _write(
+        tests_dir / "conftest.py",
+        f'''"""Test fixtures for {name}."""
+
+from collections.abc import Generator
+from pathlib import Path
+
+import pytest
+from fastapi.testclient import TestClient
+
+from {package_name}.config import settings
+from {package_name}.main import app
+
+
+@pytest.fixture
+def temp_data_dir(tmp_path: Path) -> Generator[Path, None, None]:
+    """Create a temporary data directory for tests."""
+    data_dir = tmp_path / "data"
+    data_dir.mkdir()
+    original = settings.data_dir
+    settings.data_dir = data_dir
+    yield data_dir
+    settings.data_dir = original
+
+
+@pytest.fixture
+def client(temp_data_dir: Path) -> Generator[TestClient, None, None]:
+    """Create a test client with isolated data directory."""
+    with TestClient(app) as client:
+        yield client
+''',
+    )
+
+    # tests/test_health.py
+    _write(
+        tests_dir / "test_health.py",
+        f'''"""Tests for {name} health endpoint."""
+
+from fastapi.testclient import TestClient
+
+
+class TestHealth:
+    """Health endpoint tests."""
+
+    def test_health(self, client: TestClient) -> None:
+        """Health endpoint returns ok."""
+        response = client.get("/health")
+        assert response.status_code == 200
+        assert response.json() == {{"status": "ok"}}
+''',
+    )
+
+    # CLAUDE.md
+    _write(
+        project_dir / "CLAUDE.md",
+        f"""# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working
+with code in this repository.
+
+## Overview
+
+{name} is a FastAPI service. {description}.
+
+## Commands
+
+```bash
+uv sync                     # Install dependencies
+uv run {name}              # Run service (port {port})
+uv run pytest tests/ -v     # Run tests
+uv run ruff check .         # Lint
+uv run ruff format .        # Format
+```
+
+## Architecture
+
+- `src/{package_name}/config.py` — Settings via pydantic-settings, env prefix `{env_prefix}_`
+- `src/{package_name}/main.py` — FastAPI app, lifespan, health endpoint
+- `tests/` — pytest with TestClient fixtures
+
+## Configuration
+
+Environment variables with `{env_prefix}_` prefix:
+- `{env_prefix}_DATA_DIR` — Data directory (default: ./data)
+- `{env_prefix}_HOST` — Bind host (default: 0.0.0.0)
+- `{env_prefix}_PORT` — Port (default: {port})
+""",
+    )
+
+
+def _scaffold_tool(
+    project_dir: Path,
+    name: str,
+    package_name: str,
+    description: str,
+) -> None:
+    """Scaffold a CLI tool."""
+    src_dir = project_dir / "src" / package_name
+    tests_dir = project_dir / "tests"
+    src_dir.mkdir(parents=True)
+    tests_dir.mkdir(parents=True)
+
+    # pyproject.toml
+    _write(
+        project_dir / "pyproject.toml",
+        f'''[project]
+name = "{name}"
+version = "0.1.0"
+description = "{description}"
+requires-python = ">=3.11"
+dependencies = []
+
+[project.scripts]
+{name} = "{package_name}.main:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/{package_name}"]
+
+[dependency-groups]
+dev = [
+    "pytest>=7.0.0",
+]
+
+[tool.ruff.lint.isort]
+known-first-party = ["{package_name}"]
+''',
+    )
+
+    # __init__.py
+    _write(
+        src_dir / "__init__.py",
+        f'"""{description}."""\n\n__version__ = "0.1.0"\n',
+    )
+
+    # main.py
+    _write(
+        src_dir / "main.py",
+        f'''#!/usr/bin/env python3
+"""{name}: {description}
+
+Usage:
+    {name} [options] [input]
+    cat input.txt | {name}
+
+Examples:
+    {name} input.txt
+    {name} input.txt -o output.txt
+    cat input.txt | {name} > output.txt
+"""
+
+import argparse
+import sys
+
+from {package_name} import __version__
+
+__all__ = ["main"]
+
+
+def main() -> int:
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description="{description}",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+    parser.add_argument("input", nargs="?", help="Input file (default: stdin)")
+    parser.add_argument(
+        "-o", "--output", default=None, help="Output file (default: stdout)"
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"{name} {{__version__}}"
+    )
+    args = parser.parse_args()
+
+    if args.input:
+        with open(args.input) as f:
+            data = f.read()
+    else:
+        data = sys.stdin.read()
+
+    # TODO: implement tool logic
+    result = data
+
+    if args.output:
+        with open(args.output, "w") as f:
+            f.write(result)
+    else:
+        print(result, end="")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+''',
+    )
+
+    # tests/__init__.py
+    _write(tests_dir / "__init__.py", "")
+
+    # tests/test_main.py
+    _write(
+        tests_dir / "test_main.py",
+        f'''"""Tests for {name}."""
+
+import subprocess
+import sys
+
+
+class TestCLI:
+    """CLI interface tests."""
+
+    def test_version(self) -> None:
+        """--version prints version string."""
+        result = subprocess.run(
+            [sys.executable, "-m", "{package_name}.main", "--version"],
+            capture_output=True,
+            text=True,
+        )
+        assert "{name}" in result.stdout
+        assert "0.1.0" in result.stdout
+
+    def test_stdin(self) -> None:
+        """Reads from stdin when no file argument."""
+        result = subprocess.run(
+            [sys.executable, "-m", "{package_name}.main"],
+            input="hello\\n",
+            capture_output=True,
+            text=True,
+        )
+        assert result.returncode == 0
+        assert "hello" in result.stdout
+
+    def test_file_input(self, tmp_path) -> None:
+        """Reads from file argument."""
+        input_file = tmp_path / "input.txt"
+        input_file.write_text("test data")
+        result = subprocess.run(
+            [sys.executable, "-m", "{package_name}.main", str(input_file)],
+            capture_output=True,
+            text=True,
+        )
+        assert result.returncode == 0
+        assert "test data" in result.stdout
+
+    def test_output_file(self, tmp_path) -> None:
+        """Writes to output file with -o flag."""
+        input_file = tmp_path / "input.txt"
+        input_file.write_text("test data")
+        output_file = tmp_path / "output.txt"
+        result = subprocess.run(
+            [
+                sys.executable, "-m", "{package_name}.main",
+                str(input_file), "-o", str(output_file),
+            ],
+            capture_output=True,
+            text=True,
+        )
+        assert result.returncode == 0
+        assert output_file.read_text() == "test data"
+''',
+    )
+
+    # CLAUDE.md
+    _write(
+        project_dir / "CLAUDE.md",
+        f"""# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working
+with code in this repository.
+
+## Overview
+
+{name} is a CLI tool. {description}.
+
+## Commands
+
+```bash
+uv sync                     # Install dependencies
+uv run {name}              # Run the tool
+uv run {name} --version    # Show version
+uv run pytest tests/ -v     # Run tests
+uv run ruff check .         # Lint
+uv run ruff format .        # Format
+```
+
+## Architecture
+
+- `src/{package_name}/main.py` — Entry point, argparse CLI, stdin/stdout interface
+- `src/{package_name}/__init__.py` — Package version (`__version__`)
+- `tests/` — pytest tests
+
+## Conventions
+
+- Reads from stdin or file argument
+- Writes to stdout or `-o/--output` file
+- `--version` flag for version info
+- Returns 0 on success, 1 on error
+- Composable via Unix pipes
+- `argparse.RawDescriptionHelpFormatter` with module docstring as epilog
+""",
+    )
+
+
+def _scaffold_library(
+    project_dir: Path,
+    name: str,
+    package_name: str,
+    description: str,
+) -> None:
+    """Scaffold a Python library."""
+    src_dir = project_dir / "src" / package_name
+    tests_dir = project_dir / "tests"
+    src_dir.mkdir(parents=True)
+    tests_dir.mkdir(parents=True)
+
+    # pyproject.toml
+    _write(
+        project_dir / "pyproject.toml",
+        f'''[project]
+name = "{name}"
+version = "0.1.0"
+description = "{description}"
+requires-python = ">=3.11"
+dependencies = []
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/{package_name}"]
+
+[dependency-groups]
+dev = [
+    "pytest>=7.0.0",
+]
+
+[tool.ruff.lint.isort]
+known-first-party = ["{package_name}"]
+''',
+    )
+
+    # __init__.py
+    _write(
+        src_dir / "__init__.py",
+        f'"""{description}."""\n\n__version__ = "0.1.0"\n',
+    )
+
+    # tests/__init__.py
+    _write(tests_dir / "__init__.py", "")
+
+    # tests/test_placeholder.py
+    _write(
+        tests_dir / "test_placeholder.py",
+        f'''"""Tests for {name}."""
+
+
+class TestPlaceholder:
+    """Placeholder tests."""
+
+    def test_import(self) -> None:
+        """Library can be imported."""
+        import {package_name}
+        assert {package_name}.__version__ == "0.1.0"
+''',
+    )
+
+    # CLAUDE.md
+    _write(
+        project_dir / "CLAUDE.md",
+        f"""# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working
+with code in this repository.
+
+## Overview
+
+{name} is a Python library. {description}.
+
+## Commands
+
+```bash
+uv sync                     # Install dependencies
+uv run pytest tests/ -v     # Run tests
+uv run ruff check .         # Lint
+uv run ruff format .        # Format
+```
+
+## Architecture
+
+- `src/{package_name}/` — Library source code
+- `tests/` — pytest tests
+""",
+    )
+
+
+def _write(path: Path, content: str) -> None:
+    """Write content to a file, creating parent directories."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content)

cli/tests/conftest.py

@@ -0,0 +1,68 @@
+"""Shared fixtures for castle CLI tests."""
+
+from __future__ import annotations
+
+from collections.abc import Generator
+from pathlib import Path
+
+import pytest
+import yaml
+
+
+@pytest.fixture
+def castle_root(tmp_path: Path) -> Generator[Path, None, None]:
+    """Create a temporary castle root with castle.yaml."""
+    castle_yaml = tmp_path / "castle.yaml"
+    config = {
+        "gateway": {"port": 18000},
+        "components": {
+            "test-svc": {
+                "description": "Test service",
+                "run": {
+                    "runner": "python_uv_tool",
+                    "tool": "test-svc",
+                    "cwd": "test-svc",
+                    "env": {"TEST_SVC_DATA_DIR": str(tmp_path / "data" / "test-svc")},
+                },
+                "expose": {
+                    "http": {
+                        "internal": {"port": 19000},
+                        "health_path": "/health",
+                    }
+                },
+                "proxy": {
+                    "caddy": {"path_prefix": "/test-svc"},
+                },
+                "manage": {
+                    "systemd": {},
+                },
+            },
+            "test-tool": {
+                "description": "Test tool",
+                "install": {
+                    "path": {"alias": "test-tool"},
+                },
+            },
+        },
+    }
+    castle_yaml.write_text(yaml.dump(config, default_flow_style=False))
+
+    # Create project directories
+    svc_dir = tmp_path / "test-svc"
+    svc_dir.mkdir()
+    (svc_dir / "pyproject.toml").write_text("[project]\nname = 'test-svc'\n")
+
+    tool_dir = tmp_path / "test-tool"
+    tool_dir.mkdir()
+
+    yield tmp_path
+
+
+@pytest.fixture
+def castle_home(tmp_path: Path) -> Generator[Path, None, None]:
+    """Create a temporary ~/.castle directory."""
+    home = tmp_path / ".castle"
+    home.mkdir()
+    (home / "generated").mkdir()
+    (home / "secrets").mkdir()
+    yield home

cli/tests/test_config.py

@@ -0,0 +1,171 @@
+"""Tests for castle configuration loading."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from castle_cli.config import (
+    CastleConfig,
+    load_config,
+    resolve_env_vars,
+    save_config,
+)
+from castle_cli.manifest import ComponentManifest, Role
+
+
+class TestLoadConfig:
+    """Tests for loading castle.yaml."""
+
+    def test_load_basic(self, castle_root: Path) -> None:
+        """Load a castle.yaml."""
+        config = load_config(castle_root)
+        assert isinstance(config, CastleConfig)
+        assert config.gateway.port == 18000
+        assert "test-svc" in config.components
+        assert "test-tool" in config.components
+
+    def test_load_produces_manifests(self, castle_root: Path) -> None:
+        """Components are ComponentManifest objects."""
+        config = load_config(castle_root)
+        assert isinstance(config.components["test-svc"], ComponentManifest)
+        assert isinstance(config.components["test-tool"], ComponentManifest)
+
+    def test_service_roles(self, castle_root: Path) -> None:
+        """Service with expose.http gets SERVICE role."""
+        config = load_config(castle_root)
+        svc = config.components["test-svc"]
+        assert Role.SERVICE in svc.roles
+
+    def test_tool_roles(self, castle_root: Path) -> None:
+        """Tool with install.path gets TOOL role."""
+        config = load_config(castle_root)
+        tool = config.components["test-tool"]
+        assert Role.TOOL in tool.roles
+
+    def test_service_expose(self, castle_root: Path) -> None:
+        """Service has correct expose spec."""
+        config = load_config(castle_root)
+        svc = config.components["test-svc"]
+        assert svc.expose.http.internal.port == 19000
+        assert svc.expose.http.health_path == "/health"
+
+    def test_service_proxy(self, castle_root: Path) -> None:
+        """Service has correct proxy spec."""
+        config = load_config(castle_root)
+        svc = config.components["test-svc"]
+        assert svc.proxy.caddy.path_prefix == "/test-svc"
+
+    def test_service_run_spec(self, castle_root: Path) -> None:
+        """Service has correct RunSpec."""
+        config = load_config(castle_root)
+        svc = config.components["test-svc"]
+        assert svc.run.runner == "python_uv_tool"
+        assert svc.run.tool == "test-svc"
+        assert svc.run.cwd == "test-svc"
+
+    def test_tool_no_run(self, castle_root: Path) -> None:
+        """Tool without run block has no run spec."""
+        config = load_config(castle_root)
+        tool = config.components["test-tool"]
+        assert tool.run is None
+
+    def test_services_property(self, castle_root: Path) -> None:
+        """Services property filters to SERVICE role."""
+        config = load_config(castle_root)
+        assert "test-svc" in config.services
+        assert "test-tool" not in config.services
+
+    def test_tools_property(self, castle_root: Path) -> None:
+        """Tools property filters to TOOL role."""
+        config = load_config(castle_root)
+        assert "test-tool" in config.tools
+        assert "test-svc" not in config.tools
+
+    def test_managed_property(self, castle_root: Path) -> None:
+        """Managed property returns systemd-managed components."""
+        config = load_config(castle_root)
+        assert "test-svc" in config.managed
+        assert "test-tool" not in config.managed
+
+    def test_missing_config_raises(self, tmp_path: Path) -> None:
+        """Missing castle.yaml raises FileNotFoundError."""
+        with pytest.raises(FileNotFoundError):
+            load_config(tmp_path)
+
+
+class TestSaveConfig:
+    """Tests for saving castle.yaml."""
+
+    def test_round_trip(self, castle_root: Path) -> None:
+        """Load and save should produce equivalent config."""
+        config = load_config(castle_root)
+        save_config(config)
+        config2 = load_config(castle_root)
+
+        assert config2.gateway.port == config.gateway.port
+        assert set(config2.components.keys()) == set(config.components.keys())
+
+    def test_save_adds_component(self, castle_root: Path) -> None:
+        """Adding a component and saving persists it."""
+        config = load_config(castle_root)
+        config.components["new-lib"] = ComponentManifest(
+            id="new-lib", description="A new library"
+        )
+        save_config(config)
+
+        config2 = load_config(castle_root)
+        assert "new-lib" in config2.components
+        assert config2.components["new-lib"].description == "A new library"
+
+    def test_preserves_manage_systemd(self, castle_root: Path) -> None:
+        """Roundtrip preserves manage.systemd even with all defaults."""
+        config = load_config(castle_root)
+        save_config(config)
+        config2 = load_config(castle_root)
+        assert "test-svc" in config2.managed
+
+
+class TestResolveEnvVars:
+    """Tests for environment variable resolution."""
+
+    def test_no_vars(self) -> None:
+        """Plain values pass through unchanged."""
+        manifest = ComponentManifest(id="test")
+        env = {"MY_VAR": "plain_value"}
+        resolved = resolve_env_vars(env, manifest)
+        assert resolved["MY_VAR"] == "plain_value"
+
+    def test_unrecognized_vars_preserved(self) -> None:
+        """Non-secret ${} references pass through unchanged."""
+        manifest = ComponentManifest(id="test")
+        env = {"MY_VAR": "${unknown_var}"}
+        resolved = resolve_env_vars(env, manifest)
+        assert resolved["MY_VAR"] == "${unknown_var}"
+
+    def test_resolve_secret(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """${secret:NAME} resolves from secrets directory."""
+        secrets_dir = tmp_path / "secrets"
+        secrets_dir.mkdir()
+        (secrets_dir / "API_KEY").write_text("my-secret-key\n")
+        monkeypatch.setattr("castle_cli.config.SECRETS_DIR", secrets_dir)
+
+        manifest = ComponentManifest(id="test")
+        env = {"API_KEY": "${secret:API_KEY}"}
+        resolved = resolve_env_vars(env, manifest)
+        assert resolved["API_KEY"] == "my-secret-key"
+
+    def test_resolve_missing_secret(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """Missing secret returns placeholder."""
+        secrets_dir = tmp_path / "secrets"
+        secrets_dir.mkdir()
+        monkeypatch.setattr("castle_cli.config.SECRETS_DIR", secrets_dir)
+
+        manifest = ComponentManifest(id="test")
+        env = {"API_KEY": "${secret:NONEXISTENT}"}
+        resolved = resolve_env_vars(env, manifest)
+        assert resolved["API_KEY"] == "<MISSING_SECRET:NONEXISTENT>"

cli/tests/test_create.py

@@ -0,0 +1,137 @@
+"""Tests for castle create command."""
+
+from __future__ import annotations
+
+from argparse import Namespace
+from pathlib import Path
+from unittest.mock import patch
+
+from castle_cli.config import load_config
+from castle_cli.manifest import Role
+
+
+class TestCreateCommand:
+    """Tests for the create command."""
+
+    def test_create_service(self, castle_root: Path) -> None:
+        """Create a new service project."""
+        with patch("castle_cli.commands.create.load_config") as mock_load, patch(
+            "castle_cli.commands.create.save_config"
+        ) as mock_save:
+            config = load_config(castle_root)
+            mock_load.return_value = config
+
+            from castle_cli.commands.create import run_create
+
+            args = Namespace(
+                name="my-api",
+                type="service",
+                description="My API service",
+                port=9050,
+            )
+            result = run_create(args)
+
+        assert result == 0
+        project_dir = castle_root / "my-api"
+        assert project_dir.exists()
+        assert (project_dir / "pyproject.toml").exists()
+        assert (project_dir / "src" / "my_api" / "main.py").exists()
+        assert (project_dir / "src" / "my_api" / "config.py").exists()
+        assert (project_dir / "tests" / "conftest.py").exists()
+        assert (project_dir / "tests" / "test_health.py").exists()
+        assert (project_dir / "CLAUDE.md").exists()
+
+        # Verify registered as ComponentManifest
+        assert "my-api" in config.components
+        manifest = config.components["my-api"]
+        assert Role.SERVICE in manifest.roles
+        assert manifest.expose.http.internal.port == 9050
+        mock_save.assert_called_once()
+
+    def test_create_tool(self, castle_root: Path) -> None:
+        """Create a new tool project."""
+        with patch("castle_cli.commands.create.load_config") as mock_load, patch(
+            "castle_cli.commands.create.save_config"
+        ):
+            config = load_config(castle_root)
+            mock_load.return_value = config
+
+            from castle_cli.commands.create import run_create
+
+            args = Namespace(
+                name="my-tool", type="tool", description="My tool", port=None
+            )
+            result = run_create(args)
+
+        assert result == 0
+        project_dir = castle_root / "my-tool"
+        assert project_dir.exists()
+        assert (project_dir / "src" / "my_tool" / "main.py").exists()
+        assert (project_dir / "CLAUDE.md").exists()
+        assert "my-tool" in config.components
+        manifest = config.components["my-tool"]
+        assert Role.TOOL in manifest.roles
+
+    def test_create_library(self, castle_root: Path) -> None:
+        """Create a new library project."""
+        with patch("castle_cli.commands.create.load_config") as mock_load, patch(
+            "castle_cli.commands.create.save_config"
+        ):
+            config = load_config(castle_root)
+            mock_load.return_value = config
+
+            from castle_cli.commands.create import run_create
+
+            args = Namespace(
+                name="my-lib", type="library", description="My library", port=None
+            )
+            result = run_create(args)
+
+        assert result == 0
+        project_dir = castle_root / "my-lib"
+        assert project_dir.exists()
+        assert (project_dir / "src" / "my_lib" / "__init__.py").exists()
+        assert (project_dir / "CLAUDE.md").exists()
+        assert "my-lib" in config.components
+
+    def test_create_duplicate_fails(self, castle_root: Path, capsys: object) -> None:
+        """Creating a project with existing name fails."""
+        with patch("castle_cli.commands.create.load_config") as mock_load:
+            config = load_config(castle_root)
+            mock_load.return_value = config
+
+            from castle_cli.commands.create import run_create
+
+            args = Namespace(
+                name="test-svc",
+                type="service",
+                description="Duplicate",
+                port=None,
+            )
+            result = run_create(args)
+
+        assert result == 1
+
+    def test_create_auto_port(self, castle_root: Path) -> None:
+        """Service creation auto-assigns next available port."""
+        with patch("castle_cli.commands.create.load_config") as mock_load, patch(
+            "castle_cli.commands.create.save_config"
+        ):
+            config = load_config(castle_root)
+            mock_load.return_value = config
+
+            from castle_cli.commands.create import run_create
+
+            args = Namespace(
+                name="auto-port-svc",
+                type="service",
+                description="Auto port",
+                port=None,
+            )
+            run_create(args)
+
+        manifest = config.components["auto-port-svc"]
+        port = manifest.expose.http.internal.port
+        # Port 18000 is gateway, 19000 is test-svc, so next should be 9001+
+        assert port is not None
+        assert port not in (18000, 19000)

cli/tests/test_gateway.py

@@ -0,0 +1,60 @@
+"""Tests for castle gateway command."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from castle_cli.commands.gateway import _generate_caddyfile
+from castle_cli.config import load_config
+
+
+class TestCaddyfileGeneration:
+    """Tests for Caddyfile generation."""
+
+    def test_contains_gateway_port(self, castle_root: Path) -> None:
+        """Caddyfile uses the configured gateway port."""
+        config = load_config(castle_root)
+        caddyfile = _generate_caddyfile(config)
+        assert ":18000 {" in caddyfile
+
+    def test_contains_service_routes(self, castle_root: Path) -> None:
+        """Caddyfile has reverse proxy routes for services with proxy.caddy."""
+        config = load_config(castle_root)
+        caddyfile = _generate_caddyfile(config)
+        assert "handle_path /test-svc/*" in caddyfile
+        assert "reverse_proxy" in caddyfile
+        assert "19000" in caddyfile
+
+    def test_skips_tools(self, castle_root: Path) -> None:
+        """Tools without proxy are not in Caddyfile."""
+        config = load_config(castle_root)
+        caddyfile = _generate_caddyfile(config)
+        assert "test-tool" not in caddyfile
+
+    def test_fallback_when_no_dist(self, castle_root: Path) -> None:
+        """Uses fallback dashboard path when dist/ doesn't exist."""
+        config = load_config(castle_root)
+        caddyfile = _generate_caddyfile(config)
+        # No dashboard/dist exists in tmp, so should use fallback
+        assert "handle / {" in caddyfile
+        assert "file_server" in caddyfile
+
+    def test_spa_serving_when_dist_exists(self, castle_root: Path) -> None:
+        """Serves SPA with try_files when dashboard/dist exists."""
+        # Create a dashboard/dist with index.html
+        dist = castle_root / "dashboard" / "dist"
+        dist.mkdir(parents=True)
+        (dist / "index.html").write_text("<html></html>")
+
+        config = load_config(castle_root)
+        caddyfile = _generate_caddyfile(config)
+        assert "try_files {path} /index.html" in caddyfile
+        assert str(dist) in caddyfile
+
+    def test_proxy_routes_before_dashboard(self, castle_root: Path) -> None:
+        """Service proxy routes appear before the dashboard catch-all."""
+        config = load_config(castle_root)
+        caddyfile = _generate_caddyfile(config)
+        proxy_pos = caddyfile.index("handle_path")
+        handle_pos = caddyfile.index("handle /")
+        assert proxy_pos < handle_pos

cli/tests/test_info.py

@@ -0,0 +1,148 @@
+"""Tests for castle info command."""
+
+from __future__ import annotations
+
+import json
+from argparse import Namespace
+from pathlib import Path
+from unittest.mock import patch
+
+
+class TestInfoCommand:
+    """Tests for the info command."""
+
+    def test_info_service(self, castle_root: Path, capsys) -> None:
+        """Show info for a service."""
+        from castle_cli.config import load_config
+
+        with patch("castle_cli.commands.info.load_config") as mock_load:
+            mock_load.return_value = load_config(castle_root)
+
+            from castle_cli.commands.info import run_info
+
+            result = run_info(Namespace(project="test-svc", json=False))
+
+        assert result == 0
+        output = capsys.readouterr().out
+        assert "test-svc" in output
+        assert "service" in output
+        assert "19000" in output
+
+    def test_info_tool(self, castle_root: Path, capsys) -> None:
+        """Show info for a tool."""
+        from castle_cli.config import load_config
+
+        with patch("castle_cli.commands.info.load_config") as mock_load:
+            mock_load.return_value = load_config(castle_root)
+
+            from castle_cli.commands.info import run_info
+
+            result = run_info(Namespace(project="test-tool", json=False))
+
+        assert result == 0
+        output = capsys.readouterr().out
+        assert "test-tool" in output
+        assert "tool" in output
+
+    def test_info_not_found(self, castle_root: Path, capsys) -> None:
+        """Info for nonexistent component returns error."""
+        from castle_cli.config import load_config
+
+        with patch("castle_cli.commands.info.load_config") as mock_load:
+            mock_load.return_value = load_config(castle_root)
+
+            from castle_cli.commands.info import run_info
+
+            result = run_info(Namespace(project="nope", json=False))
+
+        assert result == 1
+        output = capsys.readouterr().out
+        assert "not found" in output
+
+    def test_info_json(self, castle_root: Path, capsys) -> None:
+        """--json produces valid JSON with manifest fields."""
+        from castle_cli.config import load_config
+
+        with patch("castle_cli.commands.info.load_config") as mock_load:
+            mock_load.return_value = load_config(castle_root)
+
+            from castle_cli.commands.info import run_info
+
+            result = run_info(Namespace(project="test-svc", json=True))
+
+        assert result == 0
+        output = capsys.readouterr().out
+        data = json.loads(output)
+        assert data["id"] == "test-svc"
+        assert "service" in data["roles"]
+        assert data["expose"]["http"]["internal"]["port"] == 19000
+
+    def test_info_shows_claude_md(self, castle_root: Path, capsys) -> None:
+        """Info shows CLAUDE.md content when present."""
+        project_dir = castle_root / "test-svc"
+        project_dir.mkdir(exist_ok=True)
+        (project_dir / "CLAUDE.md").write_text("# Test Service\n\nSome docs here.")
+
+        from castle_cli.config import load_config
+
+        with patch("castle_cli.commands.info.load_config") as mock_load:
+            mock_load.return_value = load_config(castle_root)
+
+            from castle_cli.commands.info import run_info
+
+            result = run_info(Namespace(project="test-svc", json=False))
+
+        assert result == 0
+        output = capsys.readouterr().out
+        assert "Some docs here" in output
+
+    def test_info_json_includes_claude_md(self, castle_root: Path, capsys) -> None:
+        """--json includes claude_md field when CLAUDE.md exists."""
+        project_dir = castle_root / "test-svc"
+        project_dir.mkdir(exist_ok=True)
+        (project_dir / "CLAUDE.md").write_text("# Docs\n")
+
+        from castle_cli.config import load_config
+
+        with patch("castle_cli.commands.info.load_config") as mock_load:
+            mock_load.return_value = load_config(castle_root)
+
+            from castle_cli.commands.info import run_info
+
+            result = run_info(Namespace(project="test-svc", json=True))
+
+        assert result == 0
+        data = json.loads(capsys.readouterr().out)
+        assert "claude_md" in data
+        assert "# Docs" in data["claude_md"]
+
+    def test_info_shows_env(self, castle_root: Path, capsys) -> None:
+        """Info displays environment variables."""
+        from castle_cli.config import load_config
+
+        with patch("castle_cli.commands.info.load_config") as mock_load:
+            mock_load.return_value = load_config(castle_root)
+
+            from castle_cli.commands.info import run_info
+
+            result = run_info(Namespace(project="test-svc", json=False))
+
+        assert result == 0
+        output = capsys.readouterr().out
+        assert "TEST_SVC_DATA_DIR" in output
+
+    def test_info_shows_roles(self, castle_root: Path, capsys) -> None:
+        """Info displays derived roles."""
+        from castle_cli.config import load_config
+
+        with patch("castle_cli.commands.info.load_config") as mock_load:
+            mock_load.return_value = load_config(castle_root)
+
+            from castle_cli.commands.info import run_info
+
+            result = run_info(Namespace(project="test-svc", json=False))
+
+        assert result == 0
+        output = capsys.readouterr().out
+        assert "roles" in output
+        assert "service" in output

cli/tests/test_list.py

@@ -0,0 +1,75 @@
+"""Tests for castle list command."""
+
+from __future__ import annotations
+
+import json
+from argparse import Namespace
+from pathlib import Path
+from unittest.mock import patch
+
+from castle_cli.commands.list_cmd import run_list
+
+
+class TestListCommand:
+    """Tests for the list command."""
+
+    def test_list_all(self, castle_root: Path, capsys: object) -> None:
+        """List all components."""
+        with patch("castle_cli.commands.list_cmd.load_config") as mock_load:
+            from castle_cli.config import load_config
+
+            mock_load.return_value = load_config(castle_root)
+            args = Namespace(role=None, json=False)
+            result = run_list(args)
+
+        assert result == 0
+        captured = capsys.readouterr()  # type: ignore[attr-defined]
+        assert "test-svc" in captured.out
+        assert "test-tool" in captured.out
+
+    def test_list_filter_role(self, castle_root: Path, capsys: object) -> None:
+        """List filtered by role."""
+        with patch("castle_cli.commands.list_cmd.load_config") as mock_load:
+            from castle_cli.config import load_config
+
+            mock_load.return_value = load_config(castle_root)
+            args = Namespace(role="tool", json=False)
+            result = run_list(args)
+
+        assert result == 0
+        captured = capsys.readouterr()  # type: ignore[attr-defined]
+        assert "test-tool" in captured.out
+        assert "test-svc" not in captured.out
+
+    def test_list_filter_service(self, castle_root: Path, capsys: object) -> None:
+        """List filtered to services."""
+        with patch("castle_cli.commands.list_cmd.load_config") as mock_load:
+            from castle_cli.config import load_config
+
+            mock_load.return_value = load_config(castle_root)
+            args = Namespace(role="service", json=False)
+            result = run_list(args)
+
+        assert result == 0
+        captured = capsys.readouterr()  # type: ignore[attr-defined]
+        assert "test-svc" in captured.out
+        assert "test-tool" not in captured.out
+
+    def test_list_json(self, castle_root: Path, capsys: object) -> None:
+        """List output as JSON."""
+        with patch("castle_cli.commands.list_cmd.load_config") as mock_load:
+            from castle_cli.config import load_config
+
+            mock_load.return_value = load_config(castle_root)
+            args = Namespace(role=None, json=True)
+            result = run_list(args)
+
+        assert result == 0
+        captured = capsys.readouterr()  # type: ignore[attr-defined]
+        data = json.loads(captured.out)
+        names = [p["name"] for p in data]
+        assert "test-svc" in names
+        assert "test-tool" in names
+        svc = next(p for p in data if p["name"] == "test-svc")
+        assert "roles" in svc
+        assert "service" in svc["roles"]

cli/tests/test_manifest.py

@@ -0,0 +1,195 @@
+"""Tests for castle manifest — role derivation, validation."""
+
+from __future__ import annotations
+
+import pytest
+from castle_cli.manifest import (
+    BuildSpec,
+    CaddySpec,
+    ComponentManifest,
+    ExposeSpec,
+    HttpExposeSpec,
+    HttpInternal,
+    InstallSpec,
+    ManageSpec,
+    PathInstallSpec,
+    ProxySpec,
+    Role,
+    RunCommand,
+    RunContainer,
+    RunPythonUvTool,
+    RunRemote,
+    SystemdSpec,
+    ToolSpec,
+    ToolType,
+    TriggerSchedule,
+)
+
+
+class TestRoleDerivation:
+    """Tests for computed role derivation."""
+
+    def test_service_from_expose_http(self) -> None:
+        """Component with expose.http gets SERVICE role."""
+        m = ComponentManifest(
+            id="svc",
+            run=RunPythonUvTool(runner="python_uv_tool", tool="svc"),
+            expose=ExposeSpec(
+                http=HttpExposeSpec(internal=HttpInternal(port=8000))
+            ),
+        )
+        assert Role.SERVICE in m.roles
+
+    def test_tool_from_install_path(self) -> None:
+        """Component with install.path gets TOOL role."""
+        m = ComponentManifest(
+            id="mytool",
+            install=InstallSpec(path=PathInstallSpec(alias="mytool")),
+        )
+        assert Role.TOOL in m.roles
+
+    def test_worker_from_systemd_without_http(self) -> None:
+        """Component managed by systemd but no HTTP gets WORKER role."""
+        m = ComponentManifest(
+            id="worker",
+            run=RunCommand(runner="command", argv=["worker-bin"]),
+            manage=ManageSpec(systemd=SystemdSpec()),
+        )
+        assert Role.WORKER in m.roles
+        assert Role.SERVICE not in m.roles
+
+    def test_container_role(self) -> None:
+        """Container runner gets CONTAINERIZED role."""
+        m = ComponentManifest(
+            id="container",
+            run=RunContainer(runner="container", image="redis:7"),
+        )
+        assert Role.CONTAINERIZED in m.roles
+
+    def test_remote_role(self) -> None:
+        """Remote runner gets REMOTE role."""
+        m = ComponentManifest(
+            id="remote",
+            run=RunRemote(runner="remote", base_url="http://example.com"),
+        )
+        assert Role.REMOTE in m.roles
+
+    def test_job_from_schedule_trigger(self) -> None:
+        """Component with schedule trigger gets JOB role."""
+        m = ComponentManifest(
+            id="job",
+            run=RunCommand(runner="command", argv=["backup"]),
+            triggers=[TriggerSchedule(cron="0 * * * *")],
+        )
+        assert Role.JOB in m.roles
+
+    def test_frontend_from_build(self) -> None:
+        """Component with build outputs gets FRONTEND role."""
+        m = ComponentManifest(
+            id="frontend",
+            run=RunCommand(runner="command", argv=["serve"]),
+            build=BuildSpec(commands=[["pnpm", "build"]], outputs=["dist/"]),
+        )
+        assert Role.FRONTEND in m.roles
+
+    def test_tool_from_tool_spec(self) -> None:
+        """Component with tool spec gets TOOL role."""
+        m = ComponentManifest(
+            id="docx2md",
+            tool=ToolSpec(
+                tool_type=ToolType.PYTHON_UV,
+                category="document",
+                source="tools/document/docx2md.py",
+                entry_point="tools.document.docx2md:main",
+            ),
+        )
+        assert Role.TOOL in m.roles
+
+    def test_tool_spec_without_install(self) -> None:
+        """Tool spec alone is enough for TOOL role, no install.path needed."""
+        m = ComponentManifest(
+            id="my-tool",
+            tool=ToolSpec(category="misc"),
+        )
+        assert Role.TOOL in m.roles
+
+    def test_fallback_to_tool(self) -> None:
+        """Component with no indicators defaults to TOOL."""
+        m = ComponentManifest(id="bare")
+        assert m.roles == [Role.TOOL]
+
+    def test_multiple_roles(self) -> None:
+        """Component can have multiple roles."""
+        m = ComponentManifest(
+            id="multi",
+            run=RunPythonUvTool(runner="python_uv_tool", tool="multi"),
+            expose=ExposeSpec(
+                http=HttpExposeSpec(internal=HttpInternal(port=8000))
+            ),
+            install=InstallSpec(path=PathInstallSpec(alias="multi")),
+        )
+        assert Role.SERVICE in m.roles
+        assert Role.TOOL in m.roles
+
+    def test_systemd_with_http_is_service_not_worker(self) -> None:
+        """Systemd + HTTP = SERVICE, not WORKER."""
+        m = ComponentManifest(
+            id="svc",
+            run=RunPythonUvTool(runner="python_uv_tool", tool="svc"),
+            expose=ExposeSpec(
+                http=HttpExposeSpec(internal=HttpInternal(port=8000))
+            ),
+            manage=ManageSpec(systemd=SystemdSpec()),
+        )
+        assert Role.SERVICE in m.roles
+        assert Role.WORKER not in m.roles
+
+
+class TestConsistencyValidation:
+    """Tests for model validation."""
+
+    def test_remote_with_systemd_raises(self) -> None:
+        """Remote runner + systemd management is invalid."""
+        with pytest.raises(ValueError, match="manage.systemd cannot be enabled for runner=remote"):
+            ComponentManifest(
+                id="bad",
+                run=RunRemote(runner="remote", base_url="http://example.com"),
+                manage=ManageSpec(systemd=SystemdSpec()),
+            )
+
+    def test_no_run_is_valid(self) -> None:
+        """Component with no run spec is valid (registration-only)."""
+        m = ComponentManifest(id="reg-only", description="Just registered")
+        assert m.run is None
+        assert m.roles == [Role.TOOL]
+
+
+class TestModelSerialization:
+    """Tests for model_dump behavior."""
+
+    def test_dump_excludes_none(self) -> None:
+        """model_dump with exclude_none drops None fields."""
+        m = ComponentManifest(id="test", description="Test")
+        data = m.model_dump(exclude_none=True, exclude={"id", "roles"})
+        assert "description" in data
+        assert "run" not in data
+        assert "manage" not in data
+
+    def test_dump_service(self) -> None:
+        """Full service manifest serializes correctly."""
+        m = ComponentManifest(
+            id="svc",
+            description="A service",
+            run=RunPythonUvTool(runner="python_uv_tool", tool="svc", cwd="svc"),
+            expose=ExposeSpec(
+                http=HttpExposeSpec(
+                    internal=HttpInternal(port=9001), health_path="/health"
+                )
+            ),
+            proxy=ProxySpec(caddy=CaddySpec(path_prefix="/svc")),
+            manage=ManageSpec(systemd=SystemdSpec()),
+        )
+        data = m.model_dump(exclude_none=True, exclude={"id", "roles"})
+        assert data["run"]["runner"] == "python_uv_tool"
+        assert data["expose"]["http"]["internal"]["port"] == 9001
+        assert data["proxy"]["caddy"]["path_prefix"] == "/svc"

cli/tests/test_service.py

@@ -0,0 +1,57 @@
+"""Tests for castle service command."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from castle_cli.commands.service import _generate_unit, _unit_name
+from castle_cli.config import load_config
+
+
+class TestUnitName:
+    """Tests for systemd unit naming."""
+
+    def test_unit_name_format(self) -> None:
+        """Unit names follow castle-<name>.service pattern."""
+        assert _unit_name("central-context") == "castle-central-context.service"
+        assert _unit_name("my-svc") == "castle-my-svc.service"
+
+
+class TestUnitGeneration:
+    """Tests for systemd unit file generation."""
+
+    def test_contains_description(self, castle_root: Path) -> None:
+        """Unit file has service description."""
+        config = load_config(castle_root)
+        manifest = config.components["test-svc"]
+        unit = _generate_unit(config, "test-svc", manifest)
+        assert "Description=Castle: Test service" in unit
+
+    def test_contains_working_dir(self, castle_root: Path) -> None:
+        """Unit file has correct working directory."""
+        config = load_config(castle_root)
+        manifest = config.components["test-svc"]
+        unit = _generate_unit(config, "test-svc", manifest)
+        assert f"WorkingDirectory={castle_root / 'test-svc'}" in unit
+
+    def test_contains_environment(self, castle_root: Path) -> None:
+        """Unit file has environment variables."""
+        config = load_config(castle_root)
+        manifest = config.components["test-svc"]
+        unit = _generate_unit(config, "test-svc", manifest)
+        expected_data_dir = str(castle_root / "data" / "test-svc")
+        assert f"Environment=TEST_SVC_DATA_DIR={expected_data_dir}" in unit
+
+    def test_contains_restart_policy(self, castle_root: Path) -> None:
+        """Unit file has restart configuration."""
+        config = load_config(castle_root)
+        manifest = config.components["test-svc"]
+        unit = _generate_unit(config, "test-svc", manifest)
+        assert "Restart=on-failure" in unit
+
+    def test_uses_uv_run(self, castle_root: Path) -> None:
+        """Unit file ExecStart uses uv run for python_uv_tool."""
+        config = load_config(castle_root)
+        manifest = config.components["test-svc"]
+        unit = _generate_unit(config, "test-svc", manifest)
+        assert "run test-svc" in unit

cli/uv.lock

@@ -0,0 +1,425 @@
+version = 1
+revision = 3
+requires-python = ">=3.11"
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "castle-cli"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "jinja2" },
+    { name = "pydantic" },
+    { name = "pyyaml" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "pyright" },
+    { name = "pytest" },
+    { name = "ruff" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "jinja2", specifier = ">=3.1.0" },
+    { name = "pydantic", specifier = ">=2.0.0" },
+    { name = "pyyaml", specifier = ">=6.0.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "pyright", specifier = ">=1.1.0" },
+    { name = "pytest", specifier = ">=7.0.0" },
+    { name = "ruff", specifier = ">=0.11.0" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "jinja2"
+version = "3.1.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },
+]
+
+[[package]]
+name = "markupsafe"
+version = "3.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/08/db/fefacb2136439fc8dd20e797950e749aa1f4997ed584c62cfb8ef7c2be0e/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad", size = 11631, upload-time = "2025-09-27T18:36:18.185Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/2e/5898933336b61975ce9dc04decbc0a7f2fee78c30353c5efba7f2d6ff27a/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a", size = 12058, upload-time = "2025-09-27T18:36:19.444Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/09/adf2df3699d87d1d8184038df46a9c80d78c0148492323f4693df54e17bb/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50", size = 24287, upload-time = "2025-09-27T18:36:20.768Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ac/0273f6fcb5f42e314c6d8cd99effae6a5354604d461b8d392b5ec9530a54/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf", size = 22940, upload-time = "2025-09-27T18:36:22.249Z" },
+    { url = "https://files.pythonhosted.org/packages/19/ae/31c1be199ef767124c042c6c3e904da327a2f7f0cd63a0337e1eca2967a8/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f", size = 21887, upload-time = "2025-09-27T18:36:23.535Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/76/7edcab99d5349a4532a459e1fe64f0b0467a3365056ae550d3bcf3f79e1e/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a", size = 23692, upload-time = "2025-09-27T18:36:24.823Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/28/6e74cdd26d7514849143d69f0bf2399f929c37dc2b31e6829fd2045b2765/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115", size = 21471, upload-time = "2025-09-27T18:36:25.95Z" },
+    { url = "https://files.pythonhosted.org/packages/62/7e/a145f36a5c2945673e590850a6f8014318d5577ed7e5920a4b3448e0865d/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a", size = 22923, upload-time = "2025-09-27T18:36:27.109Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/62/d9c46a7f5c9adbeeeda52f5b8d802e1094e9717705a645efc71b0913a0a8/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19", size = 14572, upload-time = "2025-09-27T18:36:28.045Z" },
+    { url = "https://files.pythonhosted.org/packages/83/8a/4414c03d3f891739326e1783338e48fb49781cc915b2e0ee052aa490d586/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01", size = 15077, upload-time = "2025-09-27T18:36:29.025Z" },
+    { url = "https://files.pythonhosted.org/packages/35/73/893072b42e6862f319b5207adc9ae06070f095b358655f077f69a35601f0/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c", size = 13876, upload-time = "2025-09-27T18:36:29.954Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" },
+    { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" },
+    { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" },
+    { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" },
+    { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" },
+    { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" },
+    { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" },
+    { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" },
+    { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" },
+    { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" },
+    { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" },
+    { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" },
+    { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" },
+    { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" },
+    { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" },
+    { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" },
+    { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" },
+    { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" },
+    { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" },
+    { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" },
+    { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" },
+]
+
+[[package]]
+name = "nodeenv"
+version = "1.10.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/bf/d1bda4f6168e0b2e9e5958945e01910052158313224ada5ce1fb2e1113b8/nodeenv-1.10.0.tar.gz", hash = "sha256:996c191ad80897d076bdfba80a41994c2b47c68e224c542b48feba42ba00f8bb", size = 55611, upload-time = "2025-12-20T14:08:54.006Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.12.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.41.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e8/72/74a989dd9f2084b3d9530b0915fdda64ac48831c30dbf7c72a41a5232db8/pydantic_core-2.41.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a3a52f6156e73e7ccb0f8cced536adccb7042be67cb45f9562e12b319c119da6", size = 2105873, upload-time = "2025-11-04T13:39:31.373Z" },
+    { url = "https://files.pythonhosted.org/packages/12/44/37e403fd9455708b3b942949e1d7febc02167662bf1a7da5b78ee1ea2842/pydantic_core-2.41.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7f3bf998340c6d4b0c9a2f02d6a400e51f123b59565d74dc60d252ce888c260b", size = 1899826, upload-time = "2025-11-04T13:39:32.897Z" },
+    { url = "https://files.pythonhosted.org/packages/33/7f/1d5cab3ccf44c1935a359d51a8a2a9e1a654b744b5e7f80d41b88d501eec/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:378bec5c66998815d224c9ca994f1e14c0c21cb95d2f52b6021cc0b2a58f2a5a", size = 1917869, upload-time = "2025-11-04T13:39:34.469Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/6a/30d94a9674a7fe4f4744052ed6c5e083424510be1e93da5bc47569d11810/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7b576130c69225432866fe2f4a469a85a54ade141d96fd396dffcf607b558f8", size = 2063890, upload-time = "2025-11-04T13:39:36.053Z" },
+    { url = "https://files.pythonhosted.org/packages/50/be/76e5d46203fcb2750e542f32e6c371ffa9b8ad17364cf94bb0818dbfb50c/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6cb58b9c66f7e4179a2d5e0f849c48eff5c1fca560994d6eb6543abf955a149e", size = 2229740, upload-time = "2025-11-04T13:39:37.753Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/ee/fed784df0144793489f87db310a6bbf8118d7b630ed07aa180d6067e653a/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88942d3a3dff3afc8288c21e565e476fc278902ae4d6d134f1eeda118cc830b1", size = 2350021, upload-time = "2025-11-04T13:39:40.94Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/be/8fed28dd0a180dca19e72c233cbf58efa36df055e5b9d90d64fd1740b828/pydantic_core-2.41.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f31d95a179f8d64d90f6831d71fa93290893a33148d890ba15de25642c5d075b", size = 2066378, upload-time = "2025-11-04T13:39:42.523Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/3b/698cf8ae1d536a010e05121b4958b1257f0b5522085e335360e53a6b1c8b/pydantic_core-2.41.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c1df3d34aced70add6f867a8cf413e299177e0c22660cc767218373d0779487b", size = 2175761, upload-time = "2025-11-04T13:39:44.553Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/ba/15d537423939553116dea94ce02f9c31be0fa9d0b806d427e0308ec17145/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4009935984bd36bd2c774e13f9a09563ce8de4abaa7226f5108262fa3e637284", size = 2146303, upload-time = "2025-11-04T13:39:46.238Z" },
+    { url = "https://files.pythonhosted.org/packages/58/7f/0de669bf37d206723795f9c90c82966726a2ab06c336deba4735b55af431/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:34a64bc3441dc1213096a20fe27e8e128bd3ff89921706e83c0b1ac971276594", size = 2340355, upload-time = "2025-11-04T13:39:48.002Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/de/e7482c435b83d7e3c3ee5ee4451f6e8973cff0eb6007d2872ce6383f6398/pydantic_core-2.41.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c9e19dd6e28fdcaa5a1de679aec4141f691023916427ef9bae8584f9c2fb3b0e", size = 2319875, upload-time = "2025-11-04T13:39:49.705Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/e6/8c9e81bb6dd7560e33b9053351c29f30c8194b72f2d6932888581f503482/pydantic_core-2.41.5-cp311-cp311-win32.whl", hash = "sha256:2c010c6ded393148374c0f6f0bf89d206bf3217f201faa0635dcd56bd1520f6b", size = 1987549, upload-time = "2025-11-04T13:39:51.842Z" },
+    { url = "https://files.pythonhosted.org/packages/11/66/f14d1d978ea94d1bc21fc98fcf570f9542fe55bfcc40269d4e1a21c19bf7/pydantic_core-2.41.5-cp311-cp311-win_amd64.whl", hash = "sha256:76ee27c6e9c7f16f47db7a94157112a2f3a00e958bc626e2f4ee8bec5c328fbe", size = 2011305, upload-time = "2025-11-04T13:39:53.485Z" },
+    { url = "https://files.pythonhosted.org/packages/56/d8/0e271434e8efd03186c5386671328154ee349ff0354d83c74f5caaf096ed/pydantic_core-2.41.5-cp311-cp311-win_arm64.whl", hash = "sha256:4bc36bbc0b7584de96561184ad7f012478987882ebf9f9c389b23f432ea3d90f", size = 1972902, upload-time = "2025-11-04T13:39:56.488Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/5d/5f6c63eebb5afee93bcaae4ce9a898f3373ca23df3ccaef086d0233a35a7/pydantic_core-2.41.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:f41a7489d32336dbf2199c8c0a215390a751c5b014c2c1c5366e817202e9cdf7", size = 2110990, upload-time = "2025-11-04T13:39:58.079Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/32/9c2e8ccb57c01111e0fd091f236c7b371c1bccea0fa85247ac55b1e2b6b6/pydantic_core-2.41.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070259a8818988b9a84a449a2a7337c7f430a22acc0859c6b110aa7212a6d9c0", size = 1896003, upload-time = "2025-11-04T13:39:59.956Z" },
+    { url = "https://files.pythonhosted.org/packages/68/b8/a01b53cb0e59139fbc9e4fda3e9724ede8de279097179be4ff31f1abb65a/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e96cea19e34778f8d59fe40775a7a574d95816eb150850a85a7a4c8f4b94ac69", size = 1919200, upload-time = "2025-11-04T13:40:02.241Z" },
+    { url = "https://files.pythonhosted.org/packages/38/de/8c36b5198a29bdaade07b5985e80a233a5ac27137846f3bc2d3b40a47360/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ed2e99c456e3fadd05c991f8f437ef902e00eedf34320ba2b0842bd1c3ca3a75", size = 2052578, upload-time = "2025-11-04T13:40:04.401Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b5/0e8e4b5b081eac6cb3dbb7e60a65907549a1ce035a724368c330112adfdd/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:65840751b72fbfd82c3c640cff9284545342a4f1eb1586ad0636955b261b0b05", size = 2208504, upload-time = "2025-11-04T13:40:06.072Z" },
+    { url = "https://files.pythonhosted.org/packages/77/56/87a61aad59c7c5b9dc8caad5a41a5545cba3810c3e828708b3d7404f6cef/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e536c98a7626a98feb2d3eaf75944ef6f3dbee447e1f841eae16f2f0a72d8ddc", size = 2335816, upload-time = "2025-11-04T13:40:07.835Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/76/941cc9f73529988688a665a5c0ecff1112b3d95ab48f81db5f7606f522d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eceb81a8d74f9267ef4081e246ffd6d129da5d87e37a77c9bde550cb04870c1c", size = 2075366, upload-time = "2025-11-04T13:40:09.804Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/43/ebef01f69baa07a482844faaa0a591bad1ef129253ffd0cdaa9d8a7f72d3/pydantic_core-2.41.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d38548150c39b74aeeb0ce8ee1d8e82696f4a4e16ddc6de7b1d8823f7de4b9b5", size = 2171698, upload-time = "2025-11-04T13:40:12.004Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/87/41f3202e4193e3bacfc2c065fab7706ebe81af46a83d3e27605029c1f5a6/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c23e27686783f60290e36827f9c626e63154b82b116d7fe9adba1fda36da706c", size = 2132603, upload-time = "2025-11-04T13:40:13.868Z" },
+    { url = "https://files.pythonhosted.org/packages/49/7d/4c00df99cb12070b6bccdef4a195255e6020a550d572768d92cc54dba91a/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:482c982f814460eabe1d3bb0adfdc583387bd4691ef00b90575ca0d2b6fe2294", size = 2329591, upload-time = "2025-11-04T13:40:15.672Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/6a/ebf4b1d65d458f3cda6a7335d141305dfa19bdc61140a884d165a8a1bbc7/pydantic_core-2.41.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bfea2a5f0b4d8d43adf9d7b8bf019fb46fdd10a2e5cde477fbcb9d1fa08c68e1", size = 2319068, upload-time = "2025-11-04T13:40:17.532Z" },
+    { url = "https://files.pythonhosted.org/packages/49/3b/774f2b5cd4192d5ab75870ce4381fd89cf218af999515baf07e7206753f0/pydantic_core-2.41.5-cp312-cp312-win32.whl", hash = "sha256:b74557b16e390ec12dca509bce9264c3bbd128f8a2c376eaa68003d7f327276d", size = 1985908, upload-time = "2025-11-04T13:40:19.309Z" },
+    { url = "https://files.pythonhosted.org/packages/86/45/00173a033c801cacf67c190fef088789394feaf88a98a7035b0e40d53dc9/pydantic_core-2.41.5-cp312-cp312-win_amd64.whl", hash = "sha256:1962293292865bca8e54702b08a4f26da73adc83dd1fcf26fbc875b35d81c815", size = 2020145, upload-time = "2025-11-04T13:40:21.548Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/22/91fbc821fa6d261b376a3f73809f907cec5ca6025642c463d3488aad22fb/pydantic_core-2.41.5-cp312-cp312-win_arm64.whl", hash = "sha256:1746d4a3d9a794cacae06a5eaaccb4b8643a131d45fbc9af23e353dc0a5ba5c3", size = 1976179, upload-time = "2025-11-04T13:40:23.393Z" },
+    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },
+    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },
+    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },
+    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },
+    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
+    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
+    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
+    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
+    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
+    { url = "https://files.pythonhosted.org/packages/11/72/90fda5ee3b97e51c494938a4a44c3a35a9c96c19bba12372fb9c634d6f57/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:b96d5f26b05d03cc60f11a7761a5ded1741da411e7fe0909e27a5e6a0cb7b034", size = 2115441, upload-time = "2025-11-04T13:42:39.557Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/53/8942f884fa33f50794f119012dc6a1a02ac43a56407adaac20463df8e98f/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:634e8609e89ceecea15e2d61bc9ac3718caaaa71963717bf3c8f38bfde64242c", size = 1930291, upload-time = "2025-11-04T13:42:42.169Z" },
+    { url = "https://files.pythonhosted.org/packages/79/c8/ecb9ed9cd942bce09fc888ee960b52654fbdbede4ba6c2d6e0d3b1d8b49c/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93e8740d7503eb008aa2df04d3b9735f845d43ae845e6dcd2be0b55a2da43cd2", size = 1948632, upload-time = "2025-11-04T13:42:44.564Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/1b/687711069de7efa6af934e74f601e2a4307365e8fdc404703afc453eab26/pydantic_core-2.41.5-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f15489ba13d61f670dcc96772e733aad1a6f9c429cc27574c6cdaed82d0146ad", size = 2138905, upload-time = "2025-11-04T13:42:47.156Z" },
+    { url = "https://files.pythonhosted.org/packages/09/32/59b0c7e63e277fa7911c2fc70ccfb45ce4b98991e7ef37110663437005af/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:7da7087d756b19037bc2c06edc6c170eeef3c3bafcb8f532ff17d64dc427adfd", size = 2110495, upload-time = "2025-11-04T13:42:49.689Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/81/05e400037eaf55ad400bcd318c05bb345b57e708887f07ddb2d20e3f0e98/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:aabf5777b5c8ca26f7824cb4a120a740c9588ed58df9b2d196ce92fba42ff8dc", size = 1915388, upload-time = "2025-11-04T13:42:52.215Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/0d/e3549b2399f71d56476b77dbf3cf8937cec5cd70536bdc0e374a421d0599/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c007fe8a43d43b3969e8469004e9845944f1a80e6acd47c150856bb87f230c56", size = 1942879, upload-time = "2025-11-04T13:42:56.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/07/34573da085946b6a313d7c42f82f16e8920bfd730665de2d11c0c37a74b5/pydantic_core-2.41.5-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76d0819de158cd855d1cbb8fcafdf6f5cf1eb8e470abe056d5d161106e38062b", size = 2139017, upload-time = "2025-11-04T13:42:59.471Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/9b/1b3f0e9f9305839d7e84912f9e8bfbd191ed1b1ef48083609f0dabde978c/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:b2379fa7ed44ddecb5bfe4e48577d752db9fc10be00a6b7446e9663ba143de26", size = 2101980, upload-time = "2025-11-04T13:43:25.97Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/ed/d71fefcb4263df0da6a85b5d8a7508360f2f2e9b3bf5814be9c8bccdccc1/pydantic_core-2.41.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:266fb4cbf5e3cbd0b53669a6d1b039c45e3ce651fd5442eff4d07c2cc8d66808", size = 1923865, upload-time = "2025-11-04T13:43:28.763Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/3a/626b38db460d675f873e4444b4bb030453bbe7b4ba55df821d026a0493c4/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58133647260ea01e4d0500089a8c4f07bd7aa6ce109682b1426394988d8aaacc", size = 2134256, upload-time = "2025-11-04T13:43:31.71Z" },
+    { url = "https://files.pythonhosted.org/packages/83/d9/8412d7f06f616bbc053d30cb4e5f76786af3221462ad5eee1f202021eb4e/pydantic_core-2.41.5-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:287dad91cfb551c363dc62899a80e9e14da1f0e2b6ebde82c806612ca2a13ef1", size = 2174762, upload-time = "2025-11-04T13:43:34.744Z" },
+    { url = "https://files.pythonhosted.org/packages/55/4c/162d906b8e3ba3a99354e20faa1b49a85206c47de97a639510a0e673f5da/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:03b77d184b9eb40240ae9fd676ca364ce1085f203e1b1256f8ab9984dca80a84", size = 2143141, upload-time = "2025-11-04T13:43:37.701Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f2/f11dd73284122713f5f89fc940f370d035fa8e1e078d446b3313955157fe/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a668ce24de96165bb239160b3d854943128f4334822900534f2fe947930e5770", size = 2330317, upload-time = "2025-11-04T13:43:40.406Z" },
+    { url = "https://files.pythonhosted.org/packages/88/9d/b06ca6acfe4abb296110fb1273a4d848a0bfb2ff65f3ee92127b3244e16b/pydantic_core-2.41.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f14f8f046c14563f8eb3f45f499cc658ab8d10072961e07225e507adb700e93f", size = 2316992, upload-time = "2025-11-04T13:43:43.602Z" },
+    { url = "https://files.pythonhosted.org/packages/36/c7/cfc8e811f061c841d7990b0201912c3556bfeb99cdcb7ed24adc8d6f8704/pydantic_core-2.41.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:56121965f7a4dc965bff783d70b907ddf3d57f6eba29b6d2e5dabfaf07799c51", size = 2145302, upload-time = "2025-11-04T13:43:46.64Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pyright"
+version = "1.1.408"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nodeenv" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/74/b2/5db700e52554b8f025faa9c3c624c59f1f6c8841ba81ab97641b54322f16/pyright-1.1.408.tar.gz", hash = "sha256:f28f2321f96852fa50b5829ea492f6adb0e6954568d1caa3f3af3a5f555eb684", size = 4400578, upload-time = "2026-01-08T08:07:38.795Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/82/a2c93e32800940d9573fb28c346772a14778b84ba7524e691b324620ab89/pyright-1.1.408-py3-none-any.whl", hash = "sha256:090b32865f4fdb1e0e6cd82bf5618480d48eecd2eb2e70f960982a3d9a4c17c1", size = 6399144, upload-time = "2026-01-08T08:07:37.082Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
+    { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
+    { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
+    { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
+    { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.15.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/06/04/eab13a954e763b0606f460443fcbf6bb5a0faf06890ea3754ff16523dce5/ruff-0.15.2.tar.gz", hash = "sha256:14b965afee0969e68bb871eba625343b8673375f457af4abe98553e8bbb98342", size = 4558148, upload-time = "2026-02-19T22:32:20.271Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2f/70/3a4dc6d09b13cb3e695f28307e5d889b2e1a66b7af9c5e257e796695b0e6/ruff-0.15.2-py3-none-linux_armv6l.whl", hash = "sha256:120691a6fdae2f16d65435648160f5b81a9625288f75544dc40637436b5d3c0d", size = 10430565, upload-time = "2026-02-19T22:32:41.824Z" },
+    { url = "https://files.pythonhosted.org/packages/71/0b/bb8457b56185ece1305c666dc895832946d24055be90692381c31d57466d/ruff-0.15.2-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:a89056d831256099658b6bba4037ac6dd06f49d194199215befe2bb10457ea5e", size = 10820354, upload-time = "2026-02-19T22:32:07.366Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/c1/e0532d7f9c9e0b14c46f61b14afd563298b8b83f337b6789ddd987e46121/ruff-0.15.2-py3-none-macosx_11_0_arm64.whl", hash = "sha256:e36dee3a64be0ebd23c86ffa3aa3fd3ac9a712ff295e192243f814a830b6bd87", size = 10170767, upload-time = "2026-02-19T22:32:13.188Z" },
+    { url = "https://files.pythonhosted.org/packages/47/e8/da1aa341d3af017a21c7a62fb5ec31d4e7ad0a93ab80e3a508316efbcb23/ruff-0.15.2-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9fb47b6d9764677f8c0a193c0943ce9a05d6763523f132325af8a858eadc2b9", size = 10529591, upload-time = "2026-02-19T22:32:02.547Z" },
+    { url = "https://files.pythonhosted.org/packages/93/74/184fbf38e9f3510231fbc5e437e808f0b48c42d1df9434b208821efcd8d6/ruff-0.15.2-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f376990f9d0d6442ea9014b19621d8f2aaf2b8e39fdbfc79220b7f0c596c9b80", size = 10260771, upload-time = "2026-02-19T22:32:36.938Z" },
+    { url = "https://files.pythonhosted.org/packages/05/ac/605c20b8e059a0bc4b42360414baa4892ff278cec1c91fff4be0dceedefd/ruff-0.15.2-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2dcc987551952d73cbf5c88d9fdee815618d497e4df86cd4c4824cc59d5dd75f", size = 11045791, upload-time = "2026-02-19T22:32:31.642Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/52/db6e419908f45a894924d410ac77d64bdd98ff86901d833364251bd08e22/ruff-0.15.2-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:42a47fd785cbe8c01b9ff45031af875d101b040ad8f4de7bbb716487c74c9a77", size = 11879271, upload-time = "2026-02-19T22:32:29.305Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/d8/7992b18f2008bdc9231d0f10b16df7dda964dbf639e2b8b4c1b4e91b83af/ruff-0.15.2-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cbe9f49354866e575b4c6943856989f966421870e85cd2ac94dccb0a9dcb2fea", size = 11303707, upload-time = "2026-02-19T22:32:22.492Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/02/849b46184bcfdd4b64cde61752cc9a146c54759ed036edd11857e9b8443b/ruff-0.15.2-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b7a672c82b5f9887576087d97be5ce439f04bbaf548ee987b92d3a7dede41d3a", size = 11149151, upload-time = "2026-02-19T22:32:44.234Z" },
+    { url = "https://files.pythonhosted.org/packages/70/04/f5284e388bab60d1d3b99614a5a9aeb03e0f333847e2429bebd2aaa1feec/ruff-0.15.2-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:72ecc64f46f7019e2bcc3cdc05d4a7da958b629a5ab7033195e11a438403d956", size = 11091132, upload-time = "2026-02-19T22:32:24.691Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/ae/88d844a21110e14d92cf73d57363fab59b727ebeabe78009b9ccb23500af/ruff-0.15.2-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:8dcf243b15b561c655c1ef2f2b0050e5d50db37fe90115507f6ff37d865dc8b4", size = 10504717, upload-time = "2026-02-19T22:32:26.75Z" },
+    { url = "https://files.pythonhosted.org/packages/64/27/867076a6ada7f2b9c8292884ab44d08fd2ba71bd2b5364d4136f3cd537e1/ruff-0.15.2-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:dab6941c862c05739774677c6273166d2510d254dac0695c0e3f5efa1b5585de", size = 10263122, upload-time = "2026-02-19T22:32:10.036Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/ef/faf9321d550f8ebf0c6373696e70d1758e20ccdc3951ad7af00c0956be7c/ruff-0.15.2-py3-none-musllinux_1_2_i686.whl", hash = "sha256:1b9164f57fc36058e9a6806eb92af185b0697c9fe4c7c52caa431c6554521e5c", size = 10735295, upload-time = "2026-02-19T22:32:39.227Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/55/e8089fec62e050ba84d71b70e7834b97709ca9b7aba10c1a0b196e493f97/ruff-0.15.2-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:80d24fcae24d42659db7e335b9e1531697a7102c19185b8dc4a028b952865fd8", size = 11241641, upload-time = "2026-02-19T22:32:34.617Z" },
+    { url = "https://files.pythonhosted.org/packages/23/01/1c30526460f4d23222d0fabd5888868262fd0e2b71a00570ca26483cd993/ruff-0.15.2-py3-none-win32.whl", hash = "sha256:fd5ff9e5f519a7e1bd99cbe8daa324010a74f5e2ebc97c6242c08f26f3714f6f", size = 10507885, upload-time = "2026-02-19T22:32:15.635Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/10/3d18e3bbdf8fc50bbb4ac3cc45970aa5a9753c5cb51bf9ed9a3cd8b79fa3/ruff-0.15.2-py3-none-win_amd64.whl", hash = "sha256:d20014e3dfa400f3ff84830dfb5755ece2de45ab62ecea4af6b7262d0fb4f7c5", size = 11623725, upload-time = "2026-02-19T22:32:04.947Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/78/097c0798b1dab9f8affe73da9642bb4500e098cb27fd8dc9724816ac747b/ruff-0.15.2-py3-none-win_arm64.whl", hash = "sha256:cabddc5822acdc8f7b5527b36ceac55cc51eec7b1946e60181de8fe83ca8876e", size = 10941649, upload-time = "2026-02-19T22:32:18.108Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]

dashboard-api/CLAUDE.md

@@ -0,0 +1,31 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working
+with code in this repository.
+
+## Overview
+
+dashboard-api is a FastAPI service. Castle dashboard API.
+
+## Commands
+
+```bash
+uv sync                     # Install dependencies
+uv run dashboard-api              # Run service (port 9020)
+uv run pytest tests/ -v     # Run tests
+uv run ruff check .         # Lint
+uv run ruff format .        # Format
+```
+
+## Architecture
+
+- `src/dashboard_api/config.py` — Settings via pydantic-settings, env prefix `DASHBOARD_API_`
+- `src/dashboard_api/main.py` — FastAPI app, lifespan, health endpoint
+- `tests/` — pytest with TestClient fixtures
+
+## Configuration
+
+Environment variables with `DASHBOARD_API_` prefix:
+- `DASHBOARD_API_DATA_DIR` — Data directory (default: ./data)
+- `DASHBOARD_API_HOST` — Bind host (default: 0.0.0.0)
+- `DASHBOARD_API_PORT` — Port (default: 9020)

dashboard-api/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "dashboard-api"
+version = "0.1.0"
+description = "Castle dashboard API"
+requires-python = ">=3.13"
+dependencies = [
+    "fastapi>=0.115.0",
+    "uvicorn>=0.34.0",
+    "pydantic-settings>=2.0.0",
+    "httpx>=0.27.0",
+    "castle-cli",
+]
+
+[tool.uv.sources]
+castle-cli = { path = "../cli", editable = true }
+
+[project.scripts]
+dashboard-api = "dashboard_api.main:run"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dashboard_api"]
+
+[dependency-groups]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.23.0",
+    "httpx>=0.27.0",
+    "pyyaml>=6.0.0",
+]
+
+[tool.ruff.lint.isort]
+known-first-party = ["dashboard_api"]

dashboard-api/src/dashboard_api/__init__.py

@@ -0,0 +1,3 @@
+"""Castle dashboard API."""
+
+__version__ = "0.1.0"

dashboard-api/src/dashboard_api/bus.py

@@ -0,0 +1,121 @@
+"""Event bus core — in-memory subscription table and HTTP fan-out delivery."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Subscription:
+    """A subscription to a topic."""
+
+    topic: str
+    callback_url: str
+    subscriber: str = ""  # optional label for debugging
+
+
+@dataclass
+class EventBus:
+    """In-memory event bus with HTTP fan-out delivery."""
+
+    subscriptions: dict[str, list[Subscription]] = field(default_factory=dict)
+    _client: httpx.AsyncClient | None = field(default=None, repr=False)
+
+    async def start(self) -> None:
+        """Initialize the HTTP client."""
+        self._client = httpx.AsyncClient(timeout=10.0)
+
+    async def stop(self) -> None:
+        """Close the HTTP client."""
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    def subscribe(self, topic: str, callback_url: str, subscriber: str = "") -> None:
+        """Register a subscription to a topic."""
+        if topic not in self.subscriptions:
+            self.subscriptions[topic] = []
+
+        # Don't duplicate
+        for sub in self.subscriptions[topic]:
+            if sub.callback_url == callback_url:
+                return
+
+        self.subscriptions[topic].append(
+            Subscription(topic=topic, callback_url=callback_url, subscriber=subscriber)
+        )
+        logger.info("Subscribed %s to topic '%s' -> %s", subscriber, topic, callback_url)
+
+    def unsubscribe(self, topic: str, callback_url: str) -> bool:
+        """Remove a subscription. Returns True if found and removed."""
+        if topic not in self.subscriptions:
+            return False
+
+        before = len(self.subscriptions[topic])
+        self.subscriptions[topic] = [
+            s for s in self.subscriptions[topic] if s.callback_url != callback_url
+        ]
+        removed = len(self.subscriptions[topic]) < before
+
+        if not self.subscriptions[topic]:
+            del self.subscriptions[topic]
+
+        return removed
+
+    async def publish(self, topic: str, payload: dict) -> int:
+        """Publish an event to all subscribers. Returns number of subscribers notified."""
+        subscribers = self.subscriptions.get(topic, [])
+        if not subscribers:
+            return 0
+
+        event = {
+            "topic": topic,
+            "payload": payload,
+            "published_at": datetime.now(timezone.utc).isoformat(),
+        }
+
+        # Fan out to all subscribers concurrently, fire-and-forget style
+        tasks = [self._deliver(sub, event) for sub in subscribers]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        delivered = sum(1 for r in results if r is True)
+        return delivered
+
+    async def _deliver(self, sub: Subscription, event: dict) -> bool:
+        """Deliver an event to a single subscriber."""
+        if not self._client:
+            logger.error("HTTP client not initialized")
+            return False
+
+        try:
+            response = await self._client.post(sub.callback_url, json=event)
+            if response.status_code < 300:
+                return True
+            logger.warning(
+                "Delivery to %s returned %d", sub.callback_url, response.status_code
+            )
+            return False
+        except Exception:
+            logger.warning("Delivery to %s failed", sub.callback_url, exc_info=True)
+            return False
+
+    def list_topics(self) -> dict[str, list[dict]]:
+        """List all topics and their subscribers."""
+        return {
+            topic: [
+                {"callback_url": s.callback_url, "subscriber": s.subscriber}
+                for s in subs
+            ]
+            for topic, subs in self.subscriptions.items()
+        }
+
+
+# Singleton instance
+bus = EventBus()

dashboard-api/src/dashboard_api/config.py

@@ -0,0 +1,21 @@
+"""Configuration for dashboard-api."""
+
+from pathlib import Path
+
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    """Service settings loaded from environment variables."""
+
+    castle_root: Path = Path("/data/repos/castle")
+    host: str = "0.0.0.0"
+    port: int = 9020
+
+    model_config = {
+        "env_prefix": "DASHBOARD_API_",
+        "env_file": ".env",
+    }
+
+
+settings = Settings()

dashboard-api/src/dashboard_api/config_editor.py

@@ -0,0 +1,189 @@
+"""Config editor — read, validate, save, and apply castle.yaml changes."""
+
+from __future__ import annotations
+
+import asyncio
+import shutil
+
+import yaml
+from fastapi import APIRouter, HTTPException, status
+from pydantic import BaseModel
+
+from castle_cli.config import load_config, save_config
+from castle_cli.manifest import ComponentManifest
+
+from dashboard_api.config import settings
+from dashboard_api.stream import broadcast
+
+router = APIRouter(prefix="/config", tags=["config"])
+
+
+class ConfigResponse(BaseModel):
+    yaml_content: str
+
+
+class ConfigSaveRequest(BaseModel):
+    yaml_content: str
+
+
+class ConfigSaveResponse(BaseModel):
+    ok: bool
+    component_count: int
+    errors: list[str]
+
+
+class ApplyResponse(BaseModel):
+    ok: bool
+    actions: list[str]
+    errors: list[str]
+
+
+class ComponentConfigRequest(BaseModel):
+    config: dict
+
+
+@router.get("", response_model=ConfigResponse)
+def get_config() -> ConfigResponse:
+    """Get the raw castle.yaml content."""
+    config_path = settings.castle_root / "castle.yaml"
+    return ConfigResponse(yaml_content=config_path.read_text())
+
+
+@router.put("", response_model=ConfigSaveResponse)
+def save_yaml(request: ConfigSaveRequest) -> ConfigSaveResponse:
+    """Validate and save castle.yaml. Does NOT apply changes."""
+    errors: list[str] = []
+
+    # Parse YAML
+    try:
+        data = yaml.safe_load(request.yaml_content)
+    except yaml.YAMLError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"Invalid YAML: {e}",
+        )
+
+    if not isinstance(data, dict) or "components" not in data:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="YAML must have a 'components' key",
+        )
+
+    # Validate each component
+    count = 0
+    for name, comp_data in data.get("components", {}).items():
+        try:
+            comp_data_copy = dict(comp_data) if comp_data else {}
+            comp_data_copy["id"] = name
+            ComponentManifest.model_validate(comp_data_copy)
+            count += 1
+        except Exception as e:
+            errors.append(f"{name}: {e}")
+
+    if errors:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail={"errors": errors},
+        )
+
+    # Backup and save
+    config_path = settings.castle_root / "castle.yaml"
+    backup_path = config_path.with_suffix(".yaml.bak")
+    shutil.copy2(config_path, backup_path)
+    config_path.write_text(request.yaml_content)
+
+    return ConfigSaveResponse(ok=True, component_count=count, errors=[])
+
+
+@router.put("/components/{name}")
+def save_component(name: str, request: ComponentConfigRequest) -> dict:
+    """Update a single component's config in castle.yaml."""
+    # Validate
+    try:
+        comp_data = dict(request.config)
+        comp_data["id"] = name
+        ComponentManifest.model_validate(comp_data)
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"Invalid component config: {e}",
+        )
+
+    config = load_config(settings.castle_root)
+    config.components[name] = ComponentManifest.model_validate(
+        {**request.config, "id": name}
+    )
+    save_config(config)
+    return {"ok": True, "component": name}
+
+
+@router.delete("/components/{name}")
+def delete_component(name: str) -> dict:
+    """Remove a component from castle.yaml."""
+    config = load_config(settings.castle_root)
+    if name not in config.components:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Component '{name}' not found",
+        )
+    del config.components[name]
+    save_config(config)
+    return {"ok": True, "component": name, "action": "deleted"}
+
+
+@router.post("/apply", response_model=ApplyResponse)
+async def apply_config() -> ApplyResponse:
+    """Apply config: regenerate systemd units for managed services + reload gateway."""
+    config = load_config(settings.castle_root)
+    actions: list[str] = []
+    errors: list[str] = []
+
+    # Regenerate and restart managed services
+    for name in config.managed:
+        unit = f"castle-{name}.service"
+        ok, output = await _systemctl("restart", unit)
+        if ok:
+            actions.append(f"Restarted {name}")
+        else:
+            errors.append(f"Failed to restart {name}: {output}")
+
+    # Reload gateway
+    from castle_cli.commands.gateway import _generate_caddyfile
+    from castle_cli.config import GENERATED_DIR, ensure_dirs
+
+    ensure_dirs()
+    caddyfile_path = GENERATED_DIR / "Caddyfile"
+    caddyfile_path.write_text(_generate_caddyfile(config))
+    actions.append("Generated Caddyfile")
+
+    if shutil.which("caddy"):
+        ok, output = await _run("caddy", "reload",
+                                "--config", str(caddyfile_path),
+                                "--adapter", "caddyfile")
+        if ok:
+            actions.append("Reloaded gateway")
+        else:
+            errors.append(f"Gateway reload failed: {output}")
+
+    await broadcast("config-changed", {"actions": actions})
+    return ApplyResponse(ok=len(errors) == 0, actions=actions, errors=errors)
+
+
+async def _systemctl(action: str, unit: str) -> tuple[bool, str]:
+    proc = await asyncio.create_subprocess_exec(
+        "systemctl", "--user", action, unit,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    stdout, stderr = await proc.communicate()
+    return proc.returncode == 0, (stdout or stderr or b"").decode().strip()
+
+
+async def _run(*args: str) -> tuple[bool, str]:
+    proc = await asyncio.create_subprocess_exec(
+        *args,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    stdout, stderr = await proc.communicate()
+    return proc.returncode == 0, (stdout or stderr or b"").decode().strip()

dashboard-api/src/dashboard_api/events.py

@@ -0,0 +1,61 @@
+"""Event bus API routes — subscribe, publish, unsubscribe, list topics."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from dashboard_api.bus import bus
+
+router = APIRouter(prefix="/events", tags=["events"])
+
+
+class PublishRequest(BaseModel):
+    topic: str
+    payload: dict
+
+
+class SubscribeRequest(BaseModel):
+    topic: str
+    callback_url: str
+    subscriber: str = ""
+
+
+class UnsubscribeRequest(BaseModel):
+    topic: str
+    callback_url: str
+
+
+@router.post("/publish")
+async def publish(request: PublishRequest) -> dict:
+    """Publish an event to a topic."""
+    delivered = await bus.publish(request.topic, request.payload)
+    return {"topic": request.topic, "subscribers_notified": delivered}
+
+
+@router.post("/subscribe")
+async def subscribe(request: SubscribeRequest) -> dict:
+    """Subscribe to a topic with a webhook callback URL."""
+    bus.subscribe(request.topic, request.callback_url, request.subscriber)
+    return {
+        "topic": request.topic,
+        "callback_url": request.callback_url,
+        "status": "subscribed",
+    }
+
+
+@router.post("/unsubscribe")
+async def unsubscribe(request: UnsubscribeRequest) -> dict:
+    """Unsubscribe from a topic."""
+    removed = bus.unsubscribe(request.topic, request.callback_url)
+    return {
+        "topic": request.topic,
+        "callback_url": request.callback_url,
+        "status": "unsubscribed" if removed else "not_found",
+    }
+
+
+@router.get("/topics")
+async def list_topics() -> dict:
+    """List all topics and their subscribers."""
+    return {"topics": bus.list_topics()}

dashboard-api/src/dashboard_api/health.py

@@ -0,0 +1,48 @@
+"""Async health checker — fans out HTTP requests to service health endpoints."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+
+import httpx
+
+from castle_cli.config import CastleConfig
+
+from dashboard_api.models import HealthStatus
+
+
+async def check_all_health(config: CastleConfig) -> list[HealthStatus]:
+    """Check health of all components with expose.http and a health_path."""
+    targets: list[tuple[str, str]] = []
+    for name, manifest in config.components.items():
+        if not (manifest.expose and manifest.expose.http):
+            continue
+        http = manifest.expose.http
+        if not http.health_path:
+            continue
+        host = http.internal.host or "127.0.0.1"
+        port = http.internal.port
+        url = f"http://{host}:{port}{http.health_path}"
+        targets.append((name, url))
+
+    if not targets:
+        return []
+
+    async with httpx.AsyncClient(timeout=3.0) as client:
+        tasks = [_check_one(client, name, url) for name, url in targets]
+        return await asyncio.gather(*tasks)
+
+
+async def _check_one(client: httpx.AsyncClient, name: str, url: str) -> HealthStatus:
+    """Check a single service's health endpoint."""
+    start = time.monotonic()
+    try:
+        resp = await client.get(url)
+        latency = int((time.monotonic() - start) * 1000)
+        if resp.status_code < 300:
+            return HealthStatus(id=name, status="up", latency_ms=latency)
+        return HealthStatus(id=name, status="down", latency_ms=latency)
+    except httpx.HTTPError:
+        latency = int((time.monotonic() - start) * 1000)
+        return HealthStatus(id=name, status="down", latency_ms=latency)

dashboard-api/src/dashboard_api/logs.py

@@ -0,0 +1,70 @@
+"""Log streaming — tail journalctl output for systemd-managed services."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncGenerator
+
+from fastapi import APIRouter, HTTPException, Query, status
+from starlette.responses import StreamingResponse
+
+from castle_cli.config import load_config
+
+from dashboard_api.config import settings
+
+router = APIRouter(prefix="/logs", tags=["logs"])
+
+UNIT_PREFIX = "castle-"
+
+
+@router.get("/{name}", response_model=None)
+async def get_logs(
+    name: str,
+    n: int = Query(default=100, ge=1, le=5000, description="Number of lines"),
+    follow: bool = Query(default=False, description="Stream new lines via SSE"),
+) -> StreamingResponse | dict:
+    """Get logs for a systemd-managed service."""
+    config = load_config(settings.castle_root)
+    if name not in config.managed:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"'{name}' is not a managed service",
+        )
+
+    unit = f"{UNIT_PREFIX}{name}.service"
+
+    if follow:
+        return StreamingResponse(
+            _follow_logs(unit, n),
+            media_type="text/event-stream",
+            headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+        )
+
+    # Static tail
+    proc = await asyncio.create_subprocess_exec(
+        "journalctl", "--user", "-u", unit, "-n", str(n), "--no-pager",
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    stdout, _ = await proc.communicate()
+    lines = (stdout or b"").decode().splitlines()
+    return {"component": name, "lines": lines}
+
+
+async def _follow_logs(unit: str, n: int) -> AsyncGenerator[str, None]:
+    """Stream journalctl -f output as SSE events."""
+    proc = await asyncio.create_subprocess_exec(
+        "journalctl", "--user", "-u", unit, "-n", str(n), "-f", "--no-pager",
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    try:
+        assert proc.stdout is not None
+        async for line in proc.stdout:
+            text = line.decode().rstrip()
+            yield f"data: {text}\n\n"
+    except asyncio.CancelledError:
+        pass
+    finally:
+        proc.kill()
+        await proc.wait()

dashboard-api/src/dashboard_api/main.py

@@ -0,0 +1,97 @@
+"""Castle API — dashboard data, health aggregation, event bus, service management."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+
+import uvicorn
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from starlette.responses import StreamingResponse
+
+from dashboard_api.bus import bus
+from dashboard_api.config import settings
+from dashboard_api.config_editor import router as config_router
+from dashboard_api.events import router as events_router
+from dashboard_api.logs import router as logs_router
+from dashboard_api.routes import router as dashboard_router
+from dashboard_api.secrets import router as secrets_router
+from dashboard_api.services import router as services_router
+from dashboard_api.stream import health_poll_loop, subscribe, unsubscribe
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    """Application lifespan handler."""
+    await bus.start()
+    poll_task = asyncio.create_task(health_poll_loop())
+    yield
+    poll_task.cancel()
+    await bus.stop()
+
+
+app = FastAPI(
+    title="Castle API",
+    description="Castle dashboard API, event bus, and service management",
+    version="0.1.0",
+    lifespan=lifespan,
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(config_router)
+app.include_router(dashboard_router)
+app.include_router(events_router)
+app.include_router(logs_router)
+app.include_router(secrets_router)
+app.include_router(services_router)
+
+
+@app.get("/health")
+def health() -> dict[str, str]:
+    """Health check endpoint."""
+    return {"status": "ok"}
+
+
+@app.get("/stream")
+async def sse_stream() -> StreamingResponse:
+    """SSE stream — pushes health updates and service action events."""
+    q = subscribe()
+
+    async def event_generator() -> AsyncGenerator[str, None]:
+        try:
+            yield "event: connected\ndata: {}\n\n"
+            while True:
+                msg = await q.get()
+                yield msg
+        except asyncio.CancelledError:
+            pass
+        finally:
+            unsubscribe(q)
+
+    return StreamingResponse(
+        event_generator(),
+        media_type="text/event-stream",
+        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+    )
+
+
+def run() -> None:
+    """Run the application with uvicorn."""
+    uvicorn.run(
+        "dashboard_api.main:app",
+        host=settings.host,
+        port=settings.port,
+        reload=False,
+    )
+
+
+if __name__ == "__main__":
+    run()

dashboard-api/src/dashboard_api/models.py

@@ -0,0 +1,56 @@
+"""Response models for the dashboard API."""
+
+from pydantic import BaseModel
+
+
+class ComponentSummary(BaseModel):
+    """Summary of a single component."""
+
+    id: str
+    description: str | None = None
+    roles: list[str]
+    runner: str | None = None
+    port: int | None = None
+    health_path: str | None = None
+    proxy_path: str | None = None
+    managed: bool = False
+    category: str | None = None
+    version: str | None = None
+    tool_type: str | None = None
+
+
+class ComponentDetail(ComponentSummary):
+    """Full detail for a single component, including raw manifest."""
+
+    manifest: dict
+
+
+class HealthStatus(BaseModel):
+    """Health status of a single component."""
+
+    id: str
+    status: str  # "up", "down", "unknown"
+    latency_ms: int | None = None
+
+
+class StatusResponse(BaseModel):
+    """Aggregated health status for all exposed components."""
+
+    statuses: list[HealthStatus]
+
+
+class GatewayInfo(BaseModel):
+    """Gateway configuration summary."""
+
+    port: int
+    component_count: int
+    service_count: int
+    managed_count: int
+
+
+class ServiceActionResponse(BaseModel):
+    """Response from a service management action."""
+
+    component: str
+    action: str
+    status: str

dashboard-api/src/dashboard_api/routes.py

@@ -0,0 +1,93 @@
+"""API routes for the castle dashboard."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, status
+
+from castle_cli.config import load_config
+
+from dashboard_api.config import settings
+from dashboard_api.health import check_all_health
+from dashboard_api.models import (
+    ComponentDetail,
+    ComponentSummary,
+    GatewayInfo,
+    StatusResponse,
+)
+
+router = APIRouter(tags=["dashboard"])
+
+
+def _summary_from_manifest(name: str, manifest: object) -> ComponentSummary:
+    """Build a ComponentSummary from a manifest."""
+    port = None
+    health_path = None
+    proxy_path = None
+    if manifest.expose and manifest.expose.http:
+        port = manifest.expose.http.internal.port
+        health_path = manifest.expose.http.health_path
+    if manifest.proxy and manifest.proxy.caddy:
+        proxy_path = manifest.proxy.caddy.path_prefix
+
+    managed = bool(
+        manifest.manage and manifest.manage.systemd and manifest.manage.systemd.enable
+    )
+
+    return ComponentSummary(
+        id=name,
+        description=manifest.description,
+        roles=[r.value for r in manifest.roles],
+        runner=manifest.run.runner if manifest.run else None,
+        port=port,
+        health_path=health_path,
+        proxy_path=proxy_path,
+        managed=managed,
+        category=manifest.tool.category if manifest.tool else None,
+        version=manifest.tool.version if manifest.tool else None,
+        tool_type=manifest.tool.tool_type.value if manifest.tool else None,
+    )
+
+
+@router.get("/components", response_model=list[ComponentSummary])
+def list_components() -> list[ComponentSummary]:
+    """List all registered components."""
+    config = load_config(settings.castle_root)
+    return [
+        _summary_from_manifest(name, m)
+        for name, m in config.components.items()
+    ]
+
+
+@router.get("/components/{name}", response_model=ComponentDetail)
+def get_component(name: str) -> ComponentDetail:
+    """Get detailed info for a single component."""
+    config = load_config(settings.castle_root)
+    if name not in config.components:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Component '{name}' not found",
+        )
+    manifest = config.components[name]
+    summary = _summary_from_manifest(name, manifest)
+    raw = manifest.model_dump(mode="json", exclude_none=True)
+    return ComponentDetail(**summary.model_dump(), manifest=raw)
+
+
+@router.get("/status", response_model=StatusResponse)
+async def get_status() -> StatusResponse:
+    """Get live health status for all exposed services."""
+    config = load_config(settings.castle_root)
+    statuses = await check_all_health(config)
+    return StatusResponse(statuses=statuses)
+
+
+@router.get("/gateway", response_model=GatewayInfo)
+def get_gateway() -> GatewayInfo:
+    """Get gateway configuration summary."""
+    config = load_config(settings.castle_root)
+    return GatewayInfo(
+        port=config.gateway.port,
+        component_count=len(config.components),
+        service_count=len(config.services),
+        managed_count=len(config.managed),
+    )

dashboard-api/src/dashboard_api/secrets.py

@@ -0,0 +1,64 @@
+"""Secrets management — read and write ~/.castle/secrets/."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, status
+from pydantic import BaseModel
+
+from castle_cli.config import SECRETS_DIR
+
+router = APIRouter(prefix="/secrets", tags=["secrets"])
+
+
+class SecretValue(BaseModel):
+    value: str
+
+
+@router.get("")
+def list_secrets() -> list[str]:
+    """List all secret names (not values)."""
+    if not SECRETS_DIR.exists():
+        return []
+    return sorted(f.name for f in SECRETS_DIR.iterdir() if f.is_file())
+
+
+@router.get("/{name}")
+def get_secret(name: str) -> dict:
+    """Get a secret value."""
+    _validate_name(name)
+    path = SECRETS_DIR / name
+    if not path.exists():
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Secret '{name}' not found",
+        )
+    return {"name": name, "value": path.read_text().strip()}
+
+
+@router.put("/{name}")
+def set_secret(name: str, body: SecretValue) -> dict:
+    """Set a secret value."""
+    _validate_name(name)
+    SECRETS_DIR.mkdir(parents=True, exist_ok=True)
+    path = SECRETS_DIR / name
+    path.write_text(body.value.strip() + "\n")
+    return {"name": name, "ok": True}
+
+
+@router.delete("/{name}")
+def delete_secret(name: str) -> dict:
+    """Delete a secret."""
+    _validate_name(name)
+    path = SECRETS_DIR / name
+    if path.exists():
+        path.unlink()
+    return {"name": name, "ok": True}
+
+
+def _validate_name(name: str) -> None:
+    """Reject path traversal attempts."""
+    if "/" in name or "\\" in name or ".." in name or not name:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Invalid secret name",
+        )

dashboard-api/src/dashboard_api/services.py

@@ -0,0 +1,111 @@
+"""Service management — start/stop/restart systemd-managed components."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+
+from fastapi import APIRouter, HTTPException, status
+
+from castle_cli.config import load_config
+
+from dashboard_api.config import settings
+from dashboard_api.health import check_all_health
+from dashboard_api.models import HealthStatus
+from dashboard_api.stream import broadcast
+
+router = APIRouter(prefix="/services", tags=["services"])
+
+UNIT_PREFIX = "castle-"
+
+
+async def _systemctl(action: str, unit: str) -> tuple[bool, str]:
+    """Run a systemctl --user command. Returns (success, output)."""
+    proc = await asyncio.create_subprocess_exec(
+        "systemctl", "--user", action, unit,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    stdout, stderr = await proc.communicate()
+    output = (stdout or stderr or b"").decode().strip()
+    return proc.returncode == 0, output
+
+
+async def _get_unit_status(unit: str) -> str:
+    """Get the active status of a systemd unit."""
+    proc = await asyncio.create_subprocess_exec(
+        "systemctl", "--user", "is-active", unit,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    stdout, _ = await proc.communicate()
+    return (stdout or b"").decode().strip()
+
+
+def _validate_managed(name: str) -> None:
+    """Raise 404 if the component isn't systemd-managed."""
+    config = load_config(settings.castle_root)
+    if name not in config.managed:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"'{name}' is not a managed service",
+        )
+
+
+async def _broadcast_health_with_override(
+    override_name: str, override_status: str
+) -> None:
+    """Run health checks but override one component's status from systemd."""
+    config = load_config(settings.castle_root)
+    statuses = await check_all_health(config)
+
+    # Replace the overridden component's status with the systemd truth
+    result = []
+    for s in statuses:
+        if s.id == override_name:
+            result.append(HealthStatus(
+                id=override_name,
+                status="down" if override_status != "active" else "up",
+                latency_ms=None,
+            ))
+        else:
+            result.append(s)
+
+    await broadcast("health", {
+        "statuses": [s.model_dump() for s in result],
+        "timestamp": time.time(),
+    })
+
+
+async def _do_action(name: str, action: str) -> dict:
+    """Execute a systemctl action and broadcast updated health."""
+    _validate_managed(name)
+    unit = f"{UNIT_PREFIX}{name}.service"
+    ok, output = await _systemctl(action, unit)
+    unit_status = await _get_unit_status(unit)
+
+    if not ok:
+        raise HTTPException(status_code=500, detail=output or f"Failed to {action}")
+
+    # Broadcast immediately with systemd status as the source of truth
+    await _broadcast_health_with_override(name, unit_status)
+
+    return {"component": name, "action": action, "status": unit_status}
+
+
+@router.post("/{name}/start")
+async def start_service(name: str) -> dict:
+    """Start a systemd-managed service."""
+    return await _do_action(name, "start")
+
+
+@router.post("/{name}/stop")
+async def stop_service(name: str) -> dict:
+    """Stop a systemd-managed service."""
+    return await _do_action(name, "stop")
+
+
+@router.post("/{name}/restart")
+async def restart_service(name: str) -> dict:
+    """Restart a systemd-managed service."""
+    return await _do_action(name, "restart")

dashboard-api/src/dashboard_api/stream.py

@@ -0,0 +1,61 @@
+"""SSE stream — pushes health updates and service action events to connected clients."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import time
+
+from castle_cli.config import load_config
+
+from dashboard_api.config import settings
+from dashboard_api.health import check_all_health
+
+logger = logging.getLogger(__name__)
+
+# All connected SSE clients receive events through this queue-based broadcast.
+_subscribers: list[asyncio.Queue[str]] = []
+
+
+def subscribe() -> asyncio.Queue[str]:
+    """Register a new SSE client. Returns a queue to read events from."""
+    q: asyncio.Queue[str] = asyncio.Queue(maxsize=64)
+    _subscribers.append(q)
+    return q
+
+
+def unsubscribe(q: asyncio.Queue[str]) -> None:
+    """Remove a disconnected SSE client."""
+    try:
+        _subscribers.remove(q)
+    except ValueError:
+        pass
+
+
+async def broadcast(event_type: str, data: dict) -> None:
+    """Send an event to all connected SSE clients."""
+    payload = f"event: {event_type}\ndata: {json.dumps(data)}\n\n"
+    dead: list[asyncio.Queue[str]] = []
+    for q in _subscribers:
+        try:
+            q.put_nowait(payload)
+        except asyncio.QueueFull:
+            dead.append(q)
+    for q in dead:
+        unsubscribe(q)
+
+
+async def health_poll_loop(interval: float = 10.0) -> None:
+    """Background task that polls health and broadcasts updates."""
+    while True:
+        try:
+            config = load_config(settings.castle_root)
+            statuses = await check_all_health(config)
+            await broadcast("health", {
+                "statuses": [s.model_dump() for s in statuses],
+                "timestamp": time.time(),
+            })
+        except Exception:
+            logger.exception("Health poll failed")
+        await asyncio.sleep(interval)

dashboard-api/tests/conftest.py

@@ -0,0 +1,55 @@
+"""Test fixtures for dashboard-api."""
+
+from collections.abc import Generator
+from pathlib import Path
+
+import pytest
+import yaml
+from fastapi.testclient import TestClient
+
+from dashboard_api.config import settings
+from dashboard_api.main import app
+
+
+@pytest.fixture
+def castle_root(tmp_path: Path) -> Generator[Path, None, None]:
+    """Create a temporary castle root with castle.yaml."""
+    castle_yaml = tmp_path / "castle.yaml"
+    config = {
+        "gateway": {"port": 9000},
+        "components": {
+            "test-svc": {
+                "description": "Test service",
+                "run": {
+                    "runner": "python_uv_tool",
+                    "tool": "test-svc",
+                    "cwd": "test-svc",
+                },
+                "expose": {
+                    "http": {
+                        "internal": {"port": 19000},
+                        "health_path": "/health",
+                    }
+                },
+                "proxy": {"caddy": {"path_prefix": "/test-svc"}},
+                "manage": {"systemd": {}},
+            },
+            "test-tool": {
+                "description": "Test tool",
+                "install": {"path": {"alias": "test-tool"}},
+            },
+        },
+    }
+    castle_yaml.write_text(yaml.dump(config, default_flow_style=False))
+
+    original = settings.castle_root
+    settings.castle_root = tmp_path
+    yield tmp_path
+    settings.castle_root = original
+
+
+@pytest.fixture
+def client(castle_root: Path) -> Generator[TestClient, None, None]:
+    """Create a test client pointing to temporary castle root."""
+    with TestClient(app) as client:
+        yield client

dashboard-api/tests/test_health.py

@@ -0,0 +1,77 @@
+"""Tests for dashboard-api health endpoint."""
+
+from fastapi.testclient import TestClient
+
+
+class TestHealth:
+    """Health endpoint tests."""
+
+    def test_health(self, client: TestClient) -> None:
+        """Health endpoint returns ok."""
+        response = client.get("/health")
+        assert response.status_code == 200
+        assert response.json() == {"status": "ok"}
+
+
+class TestComponents:
+    """Component list endpoint tests."""
+
+    def test_list_components(self, client: TestClient) -> None:
+        """Returns all registered components."""
+        response = client.get("/components")
+        assert response.status_code == 200
+        data = response.json()
+        names = [c["id"] for c in data]
+        assert "test-svc" in names
+        assert "test-tool" in names
+
+    def test_service_has_port(self, client: TestClient) -> None:
+        """Service component includes port info."""
+        response = client.get("/components")
+        data = response.json()
+        svc = next(c for c in data if c["id"] == "test-svc")
+        assert svc["port"] == 19000
+        assert svc["health_path"] == "/health"
+        assert svc["proxy_path"] == "/test-svc"
+        assert svc["managed"] is True
+        assert "service" in svc["roles"]
+
+    def test_tool_has_no_port(self, client: TestClient) -> None:
+        """Tool component has no port."""
+        response = client.get("/components")
+        data = response.json()
+        tool = next(c for c in data if c["id"] == "test-tool")
+        assert tool["port"] is None
+        assert "tool" in tool["roles"]
+
+
+class TestComponentDetail:
+    """Component detail endpoint tests."""
+
+    def test_get_component(self, client: TestClient) -> None:
+        """Returns detailed info for a component."""
+        response = client.get("/components/test-svc")
+        assert response.status_code == 200
+        data = response.json()
+        assert data["id"] == "test-svc"
+        assert "manifest" in data
+        assert data["manifest"]["run"]["runner"] == "python_uv_tool"
+
+    def test_not_found(self, client: TestClient) -> None:
+        """Returns 404 for unknown component."""
+        response = client.get("/components/nonexistent")
+        assert response.status_code == 404
+
+
+class TestGateway:
+    """Gateway info endpoint tests."""
+
+    def test_gateway_info(self, client: TestClient) -> None:
+        """Returns gateway configuration."""
+        response = client.get("/gateway")
+        assert response.status_code == 200
+        data = response.json()
+        assert data["port"] == 9000
+        assert data["component_count"] == 2
+        assert data["service_count"] == 1
+        assert data["managed_count"] == 1

dashboard-api/uv.lock

@@ -0,0 +1,487 @@
+version = 1
+revision = 3
+requires-python = ">=3.13"
+
+[[package]]
+name = "annotated-doc"
+version = "0.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" },
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.12.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685, upload-time = "2026-01-06T11:45:21.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592, upload-time = "2026-01-06T11:45:19.497Z" },
+]
+
+[[package]]
+name = "castle-cli"
+version = "0.1.0"
+source = { editable = "../cli" }
+dependencies = [
+    { name = "jinja2" },
+    { name = "pydantic" },
+    { name = "pyyaml" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "jinja2", specifier = ">=3.1.0" },
+    { name = "pydantic", specifier = ">=2.0.0" },
+    { name = "pyyaml", specifier = ">=6.0.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "pyright", specifier = ">=1.1.0" },
+    { name = "pytest", specifier = ">=7.0.0" },
+    { name = "ruff", specifier = ">=0.11.0" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268, upload-time = "2026-01-04T02:42:41.825Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900, upload-time = "2026-01-04T02:42:40.15Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "dashboard-api"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "castle-cli" },
+    { name = "fastapi" },
+    { name = "httpx" },
+    { name = "pydantic-settings" },
+    { name = "uvicorn" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "httpx" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pyyaml" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "castle-cli", editable = "../cli" },
+    { name = "fastapi", specifier = ">=0.115.0" },
+    { name = "httpx", specifier = ">=0.27.0" },
+    { name = "pydantic-settings", specifier = ">=2.0.0" },
+    { name = "uvicorn", specifier = ">=0.34.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "httpx", specifier = ">=0.27.0" },
+    { name = "pytest", specifier = ">=7.0.0" },
+    { name = "pytest-asyncio", specifier = ">=0.23.0" },
+    { name = "pyyaml", specifier = ">=6.0.0" },
+]
+
+[[package]]
+name = "fastapi"
+version = "0.129.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "pydantic" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/48/47/75f6bea02e797abff1bca968d5997793898032d9923c1935ae2efdece642/fastapi-0.129.0.tar.gz", hash = "sha256:61315cebd2e65df5f97ec298c888f9de30430dd0612d59d6480beafbc10655af", size = 375450, upload-time = "2026-02-12T13:54:52.541Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/dd/d0ee25348ac58245ee9f90b6f3cbb666bf01f69be7e0911f9851bddbda16/fastapi-0.129.0-py3-none-any.whl", hash = "sha256:b4946880e48f462692b31c083be0432275cbfb6e2274566b1be91479cc1a84ec", size = 102950, upload-time = "2026-02-12T13:54:54.528Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "jinja2"
+version = "3.1.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },
+]
+
+[[package]]
+name = "markupsafe"
+version = "3.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" },
+    { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" },
+    { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" },
+    { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" },
+    { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" },
+    { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" },
+    { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" },
+    { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" },
+    { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" },
+    { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" },
+    { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" },
+    { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" },
+    { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" },
+    { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" },
+    { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" },
+    { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" },
+    { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" },
+    { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" },
+    { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.12.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.41.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },
+    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },
+    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },
+    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },
+    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
+    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
+    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
+    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
+    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
+]
+
+[[package]]
+name = "pydantic-settings"
+version = "2.13.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/52/6d/fffca34caecc4a3f97bda81b2098da5e8ab7efc9a66e819074a11955d87e/pydantic_settings-2.13.1.tar.gz", hash = "sha256:b4c11847b15237fb0171e1462bf540e294affb9b86db4d9aa5c01730bdbe4025", size = 223826, upload-time = "2026-02-19T13:45:08.055Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/00/4b/ccc026168948fec4f7555b9164c724cf4125eac006e176541483d2c959be/pydantic_settings-2.13.1-py3-none-any.whl", hash = "sha256:d56fd801823dbeae7f0975e1f8c8e25c258eb75d278ea7abb5d9cebb01b56237", size = 58929, upload-time = "2026-02-19T13:45:06.034Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
+]
+
+[[package]]
+name = "pytest-asyncio"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f0/26/19cadc79a718c5edbec86fd4919a6b6d3f681039a2f6d66d14be94e75fb9/python_dotenv-1.2.1.tar.gz", hash = "sha256:42667e897e16ab0d66954af0e60a9caa94f0fd4ecf3aaf6d2d260eec1aa36ad6", size = 44221, upload-time = "2025-10-26T15:12:10.434Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/1b/a298b06749107c305e1fe0f814c6c74aea7b2f1e10989cb30f544a1b3253/python_dotenv-1.2.1-py3-none-any.whl", hash = "sha256:b81ee9561e9ca4004139c6cbba3a238c32b03e4894671e181b671e8cb8425d61", size = 21230, upload-time = "2025-10-26T15:12:09.109Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
+]
+
+[[package]]
+name = "starlette"
+version = "0.52.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c4/68/79977123bb7be889ad680d79a40f339082c1978b5cfcf62c2d8d196873ac/starlette-0.52.1.tar.gz", hash = "sha256:834edd1b0a23167694292e94f597773bc3f89f362be6effee198165a35d62933", size = 2653702, upload-time = "2026-01-18T13:34:11.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/81/0d/13d1d239a25cbfb19e740db83143e95c772a1fe10202dda4b76792b114dd/starlette-0.52.1-py3-none-any.whl", hash = "sha256:0029d43eb3d273bc4f83a08720b4912ea4b071087a3b48db01b7c839f7954d74", size = 74272, upload-time = "2026-01-18T13:34:09.188Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "uvicorn"
+version = "0.41.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/32/ce/eeb58ae4ac36fe09e3842eb02e0eb676bf2c53ae062b98f1b2531673efdd/uvicorn-0.41.0.tar.gz", hash = "sha256:09d11cf7008da33113824ee5a1c6422d89fbc2ff476540d69a34c87fab8b571a", size = 82633, upload-time = "2026-02-16T23:07:24.1Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/83/e4/d04a086285c20886c0daad0e026f250869201013d18f81d9ff5eada73a88/uvicorn-0.41.0-py3-none-any.whl", hash = "sha256:29e35b1d2c36a04b9e180d4007ede3bcb32a85fbdfd6c6aeb3f26839de088187", size = 68783, upload-time = "2026-02-16T23:07:22.357Z" },
+]

dashboard/.env

@@ -0,0 +1 @@
+VITE_API_BASE_URL=/api

dashboard/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

dashboard/README.md

@@ -0,0 +1,73 @@
+# React + TypeScript + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) (or [oxc](https://oxc.rs) when used in [rolldown-vite](https://vite.dev/guide/rolldown)) for Fast Refresh
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
+
+## React Compiler
+
+The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend updating the configuration to enable type-aware lint rules:
+
+```js
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+
+      // Remove tseslint.configs.recommended and replace with this
+      tseslint.configs.recommendedTypeChecked,
+      // Alternatively, use this for stricter rules
+      tseslint.configs.strictTypeChecked,
+      // Optionally, add this for stylistic rules
+      tseslint.configs.stylisticTypeChecked,
+
+      // Other configs...
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```
+
+You can also install [eslint-plugin-react-x](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-x) and [eslint-plugin-react-dom](https://github.com/Rel1cx/eslint-react/tree/main/packages/plugins/eslint-plugin-react-dom) for React-specific lint rules:
+
+```js
+// eslint.config.js
+import reactX from 'eslint-plugin-react-x'
+import reactDom from 'eslint-plugin-react-dom'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      // Other configs...
+      // Enable lint rules for React
+      reactX.configs['recommended-typescript'],
+      // Enable lint rules for React DOM
+      reactDom.configs.recommended,
+    ],
+    languageOptions: {
+      parserOptions: {
+        project: ['./tsconfig.node.json', './tsconfig.app.json'],
+        tsconfigRootDir: import.meta.dirname,
+      },
+      // other options...
+    },
+  },
+])
+```

dashboard/eslint.config.js

@@ -0,0 +1,23 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import tseslint from 'typescript-eslint'
+import { defineConfig, globalIgnores } from 'eslint/config'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{ts,tsx}'],
+    extends: [
+      js.configs.recommended,
+      tseslint.configs.recommended,
+      reactHooks.configs.flat.recommended,
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+    },
+  },
+])

dashboard/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Castle</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

dashboard/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "dashboard",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@tailwindcss/vite": "^4.2.0",
+    "@tanstack/react-query": "^5.90.21",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "lucide-react": "^0.575.0",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "react-router": "^7.13.0",
+    "react-router-dom": "^7.13.0",
+    "tailwind-merge": "^3.5.0",
+    "tailwindcss": "^4.2.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "@types/node": "^24.10.1",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^5.1.1",
+    "eslint": "^9.39.1",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.4.24",
+    "globals": "^16.5.0",
+    "typescript": "~5.9.3",
+    "typescript-eslint": "^8.48.0",
+    "vite": "^7.3.1"
+  }
+}

dashboard/src/App.tsx

@@ -0,0 +1,12 @@
+import { QueryClientProvider } from "@tanstack/react-query"
+import { RouterProvider } from "react-router-dom"
+import { queryClient } from "@/lib/queryClient"
+import { router } from "@/router/routes"
+
+export default function App() {
+  return (
+    <QueryClientProvider client={queryClient}>
+      <RouterProvider router={router} />
+    </QueryClientProvider>
+  )
+}

dashboard/src/components/AddComponent.tsx

@@ -0,0 +1,194 @@
+import { useState } from "react"
+import { Plus, X } from "lucide-react"
+
+const TEMPLATES: Record<string, Record<string, unknown>> = {
+  service: {
+    run: {
+      runner: "python_uv_tool",
+      tool: "",
+      cwd: "",
+      env: {},
+    },
+    expose: {
+      http: {
+        internal: { port: 9001 },
+        health_path: "/health",
+      },
+    },
+    proxy: {
+      caddy: { path_prefix: "/" },
+    },
+    manage: {
+      systemd: {},
+    },
+  },
+  tool: {
+    install: {
+      path: { alias: "" },
+    },
+  },
+  worker: {
+    run: {
+      runner: "command",
+      argv: [""],
+      cwd: "",
+    },
+    manage: {
+      systemd: {},
+    },
+  },
+  empty: {},
+}
+
+interface AddComponentProps {
+  onAdd: (name: string, config: Record<string, unknown>) => Promise<void>
+  existingNames: string[]
+}
+
+export function AddComponent({ onAdd, existingNames }: AddComponentProps) {
+  const [open, setOpen] = useState(false)
+  const [name, setName] = useState("")
+  const [description, setDescription] = useState("")
+  const [template, setTemplate] = useState("service")
+  const [port, setPort] = useState("")
+  const [saving, setSaving] = useState(false)
+  const [error, setError] = useState("")
+
+  const nameError =
+    name && !/^[a-z0-9][a-z0-9-]*$/.test(name)
+      ? "lowercase letters, numbers, and hyphens"
+      : existingNames.includes(name)
+        ? "already exists"
+        : ""
+
+  const handleSubmit = async () => {
+    if (!name || nameError) return
+    setSaving(true)
+    setError("")
+    try {
+      const config: Record<string, unknown> = JSON.parse(
+        JSON.stringify(TEMPLATES[template] ?? {})
+      )
+      if (description) config.description = description
+
+      // Fill in template-specific fields
+      if (template === "service") {
+        const run = config.run as Record<string, unknown>
+        run.tool = name
+        run.cwd = name
+        const proxy = (config.proxy as Record<string, Record<string, string>>).caddy
+        proxy.path_prefix = `/${name}`
+        if (port) {
+          const expose = (config.expose as Record<string, Record<string, Record<string, number>>>)
+          expose.http.internal.port = parseInt(port, 10)
+        }
+      } else if (template === "tool") {
+        const install = (config.install as Record<string, Record<string, string>>).path
+        install.alias = name
+      }
+
+      await onAdd(name, config)
+      setName("")
+      setDescription("")
+      setPort("")
+      setOpen(false)
+    } catch (e: unknown) {
+      setError(e instanceof Error ? e.message : String(e))
+    } finally {
+      setSaving(false)
+    }
+  }
+
+  if (!open) {
+    return (
+      <button
+        onClick={() => setOpen(true)}
+        className="w-full flex items-center justify-center gap-2 p-4 border border-dashed border-[var(--border)] rounded-lg text-[var(--muted)] hover:text-[var(--foreground)] hover:border-[var(--primary)] transition-colors"
+      >
+        <Plus size={16} /> Add component
+      </button>
+    )
+  }
+
+  return (
+    <div className="bg-[var(--card)] border border-[var(--primary)] rounded-lg p-5 space-y-4">
+      <div className="flex items-center justify-between">
+        <h3 className="font-semibold">New component</h3>
+        <button onClick={() => setOpen(false)} className="text-[var(--muted)] hover:text-[var(--foreground)]">
+          <X size={16} />
+        </button>
+      </div>
+
+      {error && (
+        <div className="text-sm text-red-400 bg-red-900/20 border border-red-800 rounded px-3 py-1.5">
+          {error}
+        </div>
+      )}
+
+      <div className="grid grid-cols-2 gap-4">
+        <Field label="Name">
+          <input
+            value={name}
+            onChange={(e) => setName(e.target.value.toLowerCase())}
+            placeholder="my-service"
+            autoFocus
+            className="w-full bg-black/30 border border-[var(--border)] rounded px-3 py-1.5 text-sm font-mono focus:outline-none focus:border-[var(--primary)]"
+          />
+          {nameError && <p className="text-xs text-red-400 mt-1">{nameError}</p>}
+        </Field>
+
+        <Field label="Template">
+          <select
+            value={template}
+            onChange={(e) => setTemplate(e.target.value)}
+            className="w-full bg-black/30 border border-[var(--border)] rounded px-3 py-1.5 text-sm focus:outline-none focus:border-[var(--primary)]"
+          >
+            <option value="service">Service (FastAPI + systemd + Caddy)</option>
+            <option value="tool">Tool (PATH install)</option>
+            <option value="worker">Worker (systemd, no HTTP)</option>
+            <option value="empty">Empty</option>
+          </select>
+        </Field>
+      </div>
+
+      <Field label="Description">
+        <input
+          value={description}
+          onChange={(e) => setDescription(e.target.value)}
+          placeholder="What does this component do?"
+          className="w-full bg-black/30 border border-[var(--border)] rounded px-3 py-1.5 text-sm focus:outline-none focus:border-[var(--primary)]"
+        />
+      </Field>
+
+      {template === "service" && (
+        <Field label="Port">
+          <input
+            value={port}
+            onChange={(e) => setPort(e.target.value)}
+            placeholder="9001"
+            className="w-32 bg-black/30 border border-[var(--border)] rounded px-3 py-1.5 text-sm font-mono focus:outline-none focus:border-[var(--primary)]"
+          />
+        </Field>
+      )}
+
+      <div className="flex justify-end">
+        <button
+          onClick={handleSubmit}
+          disabled={!name || !!nameError || saving}
+          className="flex items-center gap-1.5 px-4 py-1.5 text-sm rounded bg-green-700 hover:bg-green-600 text-white transition-colors disabled:opacity-40"
+        >
+          <Plus size={14} /> Add
+        </button>
+      </div>
+    </div>
+  )
+}
+
+function Field({ label, children }: { label: string; children: React.ReactNode }) {
+  return (
+    <div>
+      <label className="block text-sm font-medium mb-1">{label}</label>
+      {children}
+    </div>
+  )
+}

dashboard/src/components/ComponentCard.tsx

@@ -0,0 +1,116 @@
+import { ExternalLink, Play, RefreshCw, Server, Square, Terminal } from "lucide-react"
+import { Link } from "react-router-dom"
+import type { ComponentSummary, HealthStatus } from "@/types"
+import { useServiceAction } from "@/services/api/hooks"
+import { HealthBadge } from "./HealthBadge"
+import { RoleBadge } from "./RoleBadge"
+
+interface ComponentCardProps {
+  component: ComponentSummary
+  health?: HealthStatus
+}
+
+export function ComponentCard({ component, health }: ComponentCardProps) {
+  const hasHttp = component.port != null
+  const { mutate, isPending } = useServiceAction()
+
+  const doAction = (action: string) => {
+    mutate({ name: component.id, action })
+  }
+
+  const isDown = health?.status === "down"
+
+  return (
+    <div className="bg-[var(--card)] border border-[var(--border)] rounded-lg p-5">
+      <div className="flex items-start justify-between mb-2">
+        <Link
+          to={`/${component.id}`}
+          className="text-base font-semibold hover:text-[var(--primary)] transition-colors"
+        >
+          {component.id}
+        </Link>
+        {health ? (
+          <HealthBadge status={health.status} latency={health.latency_ms} />
+        ) : hasHttp ? (
+          <HealthBadge status="unknown" />
+        ) : null}
+      </div>
+
+      <div className="flex gap-1 mb-2">
+        {component.roles.map((role) => (
+          <RoleBadge key={role} role={role} />
+        ))}
+      </div>
+
+      {component.description && (
+        <p className="text-sm text-[var(--muted)] mb-3">{component.description}</p>
+      )}
+
+      <div className="flex items-center justify-between">
+        <div className="flex items-center gap-3 text-xs text-[var(--muted)]">
+          {component.port && (
+            <span className="flex items-center gap-1 font-mono">
+              <Server size={12} />:{component.port}
+            </span>
+          )}
+          {component.runner && (
+            <span className="flex items-center gap-1">
+              <Terminal size={12} />
+              {component.runner}
+            </span>
+          )}
+          {component.proxy_path && (
+            <a
+              href={component.proxy_path + "/"}
+              className="flex items-center gap-1 text-[var(--primary)] hover:underline"
+            >
+              <ExternalLink size={12} />
+              {component.proxy_path}
+            </a>
+          )}
+          {component.port && (
+            <a
+              href={`http://localhost:${component.port}/docs`}
+              className="text-[var(--primary)] hover:underline"
+            >
+              Docs
+            </a>
+          )}
+        </div>
+
+        {component.managed && (
+          <div className="flex items-center gap-1">
+            {isDown && (
+              <button
+                onClick={() => doAction("start")}
+                disabled={isPending}
+                className="p-1 rounded hover:bg-green-800/30 text-green-400 transition-colors disabled:opacity-40"
+                title="Start"
+              >
+                <Play size={14} />
+              </button>
+            )}
+            <button
+              onClick={() => doAction("restart")}
+              disabled={isPending}
+              className="p-1 rounded hover:bg-blue-800/30 text-blue-400 transition-colors disabled:opacity-40"
+              title="Restart"
+            >
+              <RefreshCw size={14} />
+            </button>
+            {!isDown && (
+              <button
+                onClick={() => doAction("stop")}
+                disabled={isPending}
+                className="p-1 rounded hover:bg-red-800/30 text-red-400 transition-colors disabled:opacity-40"
+                title="Stop"
+              >
+                <Square size={14} />
+              </button>
+            )}
+          </div>
+        )}
+      </div>
+    </div>
+  )
+}

dashboard/src/components/ComponentEditor.tsx

@@ -0,0 +1,45 @@
+import { useState } from "react"
+import { ChevronDown, ChevronRight } from "lucide-react"
+import type { ComponentDetail } from "@/types"
+import { ComponentFields } from "./ComponentFields"
+import { RoleBadge } from "./RoleBadge"
+
+interface ComponentEditorProps {
+  component: ComponentDetail
+  onSave: (name: string, config: Record<string, unknown>) => Promise<void>
+  onDelete: (name: string) => Promise<void>
+}
+
+export function ComponentEditor({ component, onSave, onDelete }: ComponentEditorProps) {
+  const [expanded, setExpanded] = useState(false)
+
+  return (
+    <div className="bg-[var(--card)] border border-[var(--border)] rounded-lg overflow-hidden">
+      <button
+        onClick={() => setExpanded(!expanded)}
+        className="w-full flex items-center justify-between p-4 hover:bg-white/5 transition-colors text-left"
+      >
+        <div className="flex items-center gap-3">
+          {expanded ? <ChevronDown size={16} /> : <ChevronRight size={16} />}
+          <span className="font-semibold">{component.id}</span>
+          <span className="text-sm text-[var(--muted)]">{component.description}</span>
+        </div>
+        <div className="flex items-center gap-1.5">
+          {component.roles.map((r) => (
+            <RoleBadge key={r} role={r} />
+          ))}
+        </div>
+      </button>
+
+      {expanded && (
+        <div className="border-t border-[var(--border)] p-4">
+          <ComponentFields
+            component={component}
+            onSave={onSave}
+            onDelete={onDelete}
+          />
+        </div>
+      )}
+    </div>
+  )
+}

dashboard/src/components/ComponentFields.tsx

@@ -0,0 +1,254 @@
+import { useMemo, useState } from "react"
+import { Check, Loader2, Save, Trash2 } from "lucide-react"
+import type { ComponentDetail } from "@/types"
+import { SecretsEditor } from "./SecretsEditor"
+
+interface ComponentFieldsProps {
+  component: ComponentDetail
+  onSave: (name: string, config: Record<string, unknown>) => Promise<void>
+  onDelete?: (name: string) => Promise<void>
+}
+
+const SECRET_RE = /^\$\{secret:([^}]+)\}$/
+
+export function ComponentFields({ component, onSave, onDelete }: ComponentFieldsProps) {
+  const m = component.manifest
+  const [saving, setSaving] = useState(false)
+  const [saved, setSaved] = useState(false)
+
+  const allEnv: Record<string, string> =
+    ((m.run as Record<string, unknown>)?.env as Record<string, string>) ?? {}
+
+  // Split into plain env vars and secret references
+  const { initialEnv, initialSecrets } = useMemo(() => {
+    const env: Record<string, string> = {}
+    const secrets: Record<string, string> = {}
+    for (const [key, val] of Object.entries(allEnv)) {
+      const match = SECRET_RE.exec(val)
+      if (match) {
+        secrets[key] = match[1]
+      } else {
+        env[key] = val
+      }
+    }
+    return { initialEnv: env, initialSecrets: secrets }
+  }, [])
+
+  const [runEnv, setRunEnv] = useState<Record<string, string>>(initialEnv)
+  const [secrets, setSecrets] = useState<Record<string, string>>(initialSecrets)
+
+  const [description, setDescription] = useState(m.description as string ?? "")
+  const [port, setPort] = useState(
+    String(
+      ((m.expose as Record<string, unknown>)?.http as Record<string, unknown>)
+        ?.internal as Record<string, unknown>
+        ? (((m.expose as Record<string, unknown>)?.http as Record<string, unknown>)
+            ?.internal as Record<string, number>)?.port ?? ""
+        : ""
+    )
+  )
+  const [proxyPath, setProxyPath] = useState(
+    ((m.proxy as Record<string, unknown>)?.caddy as Record<string, string>)?.path_prefix ?? ""
+  )
+  const [healthPath, setHealthPath] = useState(
+    ((m.expose as Record<string, unknown>)?.http as Record<string, string>)?.health_path ?? ""
+  )
+
+  const runner = (m.run as Record<string, unknown>)?.runner as string | undefined
+
+  const handleSave = async () => {
+    setSaving(true)
+    setSaved(false)
+    try {
+      const config: Record<string, unknown> = { ...m }
+      delete config.id
+      delete config.roles
+      config.description = description || undefined
+
+      // Merge plain env + secret references back together
+      if (config.run && typeof config.run === "object") {
+        const mergedEnv: Record<string, string> = { ...runEnv }
+        for (const [envKey, secretName] of Object.entries(secrets)) {
+          mergedEnv[envKey] = `\${secret:${secretName}}`
+        }
+        config.run = { ...config.run as Record<string, unknown>, env: mergedEnv }
+      }
+
+      if (port) {
+        const portNum = parseInt(port, 10)
+        if (!isNaN(portNum)) {
+          config.expose = {
+            http: {
+              internal: { port: portNum },
+              ...(healthPath ? { health_path: healthPath } : {}),
+            },
+          }
+        }
+      }
+
+      if (proxyPath) {
+        config.proxy = { caddy: { path_prefix: proxyPath } }
+      } else {
+        delete config.proxy
+      }
+
+      await onSave(component.id, config)
+      setSaved(true)
+      setTimeout(() => setSaved(false), 2000)
+    } finally {
+      setSaving(false)
+    }
+  }
+
+  return (
+    <div className="space-y-4">
+      <Field label="Description">
+        <input
+          value={description}
+          onChange={(e) => setDescription(e.target.value)}
+          className="w-full bg-black/30 border border-[var(--border)] rounded px-3 py-1.5 text-sm focus:outline-none focus:border-[var(--primary)]"
+        />
+      </Field>
+
+      {runner && (
+        <Field label="Runner">
+          <span className="text-sm font-mono text-[var(--muted)]">
+            {runner}
+            {(m.run as Record<string, string>)?.tool && (
+              <> &middot; {(m.run as Record<string, string>).tool}</>
+            )}
+          </span>
+        </Field>
+      )}
+
+      {(component.managed || port) && (
+        <Field label="Port">
+          <input
+            value={port}
+            onChange={(e) => setPort(e.target.value)}
+            placeholder="e.g. 9001"
+            className="w-32 bg-black/30 border border-[var(--border)] rounded px-3 py-1.5 text-sm font-mono focus:outline-none focus:border-[var(--primary)]"
+          />
+        </Field>
+      )}
+
+      {(component.managed || healthPath) && (
+        <Field label="Health path">
+          <input
+            value={healthPath}
+            onChange={(e) => setHealthPath(e.target.value)}
+            placeholder="/health"
+            className="w-48 bg-black/30 border border-[var(--border)] rounded px-3 py-1.5 text-sm font-mono focus:outline-none focus:border-[var(--primary)]"
+          />
+        </Field>
+      )}
+
+      <Field label="Proxy path">
+        <input
+          value={proxyPath}
+          onChange={(e) => setProxyPath(e.target.value)}
+          placeholder="/my-service"
+          className="w-48 bg-black/30 border border-[var(--border)] rounded px-3 py-1.5 text-sm font-mono focus:outline-none focus:border-[var(--primary)]"
+        />
+      </Field>
+
+      {runner && (
+        <Field label="Environment">
+          <div className="space-y-2">
+            {Object.entries(runEnv).map(([key, val]) => (
+              <div key={key} className="flex items-center gap-2">
+                <input
+                  value={key}
+                  readOnly
+                  className="w-56 bg-black/30 border border-[var(--border)] rounded px-2 py-1 text-xs font-mono text-[var(--muted)]"
+                />
+                <span className="text-[var(--muted)]">=</span>
+                <input
+                  value={val}
+                  onChange={(e) =>
+                    setRunEnv((prev) => ({ ...prev, [key]: e.target.value }))
+                  }
+                  className="flex-1 bg-black/30 border border-[var(--border)] rounded px-2 py-1 text-xs font-mono focus:outline-none focus:border-[var(--primary)]"
+                />
+                <button
+                  onClick={() =>
+                    setRunEnv((prev) => {
+                      const next = { ...prev }
+                      delete next[key]
+                      return next
+                    })
+                  }
+                  className="text-red-400 hover:text-red-300 p-0.5"
+                  title="Remove"
+                >
+                  <Trash2 size={12} />
+                </button>
+              </div>
+            ))}
+            <button
+              onClick={() => {
+                const key = prompt("Variable name:")
+                if (key) setRunEnv((prev) => ({ ...prev, [key]: "" }))
+              }}
+              className="text-xs text-[var(--primary)] hover:underline"
+            >
+              + Add variable
+            </button>
+          </div>
+        </Field>
+      )}
+
+      {runner && (
+        <Field label="Secrets">
+          <SecretsEditor secrets={secrets} onSecretsChange={setSecrets} />
+        </Field>
+      )}
+
+      <Field label="Systemd">
+        <span className="text-sm text-[var(--muted)]">
+          {component.managed ? "Yes" : "No"}
+        </span>
+      </Field>
+
+      <div className="flex items-center justify-between pt-3 border-t border-[var(--border)]">
+        {onDelete ? (
+          <button
+            onClick={() => {
+              if (confirm(`Delete component "${component.id}" from castle.yaml?`)) {
+                onDelete(component.id)
+              }
+            }}
+            className="flex items-center gap-1.5 text-xs text-red-400 hover:text-red-300"
+          >
+            <Trash2 size={12} /> Remove component
+          </button>
+        ) : (
+          <div />
+        )}
+        <button
+          onClick={handleSave}
+          disabled={saving}
+          className="flex items-center gap-1.5 px-3 py-1.5 text-sm rounded bg-blue-700 hover:bg-blue-600 text-white transition-colors disabled:opacity-40"
+        >
+          {saving ? (
+            <Loader2 size={14} className="animate-spin" />
+          ) : saved ? (
+            <Check size={14} />
+          ) : (
+            <Save size={14} />
+          )}
+          {saved ? "Saved" : "Save"}
+        </button>
+      </div>
+    </div>
+  )
+}
+
+function Field({ label, children }: { label: string; children: React.ReactNode }) {
+  return (
+    <div className="flex items-start gap-4">
+      <label className="w-32 shrink-0 text-sm font-medium pt-1.5">{label}</label>
+      <div className="flex-1">{children}</div>
+    </div>
+  )
+}

dashboard/src/components/ComponentGrid.tsx

@@ -0,0 +1,56 @@
+import type { ComponentSummary, HealthStatus } from "@/types"
+import { ComponentCard } from "./ComponentCard"
+
+const ROLE_ORDER = ["service", "tool", "worker", "job", "frontend", "remote", "containerized"]
+const ROLE_LABELS: Record<string, string> = {
+  service: "Services",
+  tool: "Tools",
+  worker: "Workers",
+  job: "Jobs",
+  frontend: "Frontends",
+  remote: "Remote",
+  containerized: "Containers",
+}
+
+interface ComponentGridProps {
+  components: ComponentSummary[]
+  statuses: HealthStatus[]
+}
+
+export function ComponentGrid({ components, statuses }: ComponentGridProps) {
+  const statusMap = new Map(statuses.map((s) => [s.id, s]))
+
+  // Group by primary role
+  const groups = new Map<string, ComponentSummary[]>()
+  for (const comp of components) {
+    const primary = comp.roles[0] ?? "tool"
+    const list = groups.get(primary) ?? []
+    list.push(comp)
+    groups.set(primary, list)
+  }
+
+  return (
+    <div className="space-y-8">
+      {ROLE_ORDER.map((role) => {
+        const items = groups.get(role)
+        if (!items?.length) return null
+        return (
+          <section key={role}>
+            <h2 className="text-lg font-semibold mb-3 text-[var(--muted)]">
+              {ROLE_LABELS[role] ?? role}
+            </h2>
+            <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-4">
+              {items.map((comp) => (
+                <ComponentCard
+                  key={comp.id}
+                  component={comp}
+                  health={statusMap.get(comp.id)}
+                />
+              ))}
+            </div>
+          </section>
+        )
+      })}
+    </div>
+  )
+}

dashboard/src/components/HealthBadge.tsx

@@ -0,0 +1,32 @@
+import { cn } from "@/lib/utils"
+
+interface HealthBadgeProps {
+  status: "up" | "down" | "unknown"
+  latency?: number | null
+}
+
+export function HealthBadge({ status, latency }: HealthBadgeProps) {
+  return (
+    <span
+      className={cn(
+        "inline-flex items-center gap-1.5 text-xs px-2 py-0.5 rounded-full",
+        status === "up" && "bg-green-800/50 text-green-300",
+        status === "down" && "bg-red-800/50 text-red-300",
+        status === "unknown" && "bg-gray-700/50 text-gray-400",
+      )}
+    >
+      <span
+        className={cn(
+          "w-1.5 h-1.5 rounded-full",
+          status === "up" && "bg-green-400",
+          status === "down" && "bg-red-400",
+          status === "unknown" && "bg-gray-500",
+        )}
+      />
+      {status}
+      {latency != null && status === "up" && (
+        <span className="text-gray-500 ml-0.5">{latency}ms</span>
+      )}
+    </span>
+  )
+}

dashboard/src/components/LogViewer.tsx

@@ -0,0 +1,71 @@
+import { useEffect, useRef, useState } from "react"
+import { apiClient } from "@/services/api/client"
+
+interface LogViewerProps {
+  name: string
+  lines?: number
+  follow?: boolean
+}
+
+export function LogViewer({ name, lines = 50, follow = true }: LogViewerProps) {
+  const [logs, setLogs] = useState<string[]>([])
+  const [connected, setConnected] = useState(false)
+  const bottomRef = useRef<HTMLDivElement>(null)
+
+  useEffect(() => {
+    if (!follow) {
+      // Static fetch
+      apiClient
+        .get<{ lines: string[] }>(`/logs/${name}?n=${lines}`)
+        .then((data) => setLogs(data.lines))
+      return
+    }
+
+    // SSE follow
+    const url = apiClient.streamUrl(`/logs/${name}?n=${lines}&follow=true`)
+    const es = new EventSource(url)
+
+    es.onopen = () => setConnected(true)
+
+    es.onmessage = (e) => {
+      setLogs((prev) => {
+        const next = [...prev, e.data]
+        // Keep last 500 lines in memory
+        return next.length > 500 ? next.slice(-500) : next
+      })
+    }
+
+    es.onerror = () => setConnected(false)
+
+    return () => es.close()
+  }, [name, lines, follow])
+
+  useEffect(() => {
+    bottomRef.current?.scrollIntoView({ behavior: "smooth" })
+  }, [logs])
+
+  return (
+    <div className="bg-black/40 border border-[var(--border)] rounded-lg overflow-hidden">
+      <div className="flex items-center justify-between px-3 py-1.5 border-b border-[var(--border)] text-xs text-[var(--muted)]">
+        <span>logs: {name}</span>
+        {follow && (
+          <span className={connected ? "text-green-400" : "text-red-400"}>
+            {connected ? "streaming" : "disconnected"}
+          </span>
+        )}
+      </div>
+      <pre className="p-3 text-xs font-mono text-gray-300 overflow-x-auto max-h-96 overflow-y-auto">
+        {logs.length === 0 ? (
+          <span className="text-[var(--muted)]">No logs yet</span>
+        ) : (
+          logs.map((line, i) => (
+            <div key={i} className="leading-5 hover:bg-white/5">
+              {line}
+            </div>
+          ))
+        )}
+        <div ref={bottomRef} />
+      </pre>
+    </div>
+  )
+}

dashboard/src/components/RoleBadge.tsx

@@ -0,0 +1,24 @@
+import { cn } from "@/lib/utils"
+
+const roleColors: Record<string, string> = {
+  service: "bg-green-700 text-white",
+  tool: "bg-blue-700 text-white",
+  worker: "bg-blue-500 text-white",
+  job: "bg-purple-700 text-white",
+  frontend: "bg-yellow-600 text-black",
+  remote: "bg-gray-600 text-gray-200",
+  containerized: "bg-orange-600 text-black",
+}
+
+export function RoleBadge({ role }: { role: string }) {
+  return (
+    <span
+      className={cn(
+        "inline-block text-[0.65rem] font-semibold uppercase px-1.5 py-0.5 rounded",
+        roleColors[role] ?? "bg-gray-600 text-gray-200",
+      )}
+    >
+      {role}
+    </span>
+  )
+}

dashboard/src/components/SecretsEditor.tsx

@@ -0,0 +1,160 @@
+import { useEffect, useState } from "react"
+import { Check, Eye, EyeOff, Loader2, Plus, Save, Trash2 } from "lucide-react"
+import { apiClient } from "@/services/api/client"
+
+interface SecretsEditorProps {
+  /** Current secret references: { ENV_VAR_NAME: "SECRET_FILE_NAME" } */
+  secrets: Record<string, string>
+  onSecretsChange: (secrets: Record<string, string>) => void
+}
+
+interface SecretState {
+  value: string
+  original: string
+  visible: boolean
+  saving: boolean
+  saved: boolean
+  loaded: boolean
+}
+
+export function SecretsEditor({ secrets, onSecretsChange }: SecretsEditorProps) {
+  const [states, setStates] = useState<Record<string, SecretState>>({})
+
+  // Load secret values when the secret list changes
+  useEffect(() => {
+    for (const [envKey, secretName] of Object.entries(secrets)) {
+      if (states[envKey]?.loaded) continue
+      setStates((prev) => ({
+        ...prev,
+        [envKey]: {
+          value: "", original: "", visible: false,
+          saving: false, saved: false, loaded: false,
+        },
+      }))
+      apiClient
+        .get<{ value: string }>(`/secrets/${secretName}`)
+        .then((data) => {
+          setStates((prev) => ({
+            ...prev,
+            [envKey]: { ...prev[envKey], value: data.value, original: data.value, loaded: true },
+          }))
+        })
+        .catch(() => {
+          setStates((prev) => ({
+            ...prev,
+            [envKey]: { ...prev[envKey], loaded: true },
+          }))
+        })
+    }
+  }, [Object.keys(secrets).join(",")])
+
+  const handleSave = async (envKey: string) => {
+    const s = states[envKey]
+    const secretName = secrets[envKey]
+    if (!s || !secretName || s.value === s.original) return
+
+    setStates((prev) => ({ ...prev, [envKey]: { ...prev[envKey], saving: true } }))
+    try {
+      await apiClient.put(`/secrets/${secretName}`, { value: s.value })
+      setStates((prev) => ({
+        ...prev,
+        [envKey]: { ...prev[envKey], saving: false, saved: true, original: s.value },
+      }))
+      setTimeout(() => {
+        setStates((prev) => ({ ...prev, [envKey]: { ...prev[envKey], saved: false } }))
+      }, 2000)
+    } catch {
+      setStates((prev) => ({ ...prev, [envKey]: { ...prev[envKey], saving: false } }))
+    }
+  }
+
+  const handleAdd = () => {
+    const envKey = prompt("Environment variable name (e.g. MY_API_KEY):")
+    if (!envKey) return
+    const secretName = prompt("Secret file name (stored in ~/.castle/secrets/):", envKey)
+    if (!secretName) return
+    onSecretsChange({ ...secrets, [envKey]: secretName })
+    setStates((prev) => ({
+      ...prev,
+      [envKey]: {
+        value: "", original: "", visible: true,
+        saving: false, saved: false, loaded: true,
+      },
+    }))
+  }
+
+  const handleRemove = (envKey: string) => {
+    const next = { ...secrets }
+    delete next[envKey]
+    onSecretsChange(next)
+    setStates((prev) => {
+      const n = { ...prev }
+      delete n[envKey]
+      return n
+    })
+  }
+
+  return (
+    <div className="space-y-2">
+      {Object.entries(secrets).map(([envKey, secretName]) => {
+        const s = states[envKey]
+        const dirty = s ? s.value !== s.original : false
+
+        return (
+          <div key={envKey} className="flex items-center gap-2">
+            <span className="w-56 shrink-0 text-xs font-mono text-[var(--muted)] truncate" title={`${envKey} → ${secretName}`}>
+              {envKey}
+            </span>
+            <div className="flex-1 flex items-center gap-1.5">
+              <input
+                type={s?.visible ? "text" : "password"}
+                value={s?.loaded ? s.value : ""}
+                placeholder={s?.loaded ? "(empty)" : "loading..."}
+                onChange={(e) =>
+                  setStates((prev) => ({
+                    ...prev,
+                    [envKey]: { ...prev[envKey], value: e.target.value },
+                  }))
+                }
+                className="flex-1 bg-black/30 border border-[var(--border)] rounded px-2 py-1 text-xs font-mono focus:outline-none focus:border-[var(--primary)]"
+              />
+              <button
+                onClick={() =>
+                  setStates((prev) => ({
+                    ...prev,
+                    [envKey]: { ...prev[envKey], visible: !prev[envKey]?.visible },
+                  }))
+                }
+                className="p-1 text-[var(--muted)] hover:text-[var(--foreground)]"
+              >
+                {s?.visible ? <EyeOff size={12} /> : <Eye size={12} />}
+              </button>
+              <button
+                onClick={() => handleSave(envKey)}
+                disabled={!dirty || s?.saving}
+                className="p-1 text-blue-400 hover:text-blue-300 disabled:opacity-30"
+              >
+                {s?.saving ? (
+                  <Loader2 size={12} className="animate-spin" />
+                ) : s?.saved ? (
+                  <Check size={12} className="text-green-400" />
+                ) : (
+                  <Save size={12} />
+                )}
+              </button>
+              <button
+                onClick={() => handleRemove(envKey)}
+                className="p-1 text-red-400 hover:text-red-300"
+              >
+                <Trash2 size={12} />
+              </button>
+            </div>
+          </div>
+        )
+      })}
+      <button onClick={handleAdd} className="text-xs text-[var(--primary)] hover:underline">
+        <Plus size={10} className="inline mr-1" />Add secret
+      </button>
+    </div>
+  )
+}

dashboard/src/index.css

@@ -0,0 +1,19 @@
+@import "tailwindcss";
+
+:root {
+  --background: #0f1117;
+  --foreground: #e1e4e8;
+  --card: #161b22;
+  --card-foreground: #e1e4e8;
+  --border: #30363d;
+  --muted: #8b949e;
+  --primary: #58a6ff;
+  --destructive: #da3633;
+  --success: #238636;
+}
+
+body {
+  background-color: var(--background);
+  color: var(--foreground);
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+}

dashboard/src/lib/queryClient.ts

@@ -0,0 +1,11 @@
+import { QueryClient } from "@tanstack/react-query"
+
+export const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 30 * 1000,
+      gcTime: 5 * 60 * 1000,
+      retry: 1,
+    },
+  },
+})

dashboard/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}

dashboard/src/main.tsx

@@ -0,0 +1,10 @@
+import { StrictMode } from "react"
+import { createRoot } from "react-dom/client"
+import App from "./App"
+import "./index.css"
+
+createRoot(document.getElementById("root")!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)

dashboard/src/pages/ComponentDetail.tsx

@@ -0,0 +1,152 @@
+import { useState } from "react"
+import { useParams, Link, useNavigate } from "react-router-dom"
+import { ArrowLeft, Check, Play, RefreshCw, Square } from "lucide-react"
+import { useQueryClient } from "@tanstack/react-query"
+import { apiClient } from "@/services/api/client"
+import { useComponent, useStatus, useServiceAction, useEventStream } from "@/services/api/hooks"
+import { ComponentFields } from "@/components/ComponentFields"
+import { HealthBadge } from "@/components/HealthBadge"
+import { LogViewer } from "@/components/LogViewer"
+import { RoleBadge } from "@/components/RoleBadge"
+
+export function ComponentDetailPage() {
+  useEventStream()
+  const navigate = useNavigate()
+  const qc = useQueryClient()
+  const { name } = useParams<{ name: string }>()
+  const { data: component, isLoading, error, refetch } = useComponent(name ?? "")
+  const { data: statusResp } = useStatus()
+  const { mutate, isPending } = useServiceAction()
+  const health = statusResp?.statuses.find((s) => s.id === name)
+  const isDown = health?.status === "down"
+  const [message, setMessage] = useState<{ type: "ok" | "error"; text: string } | null>(null)
+
+  const handleSave = async (compName: string, config: Record<string, unknown>) => {
+    setMessage(null)
+    try {
+      await apiClient.put(`/config/components/${compName}`, { config })
+      setMessage({ type: "ok", text: "Saved to castle.yaml" })
+      refetch()
+      qc.invalidateQueries({ queryKey: ["components"] })
+    } catch (e: unknown) {
+      const msg = e instanceof Error ? e.message : String(e)
+      setMessage({ type: "error", text: msg })
+    }
+  }
+
+  const handleDelete = async (compName: string) => {
+    try {
+      await apiClient.delete(`/config/components/${compName}`)
+      qc.invalidateQueries({ queryKey: ["components"] })
+      navigate("/")
+    } catch (e: unknown) {
+      const msg = e instanceof Error ? e.message : String(e)
+      setMessage({ type: "error", text: msg })
+    }
+  }
+
+  if (isLoading) {
+    return (
+      <div className="max-w-3xl mx-auto px-6 py-8 text-[var(--muted)]">
+        Loading...
+      </div>
+    )
+  }
+
+  if (error || !component) {
+    return (
+      <div className="max-w-3xl mx-auto px-6 py-8">
+        <Link to="/" className="text-[var(--primary)] hover:underline flex items-center gap-1 mb-4">
+          <ArrowLeft size={16} /> Back
+        </Link>
+        <p className="text-red-400">Component not found</p>
+      </div>
+    )
+  }
+
+  return (
+    <div className="max-w-3xl mx-auto px-6 py-8">
+      <Link to="/" className="text-[var(--primary)] hover:underline flex items-center gap-1 mb-6">
+        <ArrowLeft size={16} /> Back
+      </Link>
+
+      <div className="flex items-start justify-between mb-4">
+        <h1 className="text-2xl font-bold">{component.id}</h1>
+        <div className="flex items-center gap-2">
+          {health && <HealthBadge status={health.status} latency={health.latency_ms} />}
+          {component.managed && (
+            <div className="flex items-center gap-1 ml-2">
+              {isDown && (
+                <button
+                  onClick={() => mutate({ name: component.id, action: "start" })}
+                  disabled={isPending}
+                  className="p-1.5 rounded hover:bg-green-800/30 text-green-400 transition-colors disabled:opacity-40"
+                  title="Start"
+                >
+                  <Play size={16} />
+                </button>
+              )}
+              <button
+                onClick={() => mutate({ name: component.id, action: "restart" })}
+                disabled={isPending}
+                className="p-1.5 rounded hover:bg-blue-800/30 text-blue-400 transition-colors disabled:opacity-40"
+                title="Restart"
+              >
+                <RefreshCw size={16} />
+              </button>
+              {!isDown && (
+                <button
+                  onClick={() => mutate({ name: component.id, action: "stop" })}
+                  disabled={isPending}
+                  className="p-1.5 rounded hover:bg-red-800/30 text-red-400 transition-colors disabled:opacity-40"
+                  title="Stop"
+                >
+                  <Square size={16} />
+                </button>
+              )}
+            </div>
+          )}
+        </div>
+      </div>
+
+      <div className="flex gap-1.5 mb-6">
+        {component.roles.map((role) => (
+          <RoleBadge key={role} role={role} />
+        ))}
+      </div>
+
+      {message && (
+        <div
+          className={`mb-4 px-3 py-2 rounded text-sm ${
+            message.type === "ok"
+              ? "bg-green-900/30 text-green-300 border border-green-800"
+              : "bg-red-900/30 text-red-300 border border-red-800"
+          }`}
+        >
+          <span className="flex items-center gap-1.5">
+            {message.type === "ok" && <Check size={14} />}
+            {message.text}
+          </span>
+        </div>
+      )}
+
+      <div className="bg-[var(--card)] border border-[var(--border)] rounded-lg p-5 mb-6">
+        <h2 className="text-sm font-semibold text-[var(--muted)] uppercase tracking-wider mb-4">
+          Configuration
+        </h2>
+        <ComponentFields
+          component={component}
+          onSave={handleSave}
+          onDelete={handleDelete}
+        />
+      </div>
+
+      {component.managed && (
+        <div className="mb-6">
+          <h2 className="text-lg font-semibold mb-3">Logs</h2>
+          <LogViewer name={component.id} />
+        </div>
+      )}
+    </div>
+  )
+}

dashboard/src/pages/ConfigEditor.tsx

@@ -0,0 +1,146 @@
+import { useState } from "react"
+import { Link } from "react-router-dom"
+import { ArrowLeft, Check, Loader2, Zap } from "lucide-react"
+import { useQuery, useQueryClient } from "@tanstack/react-query"
+import { apiClient } from "@/services/api/client"
+import type { ComponentDetail } from "@/types"
+import { AddComponent } from "@/components/AddComponent"
+import { ComponentEditor } from "@/components/ComponentEditor"
+
+interface ApplyResult {
+  ok: boolean
+  actions: string[]
+  errors: string[]
+}
+
+export function ConfigEditorPage() {
+  const qc = useQueryClient()
+  const [applying, setApplying] = useState(false)
+  const [message, setMessage] = useState<{ type: "ok" | "error"; text: string } | null>(null)
+  const [applyResult, setApplyResult] = useState<ApplyResult | null>(null)
+
+  const { data: components, isLoading, refetch } = useQuery({
+    queryKey: ["config-components"],
+    queryFn: async () => {
+      const list = await apiClient.get<{ id: string }[]>("/components")
+      const details = await Promise.all(
+        list.map((c) => apiClient.get<ComponentDetail>(`/components/${c.id}`))
+      )
+      return details
+    },
+  })
+
+  const handleSave = async (name: string, config: Record<string, unknown>) => {
+    setMessage(null)
+    setApplyResult(null)
+    try {
+      await apiClient.put(`/config/components/${name}`, { config })
+      setMessage({ type: "ok", text: `Saved ${name}` })
+      refetch()
+      qc.invalidateQueries({ queryKey: ["components"] })
+    } catch (e: unknown) {
+      const msg = e instanceof Error ? e.message : String(e)
+      setMessage({ type: "error", text: msg })
+    }
+  }
+
+  const handleDelete = async (name: string) => {
+    setMessage(null)
+    try {
+      await apiClient.delete(`/config/components/${name}`)
+      setMessage({ type: "ok", text: `Removed ${name}` })
+      refetch()
+      qc.invalidateQueries({ queryKey: ["components"] })
+    } catch (e: unknown) {
+      const msg = e instanceof Error ? e.message : String(e)
+      setMessage({ type: "error", text: msg })
+    }
+  }
+
+  const handleApply = async () => {
+    setApplying(true)
+    setMessage(null)
+    setApplyResult(null)
+    try {
+      const result = await apiClient.post<ApplyResult>("/config/apply")
+      setApplyResult(result)
+      setMessage({
+        type: result.ok ? "ok" : "error",
+        text: result.ok ? "Applied successfully" : "Applied with errors",
+      })
+      qc.invalidateQueries({ queryKey: ["components"] })
+      qc.invalidateQueries({ queryKey: ["status"] })
+    } catch (e: unknown) {
+      const msg = e instanceof Error ? e.message : String(e)
+      setMessage({ type: "error", text: msg })
+    } finally {
+      setApplying(false)
+    }
+  }
+
+  return (
+    <div className="max-w-4xl mx-auto px-6 py-8">
+      <div className="flex items-center justify-between mb-6">
+        <div className="flex items-center gap-4">
+          <Link to="/" className="text-[var(--primary)] hover:underline flex items-center gap-1">
+            <ArrowLeft size={16} /> Dashboard
+          </Link>
+          <h1 className="text-2xl font-bold">Configuration</h1>
+        </div>
+        <button
+          onClick={handleApply}
+          disabled={applying}
+          className="flex items-center gap-1.5 px-3 py-1.5 text-sm rounded bg-blue-700 hover:bg-blue-600 text-white transition-colors disabled:opacity-40"
+        >
+          {applying ? <Loader2 size={14} className="animate-spin" /> : <Zap size={14} />}
+          Apply All
+        </button>
+      </div>
+
+      {message && (
+        <div
+          className={`mb-4 px-3 py-2 rounded text-sm ${
+            message.type === "ok"
+              ? "bg-green-900/30 text-green-300 border border-green-800"
+              : "bg-red-900/30 text-red-300 border border-red-800"
+          }`}
+        >
+          <span className="flex items-center gap-1.5">
+            {message.type === "ok" && <Check size={14} />}
+            {message.text}
+          </span>
+        </div>
+      )}
+
+      {applyResult && (
+        <div className="mb-4 bg-[var(--card)] border border-[var(--border)] rounded-lg p-4 text-sm space-y-1">
+          {applyResult.actions.map((a, i) => (
+            <div key={i} className="text-green-400">{a}</div>
+          ))}
+          {applyResult.errors.map((e, i) => (
+            <div key={i} className="text-red-400">{e}</div>
+          ))}
+        </div>
+      )}
+
+      {isLoading ? (
+        <p className="text-[var(--muted)]">Loading components...</p>
+      ) : (
+        <div className="space-y-2">
+          {components?.map((comp) => (
+            <ComponentEditor
+              key={comp.id}
+              component={comp}
+              onSave={handleSave}
+              onDelete={handleDelete}
+            />
+          ))}
+          <AddComponent
+            existingNames={components?.map((c) => c.id) ?? []}
+            onAdd={handleSave}
+          />
+        </div>
+      )}
+    </div>
+  )
+}

dashboard/src/pages/Dashboard.tsx

@@ -0,0 +1,46 @@
+import { Link } from "react-router-dom"
+import { Settings } from "lucide-react"
+import { ComponentGrid } from "@/components/ComponentGrid"
+import { useComponents, useStatus, useGateway, useEventStream } from "@/services/api/hooks"
+
+export function Dashboard() {
+  useEventStream()
+  const { data: components, isLoading } = useComponents()
+  const { data: statusResp } = useStatus()
+  const { data: gateway } = useGateway()
+
+  return (
+    <div className="max-w-6xl mx-auto px-6 py-8">
+      <div className="flex items-start justify-between mb-8">
+        <div>
+          <h1 className="text-3xl font-bold">Castle</h1>
+          <p className="text-[var(--muted)] mt-1">
+            Personal software platform
+            {gateway && (
+              <span className="ml-2 text-sm">
+                &middot; {gateway.component_count} components &middot; port {gateway.port}
+              </span>
+            )}
+          </p>
+        </div>
+        <Link
+          to="/config"
+          className="flex items-center gap-1.5 px-3 py-1.5 text-sm rounded bg-[var(--border)] hover:bg-gray-600 text-[var(--foreground)] transition-colors"
+        >
+          <Settings size={14} /> Config
+        </Link>
+      </div>
+
+      {isLoading ? (
+        <p className="text-[var(--muted)]">Loading components...</p>
+      ) : components ? (
+        <ComponentGrid
+          components={components}
+          statuses={statusResp?.statuses ?? []}
+        />
+      ) : (
+        <p className="text-red-400">Failed to load components</p>
+      )}
+    </div>
+  )
+}

dashboard/src/router/routes.tsx

@@ -0,0 +1,19 @@
+import { createBrowserRouter } from "react-router-dom"
+import { Dashboard } from "@/pages/Dashboard"
+import { ComponentDetailPage } from "@/pages/ComponentDetail"
+import { ConfigEditorPage } from "@/pages/ConfigEditor"
+
+export const router = createBrowserRouter([
+  {
+    path: "/",
+    element: <Dashboard />,
+  },
+  {
+    path: "/config",
+    element: <ConfigEditorPage />,
+  },
+  {
+    path: "/:name",
+    element: <ComponentDetailPage />,
+  },
+])

dashboard/src/services/api/client.ts

@@ -0,0 +1,64 @@
+const BASE_URL = import.meta.env.VITE_API_BASE_URL ?? "/api"
+
+class ApiError extends Error {
+  status: number
+  constructor(status: number, message: string) {
+    super(message)
+    this.status = status
+  }
+}
+
+class ApiClient {
+  private baseUrl: string
+
+  constructor(baseUrl = BASE_URL) {
+    this.baseUrl = baseUrl
+  }
+
+  async get<T>(path: string): Promise<T> {
+    const resp = await fetch(`${this.baseUrl}${path}`)
+    if (!resp.ok) {
+      throw new ApiError(resp.status, await resp.text())
+    }
+    return resp.json()
+  }
+
+  async post<T>(path: string, body?: unknown): Promise<T> {
+    const resp = await fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: body ? { "Content-Type": "application/json" } : {},
+      body: body ? JSON.stringify(body) : undefined,
+    })
+    if (!resp.ok) {
+      throw new ApiError(resp.status, await resp.text())
+    }
+    return resp.json()
+  }
+
+  async put<T>(path: string, body?: unknown): Promise<T> {
+    const resp = await fetch(`${this.baseUrl}${path}`, {
+      method: "PUT",
+      headers: body ? { "Content-Type": "application/json" } : {},
+      body: body ? JSON.stringify(body) : undefined,
+    })
+    if (!resp.ok) {
+      throw new ApiError(resp.status, await resp.text())
+    }
+    return resp.json()
+  }
+
+  async delete<T>(path: string): Promise<T> {
+    const resp = await fetch(`${this.baseUrl}${path}`, { method: "DELETE" })
+    if (!resp.ok) {
+      throw new ApiError(resp.status, await resp.text())
+    }
+    return resp.json()
+  }
+
+  streamUrl(path: string): string {
+    return `${this.baseUrl}${path}`
+  }
+}
+
+export const apiClient = new ApiClient()
+export { ApiError }

dashboard/src/services/api/hooks.ts

@@ -0,0 +1,76 @@
+import { useEffect } from "react"
+import { useQuery, useQueryClient, useMutation } from "@tanstack/react-query"
+import { apiClient } from "./client"
+import type {
+  ComponentSummary,
+  ComponentDetail,
+  StatusResponse,
+  GatewayInfo,
+  ServiceActionResponse,
+  SSEHealthEvent,
+} from "@/types"
+
+export function useComponents() {
+  return useQuery({
+    queryKey: ["components"],
+    queryFn: () => apiClient.get<ComponentSummary[]>("/components"),
+  })
+}
+
+export function useComponent(name: string) {
+  return useQuery({
+    queryKey: ["components", name],
+    queryFn: () => apiClient.get<ComponentDetail>(`/components/${name}`),
+    enabled: !!name,
+  })
+}
+
+export function useStatus() {
+  return useQuery({
+    queryKey: ["status"],
+    queryFn: () => apiClient.get<StatusResponse>("/status"),
+    // SSE provides live updates; this is the fallback poll
+    refetchInterval: 30_000,
+  })
+}
+
+export function useGateway() {
+  return useQuery({
+    queryKey: ["gateway"],
+    queryFn: () => apiClient.get<GatewayInfo>("/gateway"),
+  })
+}
+
+export function useServiceAction() {
+  return useMutation({
+    mutationFn: ({ name, action }: { name: string; action: string }) =>
+      apiClient.post<ServiceActionResponse>(`/services/${name}/${action}`),
+    // SSE health event handles the UI update; no need to refetch here
+  })
+}
+
+export function useEventStream() {
+  const qc = useQueryClient()
+
+  useEffect(() => {
+    const url = apiClient.streamUrl("/stream")
+    const es = new EventSource(url)
+
+    es.addEventListener("health", (e) => {
+      const data: SSEHealthEvent = JSON.parse(e.data)
+      qc.setQueryData<StatusResponse>(["status"], { statuses: data.statuses })
+    })
+
+    es.addEventListener("service-action", () => {
+      // Health event already pushes correct status; just refetch components
+      // in case the action changed what's available
+      qc.invalidateQueries({ queryKey: ["components"] })
+    })
+
+    es.onerror = () => {
+      // EventSource auto-reconnects; nothing to do
+    }
+
+    return () => es.close()
+  }, [qc])
+}

dashboard/src/types/index.ts

@@ -0,0 +1,57 @@
+export interface ComponentSummary {
+  id: string
+  description: string | null
+  roles: string[]
+  runner: string | null
+  port: number | null
+  health_path: string | null
+  proxy_path: string | null
+  managed: boolean
+}
+
+export interface ComponentDetail extends ComponentSummary {
+  manifest: Record<string, unknown>
+}
+
+export interface HealthStatus {
+  id: string
+  status: "up" | "down" | "unknown"
+  latency_ms: number | null
+}
+
+export interface StatusResponse {
+  statuses: HealthStatus[]
+}
+
+export interface GatewayInfo {
+  port: number
+  component_count: number
+  service_count: number
+  managed_count: number
+}
+
+export interface ServiceActionResponse {
+  component: string
+  action: string
+  status: string
+}
+
+export interface SSEHealthEvent {
+  statuses: HealthStatus[]
+  timestamp: number
+}
+
+export interface SSEServiceActionEvent {
+  action: string
+  component: string
+  status: string
+}
+
+export interface ToolInfo {
+  command: string
+  description: string
+  category: string
+  version: string
+  system_dependencies: string[]
+  script: string
+}

dashboard/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

dashboard/tsconfig.app.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "ES2022",
+    "useDefineForClassFields": true,
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "types": ["vite/client"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src"]
+}

dashboard/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}

dashboard/tsconfig.node.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2023",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "types": ["node"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts"]
+}

dashboard/vite.config.ts

@@ -0,0 +1,21 @@
+import path from "path"
+import tailwindcss from "@tailwindcss/vite"
+import { defineConfig } from "vite"
+import react from "@vitejs/plugin-react"
+
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+    },
+  },
+  server: {
+    proxy: {
+      "/api": {
+        target: "http://localhost:9020",
+        rewrite: (path) => path.replace(/^\/api/, ""),
+      },
+    },
+  },
+})

devbox-connect/uv.lock

@@ -0,0 +1,371 @@
+version = 1
+revision = 3
+requires-python = ">=3.10"
+
+[[package]]
+name = "bcrypt"
+version = "5.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d4/36/3329e2518d70ad8e2e5817d5a4cac6bba05a47767ec416c7d020a965f408/bcrypt-5.0.0.tar.gz", hash = "sha256:f748f7c2d6fd375cc93d3fba7ef4a9e3a092421b8dbf34d8d4dc06be9492dfdd", size = 25386, upload-time = "2025-09-25T19:50:47.829Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/13/85/3e65e01985fddf25b64ca67275bb5bdb4040bd1a53b66d355c6c37c8a680/bcrypt-5.0.0-cp313-cp313t-macosx_10_12_universal2.whl", hash = "sha256:f3c08197f3039bec79cee59a606d62b96b16669cff3949f21e74796b6e3cd2be", size = 481806, upload-time = "2025-09-25T19:49:05.102Z" },
+    { url = "https://files.pythonhosted.org/packages/44/dc/01eb79f12b177017a726cbf78330eb0eb442fae0e7b3dfd84ea2849552f3/bcrypt-5.0.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:200af71bc25f22006f4069060c88ed36f8aa4ff7f53e67ff04d2ab3f1e79a5b2", size = 268626, upload-time = "2025-09-25T19:49:06.723Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/cf/e82388ad5959c40d6afd94fb4743cc077129d45b952d46bdc3180310e2df/bcrypt-5.0.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:baade0a5657654c2984468efb7d6c110db87ea63ef5a4b54732e7e337253e44f", size = 271853, upload-time = "2025-09-25T19:49:08.028Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/86/7134b9dae7cf0efa85671651341f6afa695857fae172615e960fb6a466fa/bcrypt-5.0.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:c58b56cdfb03202b3bcc9fd8daee8e8e9b6d7e3163aa97c631dfcfcc24d36c86", size = 269793, upload-time = "2025-09-25T19:49:09.727Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/82/6296688ac1b9e503d034e7d0614d56e80c5d1a08402ff856a4549cb59207/bcrypt-5.0.0-cp313-cp313t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4bfd2a34de661f34d0bda43c3e4e79df586e4716ef401fe31ea39d69d581ef23", size = 289930, upload-time = "2025-09-25T19:49:11.204Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/18/884a44aa47f2a3b88dd09bc05a1e40b57878ecd111d17e5bba6f09f8bb77/bcrypt-5.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:ed2e1365e31fc73f1825fa830f1c8f8917ca1b3ca6185773b349c20fd606cec2", size = 272194, upload-time = "2025-09-25T19:49:12.524Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/8f/371a3ab33c6982070b674f1788e05b656cfbf5685894acbfef0c65483a59/bcrypt-5.0.0-cp313-cp313t-manylinux_2_34_aarch64.whl", hash = "sha256:83e787d7a84dbbfba6f250dd7a5efd689e935f03dd83b0f919d39349e1f23f83", size = 269381, upload-time = "2025-09-25T19:49:14.308Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/34/7e4e6abb7a8778db6422e88b1f06eb07c47682313997ee8a8f9352e5a6f1/bcrypt-5.0.0-cp313-cp313t-manylinux_2_34_x86_64.whl", hash = "sha256:137c5156524328a24b9fac1cb5db0ba618bc97d11970b39184c1d87dc4bf1746", size = 271750, upload-time = "2025-09-25T19:49:15.584Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/1b/54f416be2499bd72123c70d98d36c6cd61a4e33d9b89562c22481c81bb30/bcrypt-5.0.0-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:38cac74101777a6a7d3b3e3cfefa57089b5ada650dce2baf0cbdd9d65db22a9e", size = 303757, upload-time = "2025-09-25T19:49:17.244Z" },
+    { url = "https://files.pythonhosted.org/packages/13/62/062c24c7bcf9d2826a1a843d0d605c65a755bc98002923d01fd61270705a/bcrypt-5.0.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:d8d65b564ec849643d9f7ea05c6d9f0cd7ca23bdd4ac0c2dbef1104ab504543d", size = 306740, upload-time = "2025-09-25T19:49:18.693Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/c8/1fdbfc8c0f20875b6b4020f3c7dc447b8de60aa0be5faaf009d24242aec9/bcrypt-5.0.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:741449132f64b3524e95cd30e5cd3343006ce146088f074f31ab26b94e6c75ba", size = 334197, upload-time = "2025-09-25T19:49:20.523Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/c1/8b84545382d75bef226fbc6588af0f7b7d095f7cd6a670b42a86243183cd/bcrypt-5.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:212139484ab3207b1f0c00633d3be92fef3c5f0af17cad155679d03ff2ee1e41", size = 352974, upload-time = "2025-09-25T19:49:22.254Z" },
+    { url = "https://files.pythonhosted.org/packages/10/a6/ffb49d4254ed085e62e3e5dd05982b4393e32fe1e49bb1130186617c29cd/bcrypt-5.0.0-cp313-cp313t-win32.whl", hash = "sha256:9d52ed507c2488eddd6a95bccee4e808d3234fa78dd370e24bac65a21212b861", size = 148498, upload-time = "2025-09-25T19:49:24.134Z" },
+    { url = "https://files.pythonhosted.org/packages/48/a9/259559edc85258b6d5fc5471a62a3299a6aa37a6611a169756bf4689323c/bcrypt-5.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f6984a24db30548fd39a44360532898c33528b74aedf81c26cf29c51ee47057e", size = 145853, upload-time = "2025-09-25T19:49:25.702Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/df/9714173403c7e8b245acf8e4be8876aac64a209d1b392af457c79e60492e/bcrypt-5.0.0-cp313-cp313t-win_arm64.whl", hash = "sha256:9fffdb387abe6aa775af36ef16f55e318dcda4194ddbf82007a6f21da29de8f5", size = 139626, upload-time = "2025-09-25T19:49:26.928Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/14/c18006f91816606a4abe294ccc5d1e6f0e42304df5a33710e9e8e95416e1/bcrypt-5.0.0-cp314-cp314t-macosx_10_12_universal2.whl", hash = "sha256:4870a52610537037adb382444fefd3706d96d663ac44cbb2f37e3919dca3d7ef", size = 481862, upload-time = "2025-09-25T19:49:28.365Z" },
+    { url = "https://files.pythonhosted.org/packages/67/49/dd074d831f00e589537e07a0725cf0e220d1f0d5d8e85ad5bbff251c45aa/bcrypt-5.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:48f753100931605686f74e27a7b49238122aa761a9aefe9373265b8b7aa43ea4", size = 268544, upload-time = "2025-09-25T19:49:30.39Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/91/50ccba088b8c474545b034a1424d05195d9fcbaaf802ab8bfe2be5a4e0d7/bcrypt-5.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f70aadb7a809305226daedf75d90379c397b094755a710d7014b8b117df1ebbf", size = 271787, upload-time = "2025-09-25T19:49:32.144Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/e7/d7dba133e02abcda3b52087a7eea8c0d4f64d3e593b4fffc10c31b7061f3/bcrypt-5.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:744d3c6b164caa658adcb72cb8cc9ad9b4b75c7db507ab4bc2480474a51989da", size = 269753, upload-time = "2025-09-25T19:49:33.885Z" },
+    { url = "https://files.pythonhosted.org/packages/33/fc/5b145673c4b8d01018307b5c2c1fc87a6f5a436f0ad56607aee389de8ee3/bcrypt-5.0.0-cp314-cp314t-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a28bc05039bdf3289d757f49d616ab3efe8cf40d8e8001ccdd621cd4f98f4fc9", size = 289587, upload-time = "2025-09-25T19:49:35.144Z" },
+    { url = "https://files.pythonhosted.org/packages/27/d7/1ff22703ec6d4f90e62f1a5654b8867ef96bafb8e8102c2288333e1a6ca6/bcrypt-5.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:7f277a4b3390ab4bebe597800a90da0edae882c6196d3038a73adf446c4f969f", size = 272178, upload-time = "2025-09-25T19:49:36.793Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/88/815b6d558a1e4d40ece04a2f84865b0fef233513bd85fd0e40c294272d62/bcrypt-5.0.0-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:79cfa161eda8d2ddf29acad370356b47f02387153b11d46042e93a0a95127493", size = 269295, upload-time = "2025-09-25T19:49:38.164Z" },
+    { url = "https://files.pythonhosted.org/packages/51/8c/e0db387c79ab4931fc89827d37608c31cc57b6edc08ccd2386139028dc0d/bcrypt-5.0.0-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:a5393eae5722bcef046a990b84dff02b954904c36a194f6cfc817d7dca6c6f0b", size = 271700, upload-time = "2025-09-25T19:49:39.917Z" },
+    { url = "https://files.pythonhosted.org/packages/06/83/1570edddd150f572dbe9fc00f6203a89fc7d4226821f67328a85c330f239/bcrypt-5.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7f4c94dec1b5ab5d522750cb059bb9409ea8872d4494fd152b53cca99f1ddd8c", size = 334034, upload-time = "2025-09-25T19:49:41.227Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/f2/ea64e51a65e56ae7a8a4ec236c2bfbdd4b23008abd50ac33fbb2d1d15424/bcrypt-5.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0cae4cb350934dfd74c020525eeae0a5f79257e8a201c0c176f4b84fdbf2a4b4", size = 352766, upload-time = "2025-09-25T19:49:43.08Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/d4/1a388d21ee66876f27d1a1f41287897d0c0f1712ef97d395d708ba93004c/bcrypt-5.0.0-cp314-cp314t-win32.whl", hash = "sha256:b17366316c654e1ad0306a6858e189fc835eca39f7eb2cafd6aaca8ce0c40a2e", size = 152449, upload-time = "2025-09-25T19:49:44.971Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/61/3291c2243ae0229e5bca5d19f4032cecad5dfb05a2557169d3a69dc0ba91/bcrypt-5.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:92864f54fb48b4c718fc92a32825d0e42265a627f956bc0361fe869f1adc3e7d", size = 149310, upload-time = "2025-09-25T19:49:46.162Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/89/4b01c52ae0c1a681d4021e5dd3e45b111a8fb47254a274fa9a378d8d834b/bcrypt-5.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dd19cf5184a90c873009244586396a6a884d591a5323f0e8a5922560718d4993", size = 143761, upload-time = "2025-09-25T19:49:47.345Z" },
+    { url = "https://files.pythonhosted.org/packages/84/29/6237f151fbfe295fe3e074ecc6d44228faa1e842a81f6d34a02937ee1736/bcrypt-5.0.0-cp38-abi3-macosx_10_12_universal2.whl", hash = "sha256:fc746432b951e92b58317af8e0ca746efe93e66555f1b40888865ef5bf56446b", size = 494553, upload-time = "2025-09-25T19:49:49.006Z" },
+    { url = "https://files.pythonhosted.org/packages/45/b6/4c1205dde5e464ea3bd88e8742e19f899c16fa8916fb8510a851fae985b5/bcrypt-5.0.0-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c2388ca94ffee269b6038d48747f4ce8df0ffbea43f31abfa18ac72f0218effb", size = 275009, upload-time = "2025-09-25T19:49:50.581Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/71/427945e6ead72ccffe77894b2655b695ccf14ae1866cd977e185d606dd2f/bcrypt-5.0.0-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:560ddb6ec730386e7b3b26b8b4c88197aaed924430e7b74666a586ac997249ef", size = 278029, upload-time = "2025-09-25T19:49:52.533Z" },
+    { url = "https://files.pythonhosted.org/packages/17/72/c344825e3b83c5389a369c8a8e58ffe1480b8a699f46c127c34580c4666b/bcrypt-5.0.0-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:d79e5c65dcc9af213594d6f7f1fa2c98ad3fc10431e7aa53c176b441943efbdd", size = 275907, upload-time = "2025-09-25T19:49:54.709Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/7e/d4e47d2df1641a36d1212e5c0514f5291e1a956a7749f1e595c07a972038/bcrypt-5.0.0-cp38-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2b732e7d388fa22d48920baa267ba5d97cca38070b69c0e2d37087b381c681fd", size = 296500, upload-time = "2025-09-25T19:49:56.013Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/c3/0ae57a68be2039287ec28bc463b82e4b8dc23f9d12c0be331f4782e19108/bcrypt-5.0.0-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:0c8e093ea2532601a6f686edbc2c6b2ec24131ff5c52f7610dd64fa4553b5464", size = 278412, upload-time = "2025-09-25T19:49:57.356Z" },
+    { url = "https://files.pythonhosted.org/packages/45/2b/77424511adb11e6a99e3a00dcc7745034bee89036ad7d7e255a7e47be7d8/bcrypt-5.0.0-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:5b1589f4839a0899c146e8892efe320c0fa096568abd9b95593efac50a87cb75", size = 275486, upload-time = "2025-09-25T19:49:59.116Z" },
+    { url = "https://files.pythonhosted.org/packages/43/0a/405c753f6158e0f3f14b00b462d8bca31296f7ecfc8fc8bc7919c0c7d73a/bcrypt-5.0.0-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:89042e61b5e808b67daf24a434d89bab164d4de1746b37a8d173b6b14f3db9ff", size = 277940, upload-time = "2025-09-25T19:50:00.869Z" },
+    { url = "https://files.pythonhosted.org/packages/62/83/b3efc285d4aadc1fa83db385ec64dcfa1707e890eb42f03b127d66ac1b7b/bcrypt-5.0.0-cp38-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:e3cf5b2560c7b5a142286f69bde914494b6d8f901aaa71e453078388a50881c4", size = 310776, upload-time = "2025-09-25T19:50:02.393Z" },
+    { url = "https://files.pythonhosted.org/packages/95/7d/47ee337dacecde6d234890fe929936cb03ebc4c3a7460854bbd9c97780b8/bcrypt-5.0.0-cp38-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:f632fd56fc4e61564f78b46a2269153122db34988e78b6be8b32d28507b7eaeb", size = 312922, upload-time = "2025-09-25T19:50:04.232Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/3a/43d494dfb728f55f4e1cf8fd435d50c16a2d75493225b54c8d06122523c6/bcrypt-5.0.0-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:801cad5ccb6b87d1b430f183269b94c24f248dddbbc5c1f78b6ed231743e001c", size = 341367, upload-time = "2025-09-25T19:50:05.559Z" },
+    { url = "https://files.pythonhosted.org/packages/55/ab/a0727a4547e383e2e22a630e0f908113db37904f58719dc48d4622139b5c/bcrypt-5.0.0-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:3cf67a804fc66fc217e6914a5635000259fbbbb12e78a99488e4d5ba445a71eb", size = 359187, upload-time = "2025-09-25T19:50:06.916Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/bb/461f352fdca663524b4643d8b09e8435b4990f17fbf4fea6bc2a90aa0cc7/bcrypt-5.0.0-cp38-abi3-win32.whl", hash = "sha256:3abeb543874b2c0524ff40c57a4e14e5d3a66ff33fb423529c88f180fd756538", size = 153752, upload-time = "2025-09-25T19:50:08.515Z" },
+    { url = "https://files.pythonhosted.org/packages/41/aa/4190e60921927b7056820291f56fc57d00d04757c8b316b2d3c0d1d6da2c/bcrypt-5.0.0-cp38-abi3-win_amd64.whl", hash = "sha256:35a77ec55b541e5e583eb3436ffbbf53b0ffa1fa16ca6782279daf95d146dcd9", size = 150881, upload-time = "2025-09-25T19:50:09.742Z" },
+    { url = "https://files.pythonhosted.org/packages/54/12/cd77221719d0b39ac0b55dbd39358db1cd1246e0282e104366ebbfb8266a/bcrypt-5.0.0-cp38-abi3-win_arm64.whl", hash = "sha256:cde08734f12c6a4e28dc6755cd11d3bdfea608d93d958fffbe95a7026ebe4980", size = 144931, upload-time = "2025-09-25T19:50:11.016Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/ba/2af136406e1c3839aea9ecadc2f6be2bcd1eff255bd451dd39bcf302c47a/bcrypt-5.0.0-cp39-abi3-macosx_10_12_universal2.whl", hash = "sha256:0c418ca99fd47e9c59a301744d63328f17798b5947b0f791e9af3c1c499c2d0a", size = 495313, upload-time = "2025-09-25T19:50:12.309Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/ee/2f4985dbad090ace5ad1f7dd8ff94477fe089b5fab2040bd784a3d5f187b/bcrypt-5.0.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ddb4e1500f6efdd402218ffe34d040a1196c072e07929b9820f363a1fd1f4191", size = 275290, upload-time = "2025-09-25T19:50:13.673Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/6e/b77ade812672d15cf50842e167eead80ac3514f3beacac8902915417f8b7/bcrypt-5.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7aeef54b60ceddb6f30ee3db090351ecf0d40ec6e2abf41430997407a46d2254", size = 278253, upload-time = "2025-09-25T19:50:15.089Z" },
+    { url = "https://files.pythonhosted.org/packages/36/c4/ed00ed32f1040f7990dac7115f82273e3c03da1e1a1587a778d8cea496d8/bcrypt-5.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:f0ce778135f60799d89c9693b9b398819d15f1921ba15fe719acb3178215a7db", size = 276084, upload-time = "2025-09-25T19:50:16.699Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/c4/fa6e16145e145e87f1fa351bbd54b429354fd72145cd3d4e0c5157cf4c70/bcrypt-5.0.0-cp39-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a71f70ee269671460b37a449f5ff26982a6f2ba493b3eabdd687b4bf35f875ac", size = 297185, upload-time = "2025-09-25T19:50:18.525Z" },
+    { url = "https://files.pythonhosted.org/packages/24/b4/11f8a31d8b67cca3371e046db49baa7c0594d71eb40ac8121e2fc0888db0/bcrypt-5.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:f8429e1c410b4073944f03bd778a9e066e7fad723564a52ff91841d278dfc822", size = 278656, upload-time = "2025-09-25T19:50:19.809Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/31/79f11865f8078e192847d2cb526e3fa27c200933c982c5b2869720fa5fce/bcrypt-5.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:edfcdcedd0d0f05850c52ba3127b1fce70b9f89e0fe5ff16517df7e81fa3cbb8", size = 275662, upload-time = "2025-09-25T19:50:21.567Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/8d/5e43d9584b3b3591a6f9b68f755a4da879a59712981ef5ad2a0ac1379f7a/bcrypt-5.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:611f0a17aa4a25a69362dcc299fda5c8a3d4f160e2abb3831041feb77393a14a", size = 278240, upload-time = "2025-09-25T19:50:23.305Z" },
+    { url = "https://files.pythonhosted.org/packages/89/48/44590e3fc158620f680a978aafe8f87a4c4320da81ed11552f0323aa9a57/bcrypt-5.0.0-cp39-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:db99dca3b1fdc3db87d7c57eac0c82281242d1eabf19dcb8a6b10eb29a2e72d1", size = 311152, upload-time = "2025-09-25T19:50:24.597Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/85/e4fbfc46f14f47b0d20493669a625da5827d07e8a88ee460af6cd9768b44/bcrypt-5.0.0-cp39-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:5feebf85a9cefda32966d8171f5db7e3ba964b77fdfe31919622256f80f9cf42", size = 313284, upload-time = "2025-09-25T19:50:26.268Z" },
+    { url = "https://files.pythonhosted.org/packages/25/ae/479f81d3f4594456a01ea2f05b132a519eff9ab5768a70430fa1132384b1/bcrypt-5.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:3ca8a166b1140436e058298a34d88032ab62f15aae1c598580333dc21d27ef10", size = 341643, upload-time = "2025-09-25T19:50:28.02Z" },
+    { url = "https://files.pythonhosted.org/packages/df/d2/36a086dee1473b14276cd6ea7f61aef3b2648710b5d7f1c9e032c29b859f/bcrypt-5.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:61afc381250c3182d9078551e3ac3a41da14154fbff647ddf52a769f588c4172", size = 359698, upload-time = "2025-09-25T19:50:31.347Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/f6/688d2cd64bfd0b14d805ddb8a565e11ca1fb0fd6817175d58b10052b6d88/bcrypt-5.0.0-cp39-abi3-win32.whl", hash = "sha256:64d7ce196203e468c457c37ec22390f1a61c85c6f0b8160fd752940ccfb3a683", size = 153725, upload-time = "2025-09-25T19:50:34.384Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/b9/9d9a641194a730bda138b3dfe53f584d61c58cd5230e37566e83ec2ffa0d/bcrypt-5.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:64ee8434b0da054d830fa8e89e1c8bf30061d539044a39524ff7dec90481e5c2", size = 150912, upload-time = "2025-09-25T19:50:35.69Z" },
+    { url = "https://files.pythonhosted.org/packages/27/44/d2ef5e87509158ad2187f4dd0852df80695bb1ee0cfe0a684727b01a69e0/bcrypt-5.0.0-cp39-abi3-win_arm64.whl", hash = "sha256:f2347d3534e76bf50bca5500989d6c1d05ed64b440408057a37673282c654927", size = 144953, upload-time = "2025-09-25T19:50:37.32Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/75/4aa9f5a4d40d762892066ba1046000b329c7cd58e888a6db878019b282dc/bcrypt-5.0.0-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:7edda91d5ab52b15636d9c30da87d2cc84f426c72b9dba7a9b4fe142ba11f534", size = 271180, upload-time = "2025-09-25T19:50:38.575Z" },
+    { url = "https://files.pythonhosted.org/packages/54/79/875f9558179573d40a9cc743038ac2bf67dfb79cecb1e8b5d70e88c94c3d/bcrypt-5.0.0-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:046ad6db88edb3c5ece4369af997938fb1c19d6a699b9c1b27b0db432faae4c4", size = 273791, upload-time = "2025-09-25T19:50:39.913Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/fe/975adb8c216174bf70fc17535f75e85ac06ed5252ea077be10d9cff5ce24/bcrypt-5.0.0-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:dcd58e2b3a908b5ecc9b9df2f0085592506ac2d5110786018ee5e160f28e0911", size = 270746, upload-time = "2025-09-25T19:50:43.306Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/f8/972c96f5a2b6c4b3deca57009d93e946bbdbe2241dca9806d502f29dd3ee/bcrypt-5.0.0-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:6b8f520b61e8781efee73cba14e3e8c9556ccfb375623f4f97429544734545b4", size = 273375, upload-time = "2025-09-25T19:50:45.43Z" },
+]
+
+[[package]]
+name = "cffi"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycparser", marker = "implementation_name != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/93/d7/516d984057745a6cd96575eea814fe1edd6646ee6efd552fb7b0921dec83/cffi-2.0.0-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:0cf2d91ecc3fcc0625c2c530fe004f82c110405f101548512cce44322fa8ac44", size = 184283, upload-time = "2025-09-08T23:22:08.01Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/84/ad6a0b408daa859246f57c03efd28e5dd1b33c21737c2db84cae8c237aa5/cffi-2.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f73b96c41e3b2adedc34a7356e64c8eb96e03a3782b535e043a986276ce12a49", size = 180504, upload-time = "2025-09-08T23:22:10.637Z" },
+    { url = "https://files.pythonhosted.org/packages/50/bd/b1a6362b80628111e6653c961f987faa55262b4002fcec42308cad1db680/cffi-2.0.0-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:53f77cbe57044e88bbd5ed26ac1d0514d2acf0591dd6bb02a3ae37f76811b80c", size = 208811, upload-time = "2025-09-08T23:22:12.267Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/27/6933a8b2562d7bd1fb595074cf99cc81fc3789f6a6c05cdabb46284a3188/cffi-2.0.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3e837e369566884707ddaf85fc1744b47575005c0a229de3327f8f9a20f4efeb", size = 216402, upload-time = "2025-09-08T23:22:13.455Z" },
+    { url = "https://files.pythonhosted.org/packages/05/eb/b86f2a2645b62adcfff53b0dd97e8dfafb5c8aa864bd0d9a2c2049a0d551/cffi-2.0.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5eda85d6d1879e692d546a078b44251cdd08dd1cfb98dfb77b670c97cee49ea0", size = 203217, upload-time = "2025-09-08T23:22:14.596Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/e0/6cbe77a53acf5acc7c08cc186c9928864bd7c005f9efd0d126884858a5fe/cffi-2.0.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9332088d75dc3241c702d852d4671613136d90fa6881da7d770a483fd05248b4", size = 203079, upload-time = "2025-09-08T23:22:15.769Z" },
+    { url = "https://files.pythonhosted.org/packages/98/29/9b366e70e243eb3d14a5cb488dfd3a0b6b2f1fb001a203f653b93ccfac88/cffi-2.0.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc7de24befaeae77ba923797c7c87834c73648a05a4bde34b3b7e5588973a453", size = 216475, upload-time = "2025-09-08T23:22:17.427Z" },
+    { url = "https://files.pythonhosted.org/packages/21/7a/13b24e70d2f90a322f2900c5d8e1f14fa7e2a6b3332b7309ba7b2ba51a5a/cffi-2.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cf364028c016c03078a23b503f02058f1814320a56ad535686f90565636a9495", size = 218829, upload-time = "2025-09-08T23:22:19.069Z" },
+    { url = "https://files.pythonhosted.org/packages/60/99/c9dc110974c59cc981b1f5b66e1d8af8af764e00f0293266824d9c4254bc/cffi-2.0.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e11e82b744887154b182fd3e7e8512418446501191994dbf9c9fc1f32cc8efd5", size = 211211, upload-time = "2025-09-08T23:22:20.588Z" },
+    { url = "https://files.pythonhosted.org/packages/49/72/ff2d12dbf21aca1b32a40ed792ee6b40f6dc3a9cf1644bd7ef6e95e0ac5e/cffi-2.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8ea985900c5c95ce9db1745f7933eeef5d314f0565b27625d9a10ec9881e1bfb", size = 218036, upload-time = "2025-09-08T23:22:22.143Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/cc/027d7fb82e58c48ea717149b03bcadcbdc293553edb283af792bd4bcbb3f/cffi-2.0.0-cp310-cp310-win32.whl", hash = "sha256:1f72fb8906754ac8a2cc3f9f5aaa298070652a0ffae577e0ea9bd480dc3c931a", size = 172184, upload-time = "2025-09-08T23:22:23.328Z" },
+    { url = "https://files.pythonhosted.org/packages/33/fa/072dd15ae27fbb4e06b437eb6e944e75b068deb09e2a2826039e49ee2045/cffi-2.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:b18a3ed7d5b3bd8d9ef7a8cb226502c6bf8308df1525e1cc676c3680e7176739", size = 182790, upload-time = "2025-09-08T23:22:24.752Z" },
+    { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload-time = "2025-09-08T23:22:26.456Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload-time = "2025-09-08T23:22:28.197Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload-time = "2025-09-08T23:22:29.475Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload-time = "2025-09-08T23:22:31.063Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload-time = "2025-09-08T23:22:32.507Z" },
+    { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload-time = "2025-09-08T23:22:34.132Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload-time = "2025-09-08T23:22:35.443Z" },
+    { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload-time = "2025-09-08T23:22:36.805Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload-time = "2025-09-08T23:22:38.436Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload-time = "2025-09-08T23:22:39.776Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" },
+    { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" },
+    { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" },
+    { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" },
+    { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" },
+    { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" },
+    { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" },
+    { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" },
+    { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" },
+    { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" },
+    { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" },
+    { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" },
+    { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" },
+    { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" },
+    { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" },
+]
+
+[[package]]
+name = "cryptography"
+version = "46.0.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/60/04/ee2a9e8542e4fa2773b81771ff8349ff19cdd56b7258a0cc442639052edb/cryptography-46.0.5.tar.gz", hash = "sha256:abace499247268e3757271b2f1e244b36b06f8515cf27c4d49468fc9eb16e93d", size = 750064, upload-time = "2026-02-10T19:18:38.255Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f7/81/b0bb27f2ba931a65409c6b8a8b358a7f03c0e46eceacddff55f7c84b1f3b/cryptography-46.0.5-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:351695ada9ea9618b3500b490ad54c739860883df6c1f555e088eaf25b1bbaad", size = 7176289, upload-time = "2026-02-10T19:17:08.274Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/9e/6b4397a3e3d15123de3b1806ef342522393d50736c13b20ec4c9ea6693a6/cryptography-46.0.5-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c18ff11e86df2e28854939acde2d003f7984f721eba450b56a200ad90eeb0e6b", size = 4275637, upload-time = "2026-02-10T19:17:10.53Z" },
+    { url = "https://files.pythonhosted.org/packages/63/e7/471ab61099a3920b0c77852ea3f0ea611c9702f651600397ac567848b897/cryptography-46.0.5-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4d7e3d356b8cd4ea5aff04f129d5f66ebdc7b6f8eae802b93739ed520c47c79b", size = 4424742, upload-time = "2026-02-10T19:17:12.388Z" },
+    { url = "https://files.pythonhosted.org/packages/37/53/a18500f270342d66bf7e4d9f091114e31e5ee9e7375a5aba2e85a91e0044/cryptography-46.0.5-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:50bfb6925eff619c9c023b967d5b77a54e04256c4281b0e21336a130cd7fc263", size = 4277528, upload-time = "2026-02-10T19:17:13.853Z" },
+    { url = "https://files.pythonhosted.org/packages/22/29/c2e812ebc38c57b40e7c583895e73c8c5adb4d1e4a0cc4c5a4fdab2b1acc/cryptography-46.0.5-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:803812e111e75d1aa73690d2facc295eaefd4439be1023fefc4995eaea2af90d", size = 4947993, upload-time = "2026-02-10T19:17:15.618Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/e7/237155ae19a9023de7e30ec64e5d99a9431a567407ac21170a046d22a5a3/cryptography-46.0.5-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3ee190460e2fbe447175cda91b88b84ae8322a104fc27766ad09428754a618ed", size = 4456855, upload-time = "2026-02-10T19:17:17.221Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/87/fc628a7ad85b81206738abbd213b07702bcbdada1dd43f72236ef3cffbb5/cryptography-46.0.5-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:f145bba11b878005c496e93e257c1e88f154d278d2638e6450d17e0f31e558d2", size = 3984635, upload-time = "2026-02-10T19:17:18.792Z" },
+    { url = "https://files.pythonhosted.org/packages/84/29/65b55622bde135aedf4565dc509d99b560ee4095e56989e815f8fd2aa910/cryptography-46.0.5-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:e9251e3be159d1020c4030bd2e5f84d6a43fe54b6c19c12f51cde9542a2817b2", size = 4277038, upload-time = "2026-02-10T19:17:20.256Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/36/45e76c68d7311432741faf1fbf7fac8a196a0a735ca21f504c75d37e2558/cryptography-46.0.5-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:47fb8a66058b80e509c47118ef8a75d14c455e81ac369050f20ba0d23e77fee0", size = 4912181, upload-time = "2026-02-10T19:17:21.825Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/1a/c1ba8fead184d6e3d5afcf03d569acac5ad063f3ac9fb7258af158f7e378/cryptography-46.0.5-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:4c3341037c136030cb46e4b1e17b7418ea4cbd9dd207e4a6f3b2b24e0d4ac731", size = 4456482, upload-time = "2026-02-10T19:17:25.133Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/e5/3fb22e37f66827ced3b902cf895e6a6bc1d095b5b26be26bd13c441fdf19/cryptography-46.0.5-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:890bcb4abd5a2d3f852196437129eb3667d62630333aacc13dfd470fad3aaa82", size = 4405497, upload-time = "2026-02-10T19:17:26.66Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/df/9d58bb32b1121a8a2f27383fabae4d63080c7ca60b9b5c88be742be04ee7/cryptography-46.0.5-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:80a8d7bfdf38f87ca30a5391c0c9ce4ed2926918e017c29ddf643d0ed2778ea1", size = 4667819, upload-time = "2026-02-10T19:17:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/ed/325d2a490c5e94038cdb0117da9397ece1f11201f425c4e9c57fe5b9f08b/cryptography-46.0.5-cp311-abi3-win32.whl", hash = "sha256:60ee7e19e95104d4c03871d7d7dfb3d22ef8a9b9c6778c94e1c8fcc8365afd48", size = 3028230, upload-time = "2026-02-10T19:17:30.518Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/5a/ac0f49e48063ab4255d9e3b79f5def51697fce1a95ea1370f03dc9db76f6/cryptography-46.0.5-cp311-abi3-win_amd64.whl", hash = "sha256:38946c54b16c885c72c4f59846be9743d699eee2b69b6988e0a00a01f46a61a4", size = 3480909, upload-time = "2026-02-10T19:17:32.083Z" },
+    { url = "https://files.pythonhosted.org/packages/00/13/3d278bfa7a15a96b9dc22db5a12ad1e48a9eb3d40e1827ef66a5df75d0d0/cryptography-46.0.5-cp314-cp314t-macosx_10_9_universal2.whl", hash = "sha256:94a76daa32eb78d61339aff7952ea819b1734b46f73646a07decb40e5b3448e2", size = 7119287, upload-time = "2026-02-10T19:17:33.801Z" },
+    { url = "https://files.pythonhosted.org/packages/67/c8/581a6702e14f0898a0848105cbefd20c058099e2c2d22ef4e476dfec75d7/cryptography-46.0.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5be7bf2fb40769e05739dd0046e7b26f9d4670badc7b032d6ce4db64dddc0678", size = 4265728, upload-time = "2026-02-10T19:17:35.569Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/4a/ba1a65ce8fc65435e5a849558379896c957870dd64fecea97b1ad5f46a37/cryptography-46.0.5-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fe346b143ff9685e40192a4960938545c699054ba11d4f9029f94751e3f71d87", size = 4408287, upload-time = "2026-02-10T19:17:36.938Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/67/8ffdbf7b65ed1ac224d1c2df3943553766914a8ca718747ee3871da6107e/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:c69fd885df7d089548a42d5ec05be26050ebcd2283d89b3d30676eb32ff87dee", size = 4270291, upload-time = "2026-02-10T19:17:38.748Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/e5/f52377ee93bc2f2bba55a41a886fd208c15276ffbd2569f2ddc89d50e2c5/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:8293f3dea7fc929ef7240796ba231413afa7b68ce38fd21da2995549f5961981", size = 4927539, upload-time = "2026-02-10T19:17:40.241Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/02/cfe39181b02419bbbbcf3abdd16c1c5c8541f03ca8bda240debc467d5a12/cryptography-46.0.5-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:1abfdb89b41c3be0365328a410baa9df3ff8a9110fb75e7b52e66803ddabc9a9", size = 4442199, upload-time = "2026-02-10T19:17:41.789Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/96/2fcaeb4873e536cf71421a388a6c11b5bc846e986b2b069c79363dc1648e/cryptography-46.0.5-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:d66e421495fdb797610a08f43b05269e0a5ea7f5e652a89bfd5a7d3c1dee3648", size = 3960131, upload-time = "2026-02-10T19:17:43.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/d2/b27631f401ddd644e94c5cf33c9a4069f72011821cf3dc7309546b0642a0/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:4e817a8920bfbcff8940ecfd60f23d01836408242b30f1a708d93198393a80b4", size = 4270072, upload-time = "2026-02-10T19:17:45.481Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/a7/60d32b0370dae0b4ebe55ffa10e8599a2a59935b5ece1b9f06edb73abdeb/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:68f68d13f2e1cb95163fa3b4db4bf9a159a418f5f6e7242564fc75fcae667fd0", size = 4892170, upload-time = "2026-02-10T19:17:46.997Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/b9/cf73ddf8ef1164330eb0b199a589103c363afa0cf794218c24d524a58eab/cryptography-46.0.5-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:a3d1fae9863299076f05cb8a778c467578262fae09f9dc0ee9b12eb4268ce663", size = 4441741, upload-time = "2026-02-10T19:17:48.661Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/eb/eee00b28c84c726fe8fa0158c65afe312d9c3b78d9d01daf700f1f6e37ff/cryptography-46.0.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c4143987a42a2397f2fc3b4d7e3a7d313fbe684f67ff443999e803dd75a76826", size = 4396728, upload-time = "2026-02-10T19:17:50.058Z" },
+    { url = "https://files.pythonhosted.org/packages/65/f4/6bc1a9ed5aef7145045114b75b77c2a8261b4d38717bd8dea111a63c3442/cryptography-46.0.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:7d731d4b107030987fd61a7f8ab512b25b53cef8f233a97379ede116f30eb67d", size = 4652001, upload-time = "2026-02-10T19:17:51.54Z" },
+    { url = "https://files.pythonhosted.org/packages/86/ef/5d00ef966ddd71ac2e6951d278884a84a40ffbd88948ef0e294b214ae9e4/cryptography-46.0.5-cp314-cp314t-win32.whl", hash = "sha256:c3bcce8521d785d510b2aad26ae2c966092b7daa8f45dd8f44734a104dc0bc1a", size = 3003637, upload-time = "2026-02-10T19:17:52.997Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/57/f3f4160123da6d098db78350fdfd9705057aad21de7388eacb2401dceab9/cryptography-46.0.5-cp314-cp314t-win_amd64.whl", hash = "sha256:4d8ae8659ab18c65ced284993c2265910f6c9e650189d4e3f68445ef82a810e4", size = 3469487, upload-time = "2026-02-10T19:17:54.549Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/fa/a66aa722105ad6a458bebd64086ca2b72cdd361fed31763d20390f6f1389/cryptography-46.0.5-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:4108d4c09fbbf2789d0c926eb4152ae1760d5a2d97612b92d508d96c861e4d31", size = 7170514, upload-time = "2026-02-10T19:17:56.267Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/04/c85bdeab78c8bc77b701bf0d9bdcf514c044e18a46dcff330df5448631b0/cryptography-46.0.5-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7d1f30a86d2757199cb2d56e48cce14deddf1f9c95f1ef1b64ee91ea43fe2e18", size = 4275349, upload-time = "2026-02-10T19:17:58.419Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/32/9b87132a2f91ee7f5223b091dc963055503e9b442c98fc0b8a5ca765fab0/cryptography-46.0.5-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:039917b0dc418bb9f6edce8a906572d69e74bd330b0b3fea4f79dab7f8ddd235", size = 4420667, upload-time = "2026-02-10T19:18:00.619Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/a6/a7cb7010bec4b7c5692ca6f024150371b295ee1c108bdc1c400e4c44562b/cryptography-46.0.5-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:ba2a27ff02f48193fc4daeadf8ad2590516fa3d0adeeb34336b96f7fa64c1e3a", size = 4276980, upload-time = "2026-02-10T19:18:02.379Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/7c/c4f45e0eeff9b91e3f12dbd0e165fcf2a38847288fcfd889deea99fb7b6d/cryptography-46.0.5-cp38-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:61aa400dce22cb001a98014f647dc21cda08f7915ceb95df0c9eaf84b4b6af76", size = 4939143, upload-time = "2026-02-10T19:18:03.964Z" },
+    { url = "https://files.pythonhosted.org/packages/37/19/e1b8f964a834eddb44fa1b9a9976f4e414cbb7aa62809b6760c8803d22d1/cryptography-46.0.5-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3ce58ba46e1bc2aac4f7d9290223cead56743fa6ab94a5d53292ffaac6a91614", size = 4453674, upload-time = "2026-02-10T19:18:05.588Z" },
+    { url = "https://files.pythonhosted.org/packages/db/ed/db15d3956f65264ca204625597c410d420e26530c4e2943e05a0d2f24d51/cryptography-46.0.5-cp38-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:420d0e909050490d04359e7fdb5ed7e667ca5c3c402b809ae2563d7e66a92229", size = 3978801, upload-time = "2026-02-10T19:18:07.167Z" },
+    { url = "https://files.pythonhosted.org/packages/41/e2/df40a31d82df0a70a0daf69791f91dbb70e47644c58581d654879b382d11/cryptography-46.0.5-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:582f5fcd2afa31622f317f80426a027f30dc792e9c80ffee87b993200ea115f1", size = 4276755, upload-time = "2026-02-10T19:18:09.813Z" },
+    { url = "https://files.pythonhosted.org/packages/33/45/726809d1176959f4a896b86907b98ff4391a8aa29c0aaaf9450a8a10630e/cryptography-46.0.5-cp38-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:bfd56bb4b37ed4f330b82402f6f435845a5f5648edf1ad497da51a8452d5d62d", size = 4901539, upload-time = "2026-02-10T19:18:11.263Z" },
+    { url = "https://files.pythonhosted.org/packages/99/0f/a3076874e9c88ecb2ecc31382f6e7c21b428ede6f55aafa1aa272613e3cd/cryptography-46.0.5-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:a3d507bb6a513ca96ba84443226af944b0f7f47dcc9a399d110cd6146481d24c", size = 4452794, upload-time = "2026-02-10T19:18:12.914Z" },
+    { url = "https://files.pythonhosted.org/packages/02/ef/ffeb542d3683d24194a38f66ca17c0a4b8bf10631feef44a7ef64e631b1a/cryptography-46.0.5-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9f16fbdf4da055efb21c22d81b89f155f02ba420558db21288b3d0035bafd5f4", size = 4404160, upload-time = "2026-02-10T19:18:14.375Z" },
+    { url = "https://files.pythonhosted.org/packages/96/93/682d2b43c1d5f1406ed048f377c0fc9fc8f7b0447a478d5c65ab3d3a66eb/cryptography-46.0.5-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ced80795227d70549a411a4ab66e8ce307899fad2220ce5ab2f296e687eacde9", size = 4667123, upload-time = "2026-02-10T19:18:15.886Z" },
+    { url = "https://files.pythonhosted.org/packages/45/2d/9c5f2926cb5300a8eefc3f4f0b3f3df39db7f7ce40c8365444c49363cbda/cryptography-46.0.5-cp38-abi3-win32.whl", hash = "sha256:02f547fce831f5096c9a567fd41bc12ca8f11df260959ecc7c3202555cc47a72", size = 3010220, upload-time = "2026-02-10T19:18:17.361Z" },
+    { url = "https://files.pythonhosted.org/packages/48/ef/0c2f4a8e31018a986949d34a01115dd057bf536905dca38897bacd21fac3/cryptography-46.0.5-cp38-abi3-win_amd64.whl", hash = "sha256:556e106ee01aa13484ce9b0239bca667be5004efb0aabbed28d353df86445595", size = 3467050, upload-time = "2026-02-10T19:18:18.899Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/dd/2d9fdb07cebdf3d51179730afb7d5e576153c6744c3ff8fded23030c204e/cryptography-46.0.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:3b4995dc971c9fb83c25aa44cf45f02ba86f71ee600d81091c2f0cbae116b06c", size = 3476964, upload-time = "2026-02-10T19:18:20.687Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/6f/6cc6cc9955caa6eaf83660b0da2b077c7fe8ff9950a3c5e45d605038d439/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:bc84e875994c3b445871ea7181d424588171efec3e185dced958dad9e001950a", size = 4218321, upload-time = "2026-02-10T19:18:22.349Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/5d/c4da701939eeee699566a6c1367427ab91a8b7088cc2328c09dbee940415/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:2ae6971afd6246710480e3f15824ed3029a60fc16991db250034efd0b9fb4356", size = 4381786, upload-time = "2026-02-10T19:18:24.529Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/97/a538654732974a94ff96c1db621fa464f455c02d4bb7d2652f4edc21d600/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:d861ee9e76ace6cf36a6a89b959ec08e7bc2493ee39d07ffe5acb23ef46d27da", size = 4217990, upload-time = "2026-02-10T19:18:25.957Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/11/7e500d2dd3ba891197b9efd2da5454b74336d64a7cc419aa7327ab74e5f6/cryptography-46.0.5-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:2b7a67c9cd56372f3249b39699f2ad479f6991e62ea15800973b956f4b73e257", size = 4381252, upload-time = "2026-02-10T19:18:27.496Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/58/6b3d24e6b9bc474a2dcdee65dfd1f008867015408a271562e4b690561a4d/cryptography-46.0.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:8456928655f856c6e1533ff59d5be76578a7157224dbd9ce6872f25055ab9ab7", size = 3407605, upload-time = "2026-02-10T19:18:29.233Z" },
+]
+
+[[package]]
+name = "devbox-connect"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "paramiko" },
+    { name = "pyyaml" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "paramiko", specifier = ">=3.4.0" },
+    { name = "pyyaml", specifier = ">=6.0" },
+]
+
+[[package]]
+name = "invoke"
+version = "2.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/de/bd/b461d3424a24c80490313fd77feeb666ca4f6a28c7e72713e3d9095719b4/invoke-2.2.1.tar.gz", hash = "sha256:515bf49b4a48932b79b024590348da22f39c4942dff991ad1fb8b8baea1be707", size = 304762, upload-time = "2025-10-11T00:36:35.172Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/32/4b/b99e37f88336009971405cbb7630610322ed6fbfa31e1d7ab3fbf3049a2d/invoke-2.2.1-py3-none-any.whl", hash = "sha256:2413bc441b376e5cd3f55bb5d364f973ad8bdd7bf87e53c79de3c11bf3feecc8", size = 160287, upload-time = "2025-10-11T00:36:33.703Z" },
+]
+
+[[package]]
+name = "paramiko"
+version = "4.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "bcrypt" },
+    { name = "cryptography" },
+    { name = "invoke" },
+    { name = "pynacl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1f/e7/81fdcbc7f190cdb058cffc9431587eb289833bdd633e2002455ca9bb13d4/paramiko-4.0.0.tar.gz", hash = "sha256:6a25f07b380cc9c9a88d2b920ad37167ac4667f8d9886ccebd8f90f654b5d69f", size = 1630743, upload-time = "2025-08-04T01:02:03.711Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a9/90/a744336f5af32c433bd09af7854599682a383b37cfd78f7de263de6ad6cb/paramiko-4.0.0-py3-none-any.whl", hash = "sha256:0e20e00ac666503bf0b4eda3b6d833465a2b7aff2e2b3d79a8bba5ef144ee3b9", size = 223932, upload-time = "2025-08-04T01:02:02.029Z" },
+]
+
+[[package]]
+name = "pycparser"
+version = "3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },
+]
+
+[[package]]
+name = "pynacl"
+version = "1.6.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d9/9a/4019b524b03a13438637b11538c82781a5eda427394380381af8f04f467a/pynacl-1.6.2.tar.gz", hash = "sha256:018494d6d696ae03c7e656e5e74cdfd8ea1326962cc401bcf018f1ed8436811c", size = 3511692, upload-time = "2026-01-01T17:48:10.851Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4b/79/0e3c34dc3c4671f67d251c07aa8eb100916f250ee470df230b0ab89551b4/pynacl-1.6.2-cp314-cp314t-macosx_10_10_universal2.whl", hash = "sha256:622d7b07cc5c02c666795792931b50c91f3ce3c2649762efb1ef0d5684c81594", size = 390064, upload-time = "2026-01-01T17:31:57.264Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/1c/23a26e931736e13b16483795c8a6b2f641bf6a3d5238c22b070a5112722c/pynacl-1.6.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d071c6a9a4c94d79eb665db4ce5cedc537faf74f2355e4d502591d850d3913c0", size = 809370, upload-time = "2026-01-01T17:31:59.198Z" },
+    { url = "https://files.pythonhosted.org/packages/87/74/8d4b718f8a22aea9e8dcc8b95deb76d4aae380e2f5b570cc70b5fd0a852d/pynacl-1.6.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fe9847ca47d287af41e82be1dd5e23023d3c31a951da134121ab02e42ac218c9", size = 1408304, upload-time = "2026-01-01T17:32:01.162Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/73/be4fdd3a6a87fe8a4553380c2b47fbd1f7f58292eb820902f5c8ac7de7b0/pynacl-1.6.2-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:04316d1fc625d860b6c162fff704eb8426b1a8bcd3abacea11142cbd99a6b574", size = 844871, upload-time = "2026-01-01T17:32:02.824Z" },
+    { url = "https://files.pythonhosted.org/packages/55/ad/6efc57ab75ee4422e96b5f2697d51bbcf6cdcc091e66310df91fbdc144a8/pynacl-1.6.2-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:44081faff368d6c5553ccf55322ef2819abb40e25afaec7e740f159f74813634", size = 1446356, upload-time = "2026-01-01T17:32:04.452Z" },
+    { url = "https://files.pythonhosted.org/packages/78/b7/928ee9c4779caa0a915844311ab9fb5f99585621c5d6e4574538a17dca07/pynacl-1.6.2-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:a9f9932d8d2811ce1a8ffa79dcbdf3970e7355b5c8eb0c1a881a57e7f7d96e88", size = 826814, upload-time = "2026-01-01T17:32:06.078Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/a9/1bdba746a2be20f8809fee75c10e3159d75864ef69c6b0dd168fc60e485d/pynacl-1.6.2-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:bc4a36b28dd72fb4845e5d8f9760610588a96d5a51f01d84d8c6ff9849968c14", size = 1411742, upload-time = "2026-01-01T17:32:07.651Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/2f/5e7ea8d85f9f3ea5b6b87db1d8388daa3587eed181bdeb0306816fdbbe79/pynacl-1.6.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3bffb6d0f6becacb6526f8f42adfb5efb26337056ee0831fb9a7044d1a964444", size = 801714, upload-time = "2026-01-01T17:32:09.558Z" },
+    { url = "https://files.pythonhosted.org/packages/06/ea/43fe2f7eab5f200e40fb10d305bf6f87ea31b3bbc83443eac37cd34a9e1e/pynacl-1.6.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:2fef529ef3ee487ad8113d287a593fa26f48ee3620d92ecc6f1d09ea38e0709b", size = 1372257, upload-time = "2026-01-01T17:32:11.026Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/54/c9ea116412788629b1347e415f72195c25eb2f3809b2d3e7b25f5c79f13a/pynacl-1.6.2-cp314-cp314t-win32.whl", hash = "sha256:a84bf1c20339d06dc0c85d9aea9637a24f718f375d861b2668b2f9f96fa51145", size = 231319, upload-time = "2026-01-01T17:32:12.46Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/04/64e9d76646abac2dccf904fccba352a86e7d172647557f35b9fe2a5ee4a1/pynacl-1.6.2-cp314-cp314t-win_amd64.whl", hash = "sha256:320ef68a41c87547c91a8b58903c9caa641ab01e8512ce291085b5fe2fcb7590", size = 244044, upload-time = "2026-01-01T17:32:13.781Z" },
+    { url = "https://files.pythonhosted.org/packages/33/33/7873dc161c6a06f43cda13dec67b6fe152cb2f982581151956fa5e5cdb47/pynacl-1.6.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d29bfe37e20e015a7d8b23cfc8bd6aa7909c92a1b8f41ee416bbb3e79ef182b2", size = 188740, upload-time = "2026-01-01T17:32:15.083Z" },
+    { url = "https://files.pythonhosted.org/packages/be/7b/4845bbf88e94586ec47a432da4e9107e3fc3ce37eb412b1398630a37f7dd/pynacl-1.6.2-cp38-abi3-macosx_10_10_universal2.whl", hash = "sha256:c949ea47e4206af7c8f604b8278093b674f7c79ed0d4719cc836902bf4517465", size = 388458, upload-time = "2026-01-01T17:32:16.829Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/b4/e927e0653ba63b02a4ca5b4d852a8d1d678afbf69b3dbf9c4d0785ac905c/pynacl-1.6.2-cp38-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8845c0631c0be43abdd865511c41eab235e0be69c81dc66a50911594198679b0", size = 800020, upload-time = "2026-01-01T17:32:18.34Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/81/d60984052df5c97b1d24365bc1e30024379b42c4edcd79d2436b1b9806f2/pynacl-1.6.2-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:22de65bb9010a725b0dac248f353bb072969c94fa8d6b1f34b87d7953cf7bbe4", size = 1399174, upload-time = "2026-01-01T17:32:20.239Z" },
+    { url = "https://files.pythonhosted.org/packages/68/f7/322f2f9915c4ef27d140101dd0ed26b479f7e6f5f183590fd32dfc48c4d3/pynacl-1.6.2-cp38-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:46065496ab748469cdd999246d17e301b2c24ae2fdf739132e580a0e94c94a87", size = 835085, upload-time = "2026-01-01T17:32:22.24Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/d0/f301f83ac8dbe53442c5a43f6a39016f94f754d7a9815a875b65e218a307/pynacl-1.6.2-cp38-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a66d6fb6ae7661c58995f9c6435bda2b1e68b54b598a6a10247bfcdadac996c", size = 1437614, upload-time = "2026-01-01T17:32:23.766Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/58/fc6e649762b029315325ace1a8c6be66125e42f67416d3dbd47b69563d61/pynacl-1.6.2-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:26bfcd00dcf2cf160f122186af731ae30ab120c18e8375684ec2670dccd28130", size = 818251, upload-time = "2026-01-01T17:32:25.69Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/a8/b917096b1accc9acd878819a49d3d84875731a41eb665f6ebc826b1af99e/pynacl-1.6.2-cp38-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:c8a231e36ec2cab018c4ad4358c386e36eede0319a0c41fed24f840b1dac59f6", size = 1402859, upload-time = "2026-01-01T17:32:27.215Z" },
+    { url = "https://files.pythonhosted.org/packages/85/42/fe60b5f4473e12c72f977548e4028156f4d340b884c635ec6b063fe7e9a5/pynacl-1.6.2-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:68be3a09455743ff9505491220b64440ced8973fe930f270c8e07ccfa25b1f9e", size = 791926, upload-time = "2026-01-01T17:32:29.314Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f9/e40e318c604259301cc091a2a63f237d9e7b424c4851cafaea4ea7c4834e/pynacl-1.6.2-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:8b097553b380236d51ed11356c953bf8ce36a29a3e596e934ecabe76c985a577", size = 1363101, upload-time = "2026-01-01T17:32:31.263Z" },
+    { url = "https://files.pythonhosted.org/packages/48/47/e761c254f410c023a469284a9bc210933e18588ca87706ae93002c05114c/pynacl-1.6.2-cp38-abi3-win32.whl", hash = "sha256:5811c72b473b2f38f7e2a3dc4f8642e3a3e9b5e7317266e4ced1fba85cae41aa", size = 227421, upload-time = "2026-01-01T17:32:33.076Z" },
+    { url = "https://files.pythonhosted.org/packages/41/ad/334600e8cacc7d86587fe5f565480fde569dfb487389c8e1be56ac21d8ac/pynacl-1.6.2-cp38-abi3-win_amd64.whl", hash = "sha256:62985f233210dee6548c223301b6c25440852e13d59a8b81490203c3227c5ba0", size = 239754, upload-time = "2026-01-01T17:32:34.557Z" },
+    { url = "https://files.pythonhosted.org/packages/29/7d/5945b5af29534641820d3bd7b00962abbbdfee84ec7e19f0d5b3175f9a31/pynacl-1.6.2-cp38-abi3-win_arm64.whl", hash = "sha256:834a43af110f743a754448463e8fd61259cd4ab5bbedcf70f9dabad1d28a394c", size = 184801, upload-time = "2026-01-01T17:32:36.309Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" },
+    { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" },
+    { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
+    { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
+    { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
+    { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
+    { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]

docs/python-tools.md

@@ -0,0 +1,419 @@
+# Python Tools in Castle
+
+How to build CLI tools following Unix philosophy. Based on the patterns in the
+[toolkit](https://github.com/payneio/toolkit) project.
+
+## Principles
+
+- Each tool does one thing well
+- Read from stdin or file argument, write to stdout
+- Compose via pipes: `pdf2md doc.pdf | gpt "summarize this"`
+- Status messages go to stderr (don't interfere with piping)
+- Exit 0 on success, 1 on error
+
+## Stack
+
+| Layer | Choice |
+|-------|--------|
+| **CLI** | argparse |
+| **Package manager** | uv (never pip) |
+| **Build** | hatchling |
+| **Testing** | unittest + mocking |
+| **Linting** | ruff |
+| **Type checking** | pyright |
+
+## Project layout
+
+Tools live inside a single package with categories:
+
+```
+toolkit/
+├── tools/
+│   ├── document/
+│   │   ├── pdf2md.py          # Implementation
+│   │   ├── pdf2md.md          # Docs + YAML frontmatter (single source of truth)
+│   │   └── test_pdf2md.py     # Tests alongside tool
+│   ├── search/
+│   │   ├── search.py
+│   │   ├── search.md
+│   │   └── test_search.py
+│   ├── system/
+│   │   ├── schedule.py
+│   │   └── schedule.md
+│   └── toolkit/
+│       ├── toolkit.py         # Meta-tool for discovery/scaffolding
+│       └── toolkit.md
+├── pyproject.toml
+├── Makefile
+└── README.md
+```
+
+Each tool is a `.py` + `.md` pair. The `.md` file has YAML frontmatter for
+metadata — no separate config files needed.
+
+## YAML frontmatter (.md file)
+
+```yaml
+---
+command: pdf2md
+script: document/pdf2md.py
+description: Convert PDF files to Markdown
+version: 1.0.0
+category: document
+system_dependencies:
+  - pandoc
+  - poppler-utils
+---
+
+# pdf2md
+
+Converts PDF files to Markdown format...
+```
+
+The toolkit management command discovers tools by scanning for these `.md` files.
+
+## pyproject.toml
+
+```toml
+[project]
+name = "toolkit"
+version = "0.1.0"
+requires-python = ">=3.11"
+dependencies = [
+    "requests>=2.28.0",
+    "pyyaml>=6.0.0",
+]
+
+[project.scripts]
+pdf2md = "tools.document.pdf2md:main"
+docx2md = "tools.document.docx2md:main"
+search = "tools.search.search:main"
+toolkit = "tools.toolkit.toolkit:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["tools"]
+```
+
+Entry points follow `command = "tools.<category>.<tool>:main"`. After
+`uv tool install --editable .`, all commands are in PATH.
+
+## Tool implementation patterns
+
+### Simple tool: stdin/stdout
+
+The most common pattern. Read from a file argument or stdin, process, write
+to stdout.
+
+```python
+#!/usr/bin/env python3
+"""
+my-tool: Brief description
+
+Detailed usage docs here.
+
+Usage:
+    my-tool [options] [FILE]
+    cat input.txt | my-tool
+
+Examples:
+    my-tool input.txt
+    my-tool input.txt -o output.txt
+    cat input.txt | my-tool > output.txt
+"""
+
+import argparse
+import sys
+
+
+def process(data: str) -> str:
+    """Core logic — pure function, easy to test."""
+    return data.upper()
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Brief description",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("input", nargs="?", help="Input file (default: stdin)")
+    parser.add_argument("-o", "--output", help="Output file (default: stdout)")
+    parser.add_argument("--version", action="version", version="my-tool 1.0.0")
+    args = parser.parse_args()
+
+    # Read
+    if args.input:
+        with open(args.input) as f:
+            data = f.read()
+    else:
+        data = sys.stdin.read()
+
+    # Process
+    result = process(data)
+
+    # Write
+    if args.output:
+        with open(args.output, "w") as f:
+            f.write(result)
+        print(f"Wrote to {args.output}", file=sys.stderr)
+    else:
+        print(result, end="")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+```
+
+### Tool with subcommands
+
+For complex tools with multiple operations:
+
+```python
+def cmd_init(args: argparse.Namespace) -> int:
+    """Initialize a collection."""
+    directory = args.directory or "."
+    # ...
+    print(f"Initialized in {directory}")
+    return 0
+
+
+def cmd_query(args: argparse.Namespace) -> int:
+    """Search a collection."""
+    # ...
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Manage collections")
+    parser.add_argument("--version", action="version", version="1.0.0")
+    subparsers = parser.add_subparsers(dest="command")
+
+    init_p = subparsers.add_parser("init", help="Initialize")
+    init_p.add_argument("directory", nargs="?")
+    init_p.add_argument("--name", help="Collection name")
+    init_p.add_argument("--force", action="store_true")
+
+    query_p = subparsers.add_parser("query", help="Search")
+    query_p.add_argument("query", help="Search query")
+    query_p.add_argument("--limit", type=int, default=20)
+
+    args = parser.parse_args()
+
+    if args.command == "init":
+        return cmd_init(args)
+    elif args.command == "query":
+        return cmd_query(args)
+    else:
+        parser.print_help()
+        return 1
+```
+
+### Tool with external processes
+
+When wrapping system commands:
+
+```python
+import subprocess
+import sys
+
+
+def convert(input_file: str, output_file: str) -> int:
+    try:
+        result = subprocess.run(
+            ["pandoc", input_file, "-o", output_file],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        return 0
+    except subprocess.CalledProcessError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        if e.stderr:
+            print(e.stderr, file=sys.stderr)
+        return 1
+    except FileNotFoundError:
+        print("Error: pandoc not found. Install with: apt install pandoc",
+              file=sys.stderr)
+        return 1
+```
+
+Always use `check=True` and `capture_output=True` with subprocess. Handle
+`FileNotFoundError` for missing system dependencies.
+
+### Tool with optional dependencies
+
+```python
+tantivy_available = False
+try:
+    import tantivy
+    tantivy_available = True
+except ImportError:
+    tantivy = None
+
+
+def check_tantivy() -> None:
+    if not tantivy_available:
+        print("Error: tantivy not found. Install with: uv add tantivy",
+              file=sys.stderr)
+        sys.exit(1)
+```
+
+## Error handling
+
+```python
+def main() -> int:
+    try:
+        result = do_work()
+        print(result)
+        return 0
+    except SpecificError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+    except FileNotFoundError as e:
+        print(f"Error: file not found: {e}", file=sys.stderr)
+        return 1
+```
+
+Rules:
+- Normal output goes to **stdout** (enables piping)
+- Error messages go to **stderr**
+- Status/progress messages go to **stderr**
+- Return **0** for success, **1** for error
+- Entry point: `sys.exit(main())`
+
+## Piping
+
+Tools compose naturally via Unix pipes:
+
+```bash
+# Convert and summarize
+pdf2md paper.pdf | gpt "summarize this"
+
+# Process a batch
+for f in *.pdf; do pdf2md "$f" > "${f%.pdf}.md"; done
+
+# Chain extractors
+cat doc.txt | text-extractor | jq .content
+```
+
+When a tool writes to both a file and stdout, status messages must go to
+stderr so they don't contaminate the pipe:
+
+```python
+with open(output_file, "w") as f:
+    f.write(result)
+print(result)                                    # stdout (for piping)
+print(f"Wrote to {output_file}", file=sys.stderr)  # stderr (status)
+```
+
+## Testing
+
+Tests live alongside the tool implementation, using unittest with mocking:
+
+```python
+# tools/gpt/test_gpt.py
+import unittest
+from unittest.mock import patch, MagicMock
+from io import StringIO
+
+from tools.gpt import gpt
+
+
+class TestGPT(unittest.TestCase):
+    @patch("tools.gpt.gpt.get_api_key")
+    @patch("openai.OpenAI")
+    def test_generate(self, mock_openai, mock_key):
+        mock_key.return_value = "fake-key"
+        mock_client = MagicMock()
+        mock_openai.return_value = mock_client
+        mock_client.chat.completions.create.return_value = MagicMock(
+            choices=[MagicMock(message=MagicMock(content="response"))]
+        )
+
+        result = gpt.generate_text("prompt", "gpt-4", 0.7, 500)
+        self.assertEqual(result, "response")
+
+    @patch("tools.gpt.gpt.generate_text")
+    def test_cli(self, mock_gen):
+        mock_gen.return_value = "output"
+        with patch("sys.argv", ["gpt", "prompt"]):
+            with patch("sys.stdout", new=StringIO()) as out:
+                gpt.main()
+                self.assertEqual(out.getvalue().strip(), "output")
+```
+
+Pattern: mock external dependencies (APIs, file I/O, subprocesses), test the
+CLI by patching `sys.argv`.
+
+## Build and install
+
+```makefile
+# Makefile
+all: build install
+
+build:
+	uv sync
+
+install:
+	uv tool install --editable .
+
+check:
+	uv run ruff format .
+	uv run ruff check . --fix
+	uv run pyright
+
+test:
+	uv run pytest -v
+
+clean:
+	find . -type d -name "__pycache__" -exec rm -rf {} + 2>/dev/null || true
+```
+
+```bash
+make all        # Sync deps + install to PATH
+make check      # Format, lint, type-check
+make test       # Run tests
+```
+
+## Creating a new tool
+
+Use the toolkit management command:
+
+```bash
+toolkit create my-tool --description "Does something" --category document
+```
+
+This creates the `.py` template, `.md` with frontmatter, and updates
+`pyproject.toml` with the entry point.
+
+Or manually:
+1. Create `tools/<category>/my_tool.py` with the argparse pattern above
+2. Create `tools/<category>/my_tool.md` with YAML frontmatter
+3. Add entry to `pyproject.toml` under `[project.scripts]`:
+   ```toml
+   my-tool = "tools.category.my_tool:main"
+   ```
+4. Run `make install` to register in PATH
+
+## Registering in castle
+
+```yaml
+# castle.yaml
+components:
+  toolkit:
+    description: Personal utility scripts
+    run:
+      runner: command
+      argv: ["toolkit"]
+      cwd: toolkit
+    install:
+      path: { alias: toolkit }
+```
+
+Tools with `install.path` get the `tool` role. They don't need `expose`,
+`proxy`, or `manage` blocks.

docs/web-apis.md

@@ -0,0 +1,424 @@
+# Web APIs in Castle
+
+How to build Python web APIs as castle service components. Based on the
+patterns used in [wild-cloud/api](https://github.com/civilsociety-dev/wild-cloud)
+and existing castle services (central-context, notification-bridge, event-bus).
+
+## Stack
+
+| Layer | Choice |
+|-------|--------|
+| **Framework** | FastAPI |
+| **Server** | uvicorn |
+| **Config** | pydantic-settings (env vars) |
+| **Validation** | Pydantic models |
+| **HTTP client** | httpx (async) |
+| **Testing** | pytest + FastAPI TestClient |
+| **Python** | 3.13+ for services |
+
+## Project layout
+
+```
+my-service/
+├── src/my_service/
+│   ├── __init__.py        # Package version
+│   ├── main.py            # FastAPI app, lifespan, entry point
+│   ├── config.py          # pydantic-settings
+│   ├── models.py          # Request/response Pydantic models
+│   ├── routes.py          # APIRouter with endpoints
+│   └── storage.py         # Domain logic (no FastAPI imports)
+├── tests/
+│   ├── conftest.py        # Fixtures (client, temp dirs)
+│   ├── test_api.py        # Endpoint integration tests
+│   └── test_storage.py    # Domain unit tests
+├── pyproject.toml
+└── CLAUDE.md
+```
+
+Separation of concerns: routes handle HTTP, storage/core handles logic,
+models define schemas. Domain code never imports FastAPI.
+
+## pyproject.toml
+
+```toml
+[project]
+name = "my-service"
+version = "0.1.0"
+description = "Does something useful"
+requires-python = ">=3.13"
+dependencies = [
+    "fastapi>=0.115.0",
+    "uvicorn>=0.34.0",
+    "pydantic-settings>=2.0.0",
+]
+
+[project.scripts]
+my-service = "my_service.main:run"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/my_service"]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0.0",
+    "httpx>=0.28.0",
+]
+```
+
+## Configuration
+
+Use pydantic-settings with an env prefix matching the service name:
+
+```python
+# config.py
+from pathlib import Path
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    data_dir: Path = Path("./data")
+    host: str = "0.0.0.0"
+    port: int = 9001
+
+    model_config = {
+        "env_prefix": "MY_SERVICE_",
+        "env_file": ".env",
+    }
+
+    def ensure_data_dir(self) -> None:
+        self.data_dir.mkdir(parents=True, exist_ok=True)
+
+
+settings = Settings()
+```
+
+Castle passes config via env vars in castle.yaml:
+
+```yaml
+components:
+  my-service:
+    run:
+      runner: python_uv_tool
+      tool: my-service
+      cwd: my-service
+      env:
+        MY_SERVICE_DATA_DIR: /data/castle/my-service
+    expose:
+      http:
+        internal: { port: 9001 }
+        health_path: /health
+    proxy:
+      caddy: { path_prefix: /my-service }
+    manage:
+      systemd: {}
+```
+
+## Application entry point
+
+```python
+# main.py
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+
+import uvicorn
+from fastapi import FastAPI
+
+from my_service.config import settings
+from my_service.routes import router
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    settings.ensure_data_dir()
+    yield
+
+
+app = FastAPI(
+    title="my-service",
+    description="Does something useful",
+    version="0.1.0",
+    lifespan=lifespan,
+)
+
+app.include_router(router)
+
+
+@app.get("/health")
+def health() -> dict[str, str]:
+    return {"status": "ok"}
+
+
+def run() -> None:
+    uvicorn.run(
+        "my_service.main:app",
+        host=settings.host,
+        port=settings.port,
+        reload=False,
+    )
+```
+
+For services with async resources (HTTP clients, connections), initialize
+them in the lifespan and clean up after yield:
+
+```python
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    settings.ensure_data_dir()
+    async with httpx.AsyncClient(timeout=10.0) as client:
+        app.state.http_client = client
+        yield
+```
+
+## Routes
+
+Use APIRouter with a prefix and tags. Map domain exceptions to HTTP status codes.
+
+```python
+# routes.py
+from fastapi import APIRouter, HTTPException, status
+
+from my_service.models import ItemCreate, ItemResponse
+from my_service.storage import (
+    ItemExistsError,
+    ItemNotFoundError,
+    create_item,
+    get_item,
+    list_items,
+)
+
+router = APIRouter(prefix="/items", tags=["items"])
+
+
+@router.post("", response_model=ItemResponse, status_code=status.HTTP_201_CREATED)
+def create(request: ItemCreate) -> ItemResponse:
+    try:
+        return create_item(request)
+    except ItemExistsError as e:
+        raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=str(e))
+
+
+@router.get("/{item_id}", response_model=ItemResponse)
+def get(item_id: str) -> ItemResponse:
+    try:
+        return get_item(item_id)
+    except ItemNotFoundError:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Not found")
+
+
+@router.get("", response_model=list[ItemResponse])
+def list_all() -> list[ItemResponse]:
+    return list_items()
+```
+
+## Request/response models
+
+Separate create models (what the client sends) from response models (what
+comes back). Use inheritance to avoid repetition.
+
+```python
+# models.py
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+
+class ItemCreate(BaseModel):
+    name: str = Field(..., description="Item name")
+    content: str = Field(..., description="Item content")
+    description: str | None = Field(default=None)
+
+
+class ItemResponse(BaseModel):
+    name: str
+    description: str | None
+    created_at: datetime
+    size_bytes: int
+    checksum: str
+
+
+class ItemWithBody(ItemResponse):
+    content: str
+```
+
+## Error handling
+
+Define domain exceptions in the storage/core layer. Map them to HTTP status
+codes in the route layer.
+
+```python
+# storage.py
+class StorageError(Exception):
+    pass
+
+class ItemExistsError(StorageError):
+    pass
+
+class ItemNotFoundError(StorageError):
+    pass
+
+class InvalidNameError(StorageError):
+    pass
+```
+
+Mapping convention:
+
+| Exception | HTTP Status |
+|-----------|-------------|
+| `NotFoundError` | 404 |
+| `ExistsError` / conflict | 409 |
+| `InvalidError` / bad input | 400 |
+| Unexpected | 500 (FastAPI default) |
+
+## Storage
+
+Castle services use filesystem storage with JSON metadata sidecars:
+
+```
+/data/castle/my-service/
+└── bucket/
+    ├── item-name
+    └── item-name.meta.json
+```
+
+```python
+# storage.py
+import hashlib
+import json
+from datetime import datetime
+from pathlib import Path
+
+from my_service.config import settings
+from my_service.models import ItemCreate, ItemResponse
+
+
+def create_item(request: ItemCreate) -> ItemResponse:
+    checksum = hashlib.sha256(request.content.encode()).hexdigest()
+    path = settings.data_dir / request.name
+    meta_path = path.with_suffix(path.suffix + ".meta.json")
+
+    if path.exists():
+        raise ItemExistsError(f"'{request.name}' already exists")
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    now = datetime.now()
+
+    metadata = ItemResponse(
+        name=request.name,
+        description=request.description,
+        created_at=now,
+        size_bytes=len(request.content.encode()),
+        checksum=checksum,
+    )
+
+    path.write_text(request.content, encoding="utf-8")
+    meta_path.write_text(
+        json.dumps(metadata.model_dump(), default=str, indent=2)
+    )
+    return metadata
+```
+
+## Testing
+
+### Fixtures
+
+```python
+# tests/conftest.py
+from collections.abc import Generator
+from pathlib import Path
+
+import pytest
+from fastapi.testclient import TestClient
+
+from my_service import config
+from my_service.main import app
+
+
+@pytest.fixture
+def temp_data_dir(tmp_path: Path) -> Generator[Path, None, None]:
+    data_dir = tmp_path / "data"
+    data_dir.mkdir()
+    original = config.settings.data_dir
+    config.settings.data_dir = data_dir
+    yield data_dir
+    config.settings.data_dir = original
+
+
+@pytest.fixture
+def client(temp_data_dir: Path) -> Generator[TestClient, None, None]:
+    with TestClient(app) as client:
+        yield client
+```
+
+### Endpoint tests
+
+```python
+# tests/test_api.py
+from fastapi import status
+from fastapi.testclient import TestClient
+
+
+class TestHealth:
+    def test_health(self, client: TestClient) -> None:
+        response = client.get("/health")
+        assert response.status_code == status.HTTP_200_OK
+        assert response.json() == {"status": "ok"}
+
+
+class TestCreateItem:
+    def test_create(self, client: TestClient) -> None:
+        response = client.post(
+            "/items",
+            json={"name": "test", "content": "hello"},
+        )
+        assert response.status_code == status.HTTP_201_CREATED
+        data = response.json()
+        assert data["name"] == "test"
+        assert "checksum" in data
+
+    def test_duplicate_returns_409(self, client: TestClient) -> None:
+        payload = {"name": "dup", "content": "hello"}
+        client.post("/items", json=payload)
+        response = client.post("/items", json=payload)
+        assert response.status_code == status.HTTP_409_CONFLICT
+```
+
+### Domain unit tests
+
+```python
+# tests/test_storage.py
+from pathlib import Path
+
+from my_service.models import ItemCreate
+from my_service.storage import create_item
+
+
+class TestCreateItem:
+    def test_creates_files(self, temp_data_dir: Path) -> None:
+        request = ItemCreate(name="test", content="hello")
+        metadata = create_item(request)
+
+        assert metadata.name == "test"
+        assert (temp_data_dir / "test").exists()
+        assert (temp_data_dir / "test.meta.json").exists()
+```
+
+## Commands
+
+```bash
+uv sync                     # Install deps
+uv run my-service           # Run service
+uv run pytest tests/ -v     # Run tests
+uv run ruff check .         # Lint
+uv run ruff format .        # Format
+```
+
+## Scaffolding
+
+`castle create` generates all of this automatically:
+
+```bash
+castle create my-service --type service --description "Does something useful"
+```

docs/web-frontends.md

@@ -0,0 +1,334 @@
+# Web Frontends in Castle
+
+How to build, serve, and manage web frontends as castle components. Based on
+the stack used in [wild-cloud/web](https://github.com/civilsociety-dev/wild-cloud).
+
+## Stack
+
+| Layer | Choice |
+|-------|--------|
+| **Build** | Vite 6 |
+| **Language** | TypeScript 5.8 (strict) |
+| **Framework** | React 19 |
+| **Routing** | React Router 7 |
+| **Styling** | Tailwind CSS 4 (`@tailwindcss/vite` plugin) |
+| **Components** | shadcn/ui (new-york style) + Radix UI primitives |
+| **Icons** | Lucide React |
+| **Server state** | TanStack React Query 5 |
+| **Forms** | React Hook Form + Zod validation |
+| **Testing** | Vitest + Testing Library |
+| **Package manager** | pnpm |
+
+## Scaffolding a new frontend
+
+```bash
+# Create the project
+mkdir my-frontend && cd my-frontend
+pnpm create vite . --template react-ts
+
+# Core dependencies
+pnpm add react-router react-router-dom \
+         @tanstack/react-query \
+         tailwindcss @tailwindcss/vite \
+         class-variance-authority clsx tailwind-merge \
+         lucide-react sonner zod \
+         react-hook-form @hookform/resolvers
+
+# Dev dependencies
+pnpm add -D vitest jsdom @testing-library/react @testing-library/jest-dom \
+            @testing-library/user-event
+
+# shadcn/ui
+pnpm dlx shadcn@latest init
+```
+
+## Vite config
+
+```ts
+// vite.config.ts
+import path from "path"
+import tailwindcss from "@tailwindcss/vite"
+import { defineConfig } from "vite"
+import react from "@vitejs/plugin-react"
+
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+    },
+  },
+})
+```
+
+## Project layout
+
+```
+my-frontend/
+├── src/
+│   ├── main.tsx                 # ReactDOM.createRoot mount
+│   ├── App.tsx                  # Root: QueryClientProvider + RouterProvider
+│   ├── index.css                # Tailwind imports + CSS custom properties
+│   ├── router/
+│   │   ├── index.tsx            # createBrowserRouter
+│   │   └── routes.tsx           # Route tree
+│   ├── components/
+│   │   └── ui/                  # shadcn/ui components
+│   ├── services/api/
+│   │   ├── client.ts            # Typed fetch wrapper
+│   │   └── hooks/               # React Query hooks per resource
+│   ├── hooks/                   # App-level hooks
+│   ├── contexts/                # React context providers
+│   ├── lib/
+│   │   ├── utils.ts             # cn() helper
+│   │   └── queryClient.ts       # Query client config
+│   ├── types/                   # Shared TypeScript types
+│   └── schemas/                 # Zod schemas
+├── public/                      # Static assets (favicon, manifest.json)
+├── index.html                   # SPA entry point
+├── package.json
+├── vite.config.ts
+├── tsconfig.json
+├── vitest.config.ts
+├── components.json              # shadcn/ui config
+└── .env                         # VITE_API_BASE_URL etc.
+```
+
+## Build commands
+
+```bash
+pnpm run dev          # Vite dev server (:5173), HMR
+pnpm run build        # tsc -b && vite build → dist/
+pnpm run preview      # Serve production build locally
+pnpm run type-check   # tsc --noEmit
+pnpm run lint         # ESLint
+pnpm run test         # Vitest
+pnpm run check        # lint + type-check + test
+```
+
+The `build` output is a static SPA in `dist/` — just HTML, JS, and CSS files.
+
+## Registering as a castle component
+
+A frontend component has a `build` spec (produces static output) and optionally
+a `proxy` spec (Caddy serves the built files). No `run` block needed if Caddy
+handles serving directly from the build output.
+
+```yaml
+# castle.yaml
+components:
+  my-frontend:
+    description: Web dashboard
+    build:
+      commands:
+        - ["pnpm", "build"]
+      outputs:
+        - dist/
+    proxy:
+      caddy:
+        path_prefix: /app
+```
+
+For development with Vite's dev server, add a `run` block:
+
+```yaml
+components:
+  my-frontend:
+    description: Web dashboard
+    run:
+      runner: node
+      script: dev
+      package_manager: pnpm
+      cwd: my-frontend
+    build:
+      commands:
+        - ["pnpm", "build"]
+      outputs:
+        - dist/
+    expose:
+      http:
+        internal: { port: 5173 }
+    proxy:
+      caddy:
+        path_prefix: /app
+```
+
+This gives the component both the `frontend` role (from `build`) and the
+`service` role (from `expose.http`) during development.
+
+## Serving with Caddy
+
+For production, serve the static `dist/` output directly from Caddy rather than
+running a Node process. The gateway Caddyfile can serve the files:
+
+```caddyfile
+handle_path /app/* {
+    root * /data/repos/castle/my-frontend/dist
+    try_files {path} /index.html
+    file_server
+}
+```
+
+The `try_files {path} /index.html` directive is essential for SPA routing —
+it falls back to `index.html` for any path that doesn't match a static file,
+letting React Router handle client-side routes.
+
+## API integration
+
+Frontends talk to castle services via environment variables injected at build
+time. Vite exposes variables prefixed with `VITE_`:
+
+```bash
+# .env
+VITE_API_BASE_URL=http://localhost:9001
+```
+
+```ts
+// src/services/api/client.ts
+const BASE_URL = import.meta.env.VITE_API_BASE_URL ?? "http://localhost:9001"
+
+class ApiClient {
+  private baseUrl: string
+
+  constructor(baseUrl = BASE_URL) {
+    this.baseUrl = baseUrl
+  }
+
+  async get<T>(path: string): Promise<T> {
+    const resp = await fetch(`${this.baseUrl}${path}`)
+    if (!resp.ok) throw new ApiError(resp.status, await resp.text())
+    return resp.json()
+  }
+
+  // post<T>, put<T>, delete<T>, etc.
+}
+
+export const apiClient = new ApiClient()
+```
+
+When served behind the castle gateway, the API base URL can use the gateway's
+proxy paths (e.g., `/central-context/`) instead of direct ports, avoiding CORS.
+
+## React Query setup
+
+```ts
+// src/lib/queryClient.ts
+import { QueryClient } from "@tanstack/react-query"
+
+export const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 5 * 60 * 1000,    // 5 minutes
+      gcTime: 10 * 60 * 1000,      // 10 minutes
+      retry: 1,
+    },
+  },
+})
+```
+
+```ts
+// src/services/api/hooks/useThings.ts
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query"
+import { apiClient } from "../client"
+
+export function useThings() {
+  return useQuery({
+    queryKey: ["things"],
+    queryFn: () => apiClient.get<Thing[]>("/things"),
+  })
+}
+
+export function useCreateThing() {
+  const qc = useQueryClient()
+  return useMutation({
+    mutationFn: (data: CreateThing) => apiClient.post<Thing>("/things", data),
+    onSuccess: () => qc.invalidateQueries({ queryKey: ["things"] }),
+  })
+}
+```
+
+## shadcn/ui setup
+
+Initialize with the `components.json` config:
+
+```json
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "new-york",
+  "rsc": false,
+  "tsx": true,
+  "tailwind": {
+    "config": "",
+    "css": "src/index.css",
+    "baseColor": "neutral",
+    "cssVariables": true
+  },
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/utils",
+    "ui": "@/components/ui",
+    "lib": "@/lib",
+    "hooks": "@/hooks"
+  },
+  "iconLibrary": "lucide"
+}
+```
+
+Add components as needed:
+
+```bash
+pnpm dlx shadcn@latest add button card dialog sidebar
+```
+
+Components are copied into `src/components/ui/` as source files you own and can
+modify. They use Radix UI primitives underneath, with Tailwind for styling.
+
+## Dark mode
+
+Use CSS custom properties with a `.dark` class on `<html>`:
+
+```css
+/* src/index.css */
+@import "tailwindcss";
+
+:root {
+  --background: oklch(1 0 0);
+  --foreground: oklch(0.145 0 0);
+  --primary: oklch(0.205 0 0);
+  /* ... */
+}
+
+.dark {
+  --background: oklch(0.145 0 0);
+  --foreground: oklch(0.985 0 0);
+  --primary: oklch(0.922 0 0);
+  /* ... */
+}
+```
+
+Toggle via a React context that persists the preference to `localStorage`.
+
+## Testing
+
+```ts
+// vitest.config.ts
+import { defineConfig } from "vitest/config"
+import path from "path"
+
+export default defineConfig({
+  test: {
+    environment: "jsdom",
+    setupFiles: ["src/test/setup.ts"],
+    exclude: ["dist/**"],
+  },
+  resolve: {
+    alias: { "@": path.resolve(__dirname, "./src") },
+  },
+})
+```
+
+```bash
+pnpm run test              # Single run
+pnpm run test:ui           # Interactive UI
+pnpm run test:coverage     # With coverage report
+```

event-bus/CLAUDE.md

@@ -0,0 +1,42 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working
+with code in this repository.
+
+## Overview
+
+event-bus is a castle-component — a lightweight inter-service event bus for HTTP fan-out.
+Services publish typed events to topics, other services subscribe with webhook callback URLs.
+No persistence, no guaranteed delivery — just simple HTTP POST fan-out.
+
+## Commands
+
+```bash
+uv sync                     # Install dependencies
+uv run event-bus            # Run service (port 9010)
+uv run pytest tests/ -v     # Run tests
+uv run ruff check .         # Lint
+uv run ruff format .        # Format
+```
+
+## Architecture
+
+- `src/event_bus/config.py` — Settings via pydantic-settings, env prefix `EVENT_BUS_`
+- `src/event_bus/main.py` — FastAPI app, endpoints: publish, subscribe, unsubscribe, topics, health
+- `src/event_bus/bus.py` — Core EventBus class with in-memory subscription table and async HTTP delivery
+- `tests/` — pytest with TestClient fixtures
+
+## API
+
+- `POST /publish` — `{"topic": "...", "payload": {...}}` — fan-out to subscribers
+- `POST /subscribe` — `{"topic": "...", "callback_url": "...", "subscriber": "..."}` — register webhook
+- `POST /unsubscribe` — `{"topic": "...", "callback_url": "..."}` — remove subscription
+- `GET /topics` — list all topics and their subscribers
+- `GET /health` — health check
+
+## Configuration
+
+Environment variables with `EVENT_BUS_` prefix:
+- `EVENT_BUS_DATA_DIR` — Data directory (default: ./data)
+- `EVENT_BUS_HOST` — Bind host (default: 0.0.0.0)
+- `EVENT_BUS_PORT` — Port (default: 9010)

event-bus/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "event-bus"
+version = "0.1.0"
+description = "Inter-service event bus"
+requires-python = ">=3.13"
+dependencies = [
+    "fastapi>=0.115.0",
+    "uvicorn>=0.34.0",
+    "pydantic-settings>=2.0.0",
+    "httpx>=0.27.0",
+]
+
+[project.scripts]
+event-bus = "event_bus.main:run"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/event_bus"]
+
+[dependency-groups]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.23.0",
+    "httpx>=0.27.0",
+]
+
+[tool.ruff.lint.isort]
+known-first-party = ["event_bus"]

event-bus/src/event_bus/__init__.py

@@ -0,0 +1,3 @@
+"""Inter-service event bus."""
+
+__version__ = "0.1.0"

event-bus/src/event_bus/bus.py

@@ -0,0 +1,121 @@
+"""Event bus core — in-memory subscription table and HTTP fan-out delivery."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Subscription:
+    """A subscription to a topic."""
+
+    topic: str
+    callback_url: str
+    subscriber: str = ""  # optional label for debugging
+
+
+@dataclass
+class EventBus:
+    """In-memory event bus with HTTP fan-out delivery."""
+
+    subscriptions: dict[str, list[Subscription]] = field(default_factory=dict)
+    _client: httpx.AsyncClient | None = field(default=None, repr=False)
+
+    async def start(self) -> None:
+        """Initialize the HTTP client."""
+        self._client = httpx.AsyncClient(timeout=10.0)
+
+    async def stop(self) -> None:
+        """Close the HTTP client."""
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    def subscribe(self, topic: str, callback_url: str, subscriber: str = "") -> None:
+        """Register a subscription to a topic."""
+        if topic not in self.subscriptions:
+            self.subscriptions[topic] = []
+
+        # Don't duplicate
+        for sub in self.subscriptions[topic]:
+            if sub.callback_url == callback_url:
+                return
+
+        self.subscriptions[topic].append(
+            Subscription(topic=topic, callback_url=callback_url, subscriber=subscriber)
+        )
+        logger.info("Subscribed %s to topic '%s' -> %s", subscriber, topic, callback_url)
+
+    def unsubscribe(self, topic: str, callback_url: str) -> bool:
+        """Remove a subscription. Returns True if found and removed."""
+        if topic not in self.subscriptions:
+            return False
+
+        before = len(self.subscriptions[topic])
+        self.subscriptions[topic] = [
+            s for s in self.subscriptions[topic] if s.callback_url != callback_url
+        ]
+        removed = len(self.subscriptions[topic]) < before
+
+        if not self.subscriptions[topic]:
+            del self.subscriptions[topic]
+
+        return removed
+
+    async def publish(self, topic: str, payload: dict) -> int:
+        """Publish an event to all subscribers. Returns number of subscribers notified."""
+        subscribers = self.subscriptions.get(topic, [])
+        if not subscribers:
+            return 0
+
+        event = {
+            "topic": topic,
+            "payload": payload,
+            "published_at": datetime.now(timezone.utc).isoformat(),
+        }
+
+        # Fan out to all subscribers concurrently, fire-and-forget style
+        tasks = [self._deliver(sub, event) for sub in subscribers]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        delivered = sum(1 for r in results if r is True)
+        return delivered
+
+    async def _deliver(self, sub: Subscription, event: dict) -> bool:
+        """Deliver an event to a single subscriber."""
+        if not self._client:
+            logger.error("HTTP client not initialized")
+            return False
+
+        try:
+            response = await self._client.post(sub.callback_url, json=event)
+            if response.status_code < 300:
+                return True
+            logger.warning(
+                "Delivery to %s returned %d", sub.callback_url, response.status_code
+            )
+            return False
+        except Exception:
+            logger.warning("Delivery to %s failed", sub.callback_url, exc_info=True)
+            return False
+
+    def list_topics(self) -> dict[str, list[dict]]:
+        """List all topics and their subscribers."""
+        return {
+            topic: [
+                {"callback_url": s.callback_url, "subscriber": s.subscriber}
+                for s in subs
+            ]
+            for topic, subs in self.subscriptions.items()
+        }
+
+
+# Singleton instance
+bus = EventBus()

event-bus/src/event_bus/config.py

@@ -0,0 +1,25 @@
+"""Configuration for event-bus."""
+
+from pathlib import Path
+
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    """Service settings loaded from environment variables."""
+
+    data_dir: Path = Path("./data")
+    host: str = "0.0.0.0"
+    port: int = 9010
+
+    model_config = {
+        "env_prefix": "EVENT_BUS_",
+        "env_file": ".env",
+    }
+
+    def ensure_data_dir(self) -> None:
+        """Create data directory if it doesn't exist."""
+        self.data_dir.mkdir(parents=True, exist_ok=True)
+
+
+settings = Settings()

event-bus/src/event_bus/main.py

@@ -0,0 +1,115 @@
+"""Main application for event-bus.
+
+A lightweight castle-component for inter-service communication.
+Services publish typed events, other services subscribe with webhook callbacks.
+The bus delivers events via HTTP POST fan-out. No persistence, no guaranteed delivery.
+"""
+
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+
+import uvicorn
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+from event_bus.bus import bus
+from event_bus.config import settings
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+    """Application lifespan handler."""
+    settings.ensure_data_dir()
+    await bus.start()
+    yield
+    await bus.stop()
+
+
+app = FastAPI(
+    title="event-bus",
+    description="Inter-service event bus for castle",
+    version="0.1.0",
+    lifespan=lifespan,
+)
+
+
+class PublishRequest(BaseModel):
+    """Request body for publishing an event."""
+
+    topic: str
+    payload: dict
+
+
+class SubscribeRequest(BaseModel):
+    """Request body for subscribing to a topic."""
+
+    topic: str
+    callback_url: str
+    subscriber: str = ""
+
+
+class UnsubscribeRequest(BaseModel):
+    """Request body for unsubscribing from a topic."""
+
+    topic: str
+    callback_url: str
+
+
+@app.get("/health")
+async def health() -> dict[str, str]:
+    """Health check endpoint."""
+    return {"status": "ok"}
+
+
+@app.post("/publish")
+async def publish(request: PublishRequest) -> dict:
+    """Publish an event to a topic. Returns number of subscribers notified."""
+    delivered = await bus.publish(request.topic, request.payload)
+    return {
+        "topic": request.topic,
+        "subscribers_notified": delivered,
+    }
+
+
+@app.post("/subscribe")
+async def subscribe(request: SubscribeRequest) -> dict:
+    """Subscribe to a topic with a webhook callback URL."""
+    bus.subscribe(request.topic, request.callback_url, request.subscriber)
+    return {
+        "topic": request.topic,
+        "callback_url": request.callback_url,
+        "status": "subscribed",
+    }
+
+
+@app.post("/unsubscribe")
+async def unsubscribe(request: UnsubscribeRequest) -> dict:
+    """Unsubscribe from a topic."""
+    removed = bus.unsubscribe(request.topic, request.callback_url)
+    return {
+        "topic": request.topic,
+        "callback_url": request.callback_url,
+        "status": "unsubscribed" if removed else "not_found",
+    }
+
+
+@app.get("/topics")
+async def list_topics() -> dict:
+    """List all topics and their subscribers."""
+    return {"topics": bus.list_topics()}
+
+
+def run() -> None:
+    """Run the application with uvicorn."""
+    uvicorn.run(
+        "event_bus.main:app",
+        host=settings.host,
+        port=settings.port,
+        reload=False,
+    )
+
+
+if __name__ == "__main__":
+    run()

event-bus/tests/conftest.py

@@ -0,0 +1,28 @@
+"""Test fixtures for event-bus."""
+
+from collections.abc import Generator
+from pathlib import Path
+
+import pytest
+from fastapi.testclient import TestClient
+
+from event_bus.config import settings
+from event_bus.main import app
+
+
+@pytest.fixture
+def temp_data_dir(tmp_path: Path) -> Generator[Path, None, None]:
+    """Create a temporary data directory for tests."""
+    data_dir = tmp_path / "data"
+    data_dir.mkdir()
+    original = settings.data_dir
+    settings.data_dir = data_dir
+    yield data_dir
+    settings.data_dir = original
+
+
+@pytest.fixture
+def client(temp_data_dir: Path) -> Generator[TestClient, None, None]:
+    """Create a test client with isolated data directory."""
+    with TestClient(app) as client:
+        yield client

event-bus/tests/test_bus.py

@@ -0,0 +1,139 @@
+"""Tests for event bus publish/subscribe functionality."""
+
+from fastapi.testclient import TestClient
+
+from event_bus.bus import EventBus
+
+
+class TestSubscribe:
+    """Subscription management tests."""
+
+    def test_subscribe(self, client: TestClient) -> None:
+        """Subscribe to a topic."""
+        response = client.post(
+            "/subscribe",
+            json={
+                "topic": "test.event",
+                "callback_url": "http://localhost:9999/hook",
+                "subscriber": "test-service",
+            },
+        )
+        assert response.status_code == 200
+        data = response.json()
+        assert data["status"] == "subscribed"
+        assert data["topic"] == "test.event"
+
+    def test_subscribe_deduplicates(self, client: TestClient) -> None:
+        """Same callback URL for same topic is not duplicated."""
+        for _ in range(3):
+            client.post(
+                "/subscribe",
+                json={
+                    "topic": "test.event",
+                    "callback_url": "http://localhost:9999/hook",
+                },
+            )
+
+        response = client.get("/topics")
+        topics = response.json()["topics"]
+        assert len(topics.get("test.event", [])) == 1
+
+    def test_unsubscribe(self, client: TestClient) -> None:
+        """Unsubscribe removes the subscription."""
+        client.post(
+            "/subscribe",
+            json={
+                "topic": "test.event",
+                "callback_url": "http://localhost:9999/hook",
+            },
+        )
+
+        response = client.post(
+            "/unsubscribe",
+            json={
+                "topic": "test.event",
+                "callback_url": "http://localhost:9999/hook",
+            },
+        )
+        assert response.json()["status"] == "unsubscribed"
+
+        response = client.get("/topics")
+        assert "test.event" not in response.json()["topics"]
+
+    def test_unsubscribe_not_found(self, client: TestClient) -> None:
+        """Unsubscribing from non-existent subscription returns not_found."""
+        response = client.post(
+            "/unsubscribe",
+            json={
+                "topic": "nonexistent",
+                "callback_url": "http://localhost:9999/hook",
+            },
+        )
+        assert response.json()["status"] == "not_found"
+
+
+class TestPublish:
+    """Event publishing tests."""
+
+    def test_publish_no_subscribers(self, client: TestClient) -> None:
+        """Publishing to a topic with no subscribers returns 0."""
+        response = client.post(
+            "/publish",
+            json={"topic": "empty.topic", "payload": {"msg": "hello"}},
+        )
+        assert response.status_code == 200
+        assert response.json()["subscribers_notified"] == 0
+
+
+class TestTopics:
+    """Topic listing tests."""
+
+    def test_list_topics_empty(self, client: TestClient) -> None:
+        """Empty bus returns empty topics."""
+        response = client.get("/topics")
+        assert response.status_code == 200
+        assert response.json() == {"topics": {}}
+
+    def test_list_topics_with_subscriptions(self, client: TestClient) -> None:
+        """Topics list shows all subscriptions."""
+        client.post(
+            "/subscribe",
+            json={
+                "topic": "a.event",
+                "callback_url": "http://localhost:9999/a",
+                "subscriber": "svc-a",
+            },
+        )
+        client.post(
+            "/subscribe",
+            json={
+                "topic": "b.event",
+                "callback_url": "http://localhost:9999/b",
+                "subscriber": "svc-b",
+            },
+        )
+
+        response = client.get("/topics")
+        topics = response.json()["topics"]
+        assert "a.event" in topics
+        assert "b.event" in topics
+        assert topics["a.event"][0]["subscriber"] == "svc-a"
+
+
+class TestEventBusUnit:
+    """Unit tests for the EventBus class."""
+
+    def test_subscribe_and_list(self) -> None:
+        """Subscribe adds to subscription table."""
+        eb = EventBus()
+        eb.subscribe("test", "http://localhost/hook", "test-svc")
+        topics = eb.list_topics()
+        assert "test" in topics
+        assert topics["test"][0]["callback_url"] == "http://localhost/hook"
+
+    def test_unsubscribe_cleans_empty_topic(self) -> None:
+        """Unsubscribing the last subscriber removes the topic."""
+        eb = EventBus()
+        eb.subscribe("test", "http://localhost/hook")
+        eb.unsubscribe("test", "http://localhost/hook")
+        assert "test" not in eb.list_topics()

event-bus/tests/test_health.py

@@ -0,0 +1,13 @@
+"""Tests for event-bus health endpoint."""
+
+from fastapi.testclient import TestClient
+
+
+class TestHealth:
+    """Health endpoint tests."""
+
+    def test_health(self, client: TestClient) -> None:
+        """Health endpoint returns ok."""
+        response = client.get("/health")
+        assert response.status_code == 200
+        assert response.json() == {"status": "ok"}

event-bus/uv.lock

@@ -0,0 +1,359 @@
+version = 1
+revision = 3
+requires-python = ">=3.13"
+
+[[package]]
+name = "annotated-doc"
+version = "0.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" },
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.12.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/96/f0/5eb65b2bb0d09ac6776f2eb54adee6abe8228ea05b20a5ad0e4945de8aac/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703", size = 228685, upload-time = "2026-01-06T11:45:21.246Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/38/0e/27be9fdef66e72d64c0cdc3cc2823101b80585f8119b5c112c2e8f5f7dab/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c", size = 113592, upload-time = "2026-01-06T11:45:19.497Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268, upload-time = "2026-01-04T02:42:41.825Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900, upload-time = "2026-01-04T02:42:40.15Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "event-bus"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "fastapi" },
+    { name = "httpx" },
+    { name = "pydantic-settings" },
+    { name = "uvicorn" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "httpx" },
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "fastapi", specifier = ">=0.115.0" },
+    { name = "httpx", specifier = ">=0.27.0" },
+    { name = "pydantic-settings", specifier = ">=2.0.0" },
+    { name = "uvicorn", specifier = ">=0.34.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "httpx", specifier = ">=0.27.0" },
+    { name = "pytest", specifier = ">=7.0.0" },
+    { name = "pytest-asyncio", specifier = ">=0.23.0" },
+]
+
+[[package]]
+name = "fastapi"
+version = "0.129.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "pydantic" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/48/47/75f6bea02e797abff1bca968d5997793898032d9923c1935ae2efdece642/fastapi-0.129.0.tar.gz", hash = "sha256:61315cebd2e65df5f97ec298c888f9de30430dd0612d59d6480beafbc10655af", size = 375450, upload-time = "2026-02-12T13:54:52.541Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9e/dd/d0ee25348ac58245ee9f90b6f3cbb666bf01f69be7e0911f9851bddbda16/fastapi-0.129.0-py3-none-any.whl", hash = "sha256:b4946880e48f462692b31c083be0432275cbfb6e2274566b1be91479cc1a84ec", size = 102950, upload-time = "2026-02-12T13:54:54.528Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.12.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/69/44/36f1a6e523abc58ae5f928898e4aca2e0ea509b5aa6f6f392a5d882be928/pydantic-2.12.5.tar.gz", hash = "sha256:4d351024c75c0f085a9febbb665ce8c0c6ec5d30e903bdb6394b7ede26aebb49", size = 821591, upload-time = "2025-11-26T15:11:46.471Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl", hash = "sha256:e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d", size = 463580, upload-time = "2025-11-26T15:11:44.605Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.41.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/71/70/23b021c950c2addd24ec408e9ab05d59b035b39d97cdc1130e1bce647bb6/pydantic_core-2.41.5.tar.gz", hash = "sha256:08daa51ea16ad373ffd5e7606252cc32f07bc72b28284b6bc9c6df804816476e", size = 460952, upload-time = "2025-11-04T13:43:49.098Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/87/06/8806241ff1f70d9939f9af039c6c35f2360cf16e93c2ca76f184e76b1564/pydantic_core-2.41.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:941103c9be18ac8daf7b7adca8228f8ed6bb7a1849020f643b3a14d15b1924d9", size = 2120403, upload-time = "2025-11-04T13:40:25.248Z" },
+    { url = "https://files.pythonhosted.org/packages/94/02/abfa0e0bda67faa65fef1c84971c7e45928e108fe24333c81f3bfe35d5f5/pydantic_core-2.41.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:112e305c3314f40c93998e567879e887a3160bb8689ef3d2c04b6cc62c33ac34", size = 1896206, upload-time = "2025-11-04T13:40:27.099Z" },
+    { url = "https://files.pythonhosted.org/packages/15/df/a4c740c0943e93e6500f9eb23f4ca7ec9bf71b19e608ae5b579678c8d02f/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbaad15cb0c90aa221d43c00e77bb33c93e8d36e0bf74760cd00e732d10a6a0", size = 1919307, upload-time = "2025-11-04T13:40:29.806Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/e3/6324802931ae1d123528988e0e86587c2072ac2e5394b4bc2bc34b61ff6e/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:03ca43e12fab6023fc79d28ca6b39b05f794ad08ec2feccc59a339b02f2b3d33", size = 2063258, upload-time = "2025-11-04T13:40:33.544Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d4/2230d7151d4957dd79c3044ea26346c148c98fbf0ee6ebd41056f2d62ab5/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc799088c08fa04e43144b164feb0c13f9a0bc40503f8df3e9fde58a3c0c101e", size = 2214917, upload-time = "2025-11-04T13:40:35.479Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9f/eaac5df17a3672fef0081b6c1bb0b82b33ee89aa5cec0d7b05f52fd4a1fa/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:97aeba56665b4c3235a0e52b2c2f5ae9cd071b8a8310ad27bddb3f7fb30e9aa2", size = 2332186, upload-time = "2025-11-04T13:40:37.436Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/4e/35a80cae583a37cf15604b44240e45c05e04e86f9cfd766623149297e971/pydantic_core-2.41.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:406bf18d345822d6c21366031003612b9c77b3e29ffdb0f612367352aab7d586", size = 2073164, upload-time = "2025-11-04T13:40:40.289Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/e3/f6e262673c6140dd3305d144d032f7bd5f7497d3871c1428521f19f9efa2/pydantic_core-2.41.5-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b93590ae81f7010dbe380cdeab6f515902ebcbefe0b9327cc4804d74e93ae69d", size = 2179146, upload-time = "2025-11-04T13:40:42.809Z" },
+    { url = "https://files.pythonhosted.org/packages/75/c7/20bd7fc05f0c6ea2056a4565c6f36f8968c0924f19b7d97bbfea55780e73/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:01a3d0ab748ee531f4ea6c3e48ad9dac84ddba4b0d82291f87248f2f9de8d740", size = 2137788, upload-time = "2025-11-04T13:40:44.752Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/8d/34318ef985c45196e004bc46c6eab2eda437e744c124ef0dbe1ff2c9d06b/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:6561e94ba9dacc9c61bce40e2d6bdc3bfaa0259d3ff36ace3b1e6901936d2e3e", size = 2340133, upload-time = "2025-11-04T13:40:46.66Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/59/013626bf8c78a5a5d9350d12e7697d3d4de951a75565496abd40ccd46bee/pydantic_core-2.41.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:915c3d10f81bec3a74fbd4faebe8391013ba61e5a1a8d48c4455b923bdda7858", size = 2324852, upload-time = "2025-11-04T13:40:48.575Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/d9/c248c103856f807ef70c18a4f986693a46a8ffe1602e5d361485da502d20/pydantic_core-2.41.5-cp313-cp313-win32.whl", hash = "sha256:650ae77860b45cfa6e2cdafc42618ceafab3a2d9a3811fcfbd3bbf8ac3c40d36", size = 1994679, upload-time = "2025-11-04T13:40:50.619Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8b/341991b158ddab181cff136acd2552c9f35bd30380422a639c0671e99a91/pydantic_core-2.41.5-cp313-cp313-win_amd64.whl", hash = "sha256:79ec52ec461e99e13791ec6508c722742ad745571f234ea6255bed38c6480f11", size = 2019766, upload-time = "2025-11-04T13:40:52.631Z" },
+    { url = "https://files.pythonhosted.org/packages/73/7d/f2f9db34af103bea3e09735bb40b021788a5e834c81eedb541991badf8f5/pydantic_core-2.41.5-cp313-cp313-win_arm64.whl", hash = "sha256:3f84d5c1b4ab906093bdc1ff10484838aca54ef08de4afa9de0f5f14d69639cd", size = 1981005, upload-time = "2025-11-04T13:40:54.734Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/28/46b7c5c9635ae96ea0fbb779e271a38129df2550f763937659ee6c5dbc65/pydantic_core-2.41.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:3f37a19d7ebcdd20b96485056ba9e8b304e27d9904d233d7b1015db320e51f0a", size = 2119622, upload-time = "2025-11-04T13:40:56.68Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1a/145646e5687e8d9a1e8d09acb278c8535ebe9e972e1f162ed338a622f193/pydantic_core-2.41.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1d1d9764366c73f996edd17abb6d9d7649a7eb690006ab6adbda117717099b14", size = 1891725, upload-time = "2025-11-04T13:40:58.807Z" },
+    { url = "https://files.pythonhosted.org/packages/23/04/e89c29e267b8060b40dca97bfc64a19b2a3cf99018167ea1677d96368273/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25e1c2af0fce638d5f1988b686f3b3ea8cd7de5f244ca147c777769e798a9cd1", size = 1915040, upload-time = "2025-11-04T13:41:00.853Z" },
+    { url = "https://files.pythonhosted.org/packages/84/a3/15a82ac7bd97992a82257f777b3583d3e84bdb06ba6858f745daa2ec8a85/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:506d766a8727beef16b7adaeb8ee6217c64fc813646b424d0804d67c16eddb66", size = 2063691, upload-time = "2025-11-04T13:41:03.504Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/0046701313c6ef08c0c1cf0e028c67c770a4e1275ca73131563c5f2a310a/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4819fa52133c9aa3c387b3328f25c1facc356491e6135b459f1de698ff64d869", size = 2213897, upload-time = "2025-11-04T13:41:05.804Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/cd/6bac76ecd1b27e75a95ca3a9a559c643b3afcd2dd62086d4b7a32a18b169/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2b761d210c9ea91feda40d25b4efe82a1707da2ef62901466a42492c028553a2", size = 2333302, upload-time = "2025-11-04T13:41:07.809Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/d2/ef2074dc020dd6e109611a8be4449b98cd25e1b9b8a303c2f0fca2f2bcf7/pydantic_core-2.41.5-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22f0fb8c1c583a3b6f24df2470833b40207e907b90c928cc8d3594b76f874375", size = 2064877, upload-time = "2025-11-04T13:41:09.827Z" },
+    { url = "https://files.pythonhosted.org/packages/18/66/e9db17a9a763d72f03de903883c057b2592c09509ccfe468187f2a2eef29/pydantic_core-2.41.5-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c870e99878c634505236d81e5443092fba820f0373997ff75f90f68cd553", size = 2180680, upload-time = "2025-11-04T13:41:12.379Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/9e/3ce66cebb929f3ced22be85d4c2399b8e85b622db77dad36b73c5387f8f8/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:0177272f88ab8312479336e1d777f6b124537d47f2123f89cb37e0accea97f90", size = 2138960, upload-time = "2025-11-04T13:41:14.627Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/62/205a998f4327d2079326b01abee48e502ea739d174f0a89295c481a2272e/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:63510af5e38f8955b8ee5687740d6ebf7c2a0886d15a6d65c32814613681bc07", size = 2339102, upload-time = "2025-11-04T13:41:16.868Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/0d/f05e79471e889d74d3d88f5bd20d0ed189ad94c2423d81ff8d0000aab4ff/pydantic_core-2.41.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:e56ba91f47764cc14f1daacd723e3e82d1a89d783f0f5afe9c364b8bb491ccdb", size = 2326039, upload-time = "2025-11-04T13:41:18.934Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/e1/e08a6208bb100da7e0c4b288eed624a703f4d129bde2da475721a80cab32/pydantic_core-2.41.5-cp314-cp314-win32.whl", hash = "sha256:aec5cf2fd867b4ff45b9959f8b20ea3993fc93e63c7363fe6851424c8a7e7c23", size = 1995126, upload-time = "2025-11-04T13:41:21.418Z" },
+    { url = "https://files.pythonhosted.org/packages/48/5d/56ba7b24e9557f99c9237e29f5c09913c81eeb2f3217e40e922353668092/pydantic_core-2.41.5-cp314-cp314-win_amd64.whl", hash = "sha256:8e7c86f27c585ef37c35e56a96363ab8de4e549a95512445b85c96d3e2f7c1bf", size = 2015489, upload-time = "2025-11-04T13:41:24.076Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/bb/f7a190991ec9e3e0ba22e4993d8755bbc4a32925c0b5b42775c03e8148f9/pydantic_core-2.41.5-cp314-cp314-win_arm64.whl", hash = "sha256:e672ba74fbc2dc8eea59fb6d4aed6845e6905fc2a8afe93175d94a83ba2a01a0", size = 1977288, upload-time = "2025-11-04T13:41:26.33Z" },
+    { url = "https://files.pythonhosted.org/packages/92/ed/77542d0c51538e32e15afe7899d79efce4b81eee631d99850edc2f5e9349/pydantic_core-2.41.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8566def80554c3faa0e65ac30ab0932b9e3a5cd7f8323764303d468e5c37595a", size = 2120255, upload-time = "2025-11-04T13:41:28.569Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/3d/6913dde84d5be21e284439676168b28d8bbba5600d838b9dca99de0fad71/pydantic_core-2.41.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b80aa5095cd3109962a298ce14110ae16b8c1aece8b72f9dafe81cf597ad80b3", size = 1863760, upload-time = "2025-11-04T13:41:31.055Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/f0/e5e6b99d4191da102f2b0eb9687aaa7f5bea5d9964071a84effc3e40f997/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3006c3dd9ba34b0c094c544c6006cc79e87d8612999f1a5d43b769b89181f23c", size = 1878092, upload-time = "2025-11-04T13:41:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/71/48/36fb760642d568925953bcc8116455513d6e34c4beaa37544118c36aba6d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:72f6c8b11857a856bcfa48c86f5368439f74453563f951e473514579d44aa612", size = 2053385, upload-time = "2025-11-04T13:41:35.508Z" },
+    { url = "https://files.pythonhosted.org/packages/20/25/92dc684dd8eb75a234bc1c764b4210cf2646479d54b47bf46061657292a8/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cb1b2f9742240e4bb26b652a5aeb840aa4b417c7748b6f8387927bc6e45e40d", size = 2218832, upload-time = "2025-11-04T13:41:37.732Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/09/f53e0b05023d3e30357d82eb35835d0f6340ca344720a4599cd663dca599/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bd3d54f38609ff308209bd43acea66061494157703364ae40c951f83ba99a1a9", size = 2327585, upload-time = "2025-11-04T13:41:40Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/4e/2ae1aa85d6af35a39b236b1b1641de73f5a6ac4d5a7509f77b814885760c/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2ff4321e56e879ee8d2a879501c8e469414d948f4aba74a2d4593184eb326660", size = 2041078, upload-time = "2025-11-04T13:41:42.323Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/13/2e215f17f0ef326fc72afe94776edb77525142c693767fc347ed6288728d/pydantic_core-2.41.5-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0d2568a8c11bf8225044aa94409e21da0cb09dcdafe9ecd10250b2baad531a9", size = 2173914, upload-time = "2025-11-04T13:41:45.221Z" },
+    { url = "https://files.pythonhosted.org/packages/02/7a/f999a6dcbcd0e5660bc348a3991c8915ce6599f4f2c6ac22f01d7a10816c/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:a39455728aabd58ceabb03c90e12f71fd30fa69615760a075b9fec596456ccc3", size = 2129560, upload-time = "2025-11-04T13:41:47.474Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/b1/6c990ac65e3b4c079a4fb9f5b05f5b013afa0f4ed6780a3dd236d2cbdc64/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:239edca560d05757817c13dc17c50766136d21f7cd0fac50295499ae24f90fdf", size = 2329244, upload-time = "2025-11-04T13:41:49.992Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/02/3c562f3a51afd4d88fff8dffb1771b30cfdfd79befd9883ee094f5b6c0d8/pydantic_core-2.41.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:2a5e06546e19f24c6a96a129142a75cee553cc018ffee48a460059b1185f4470", size = 2331955, upload-time = "2025-11-04T13:41:54.079Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/96/5fb7d8c3c17bc8c62fdb031c47d77a1af698f1d7a406b0f79aaa1338f9ad/pydantic_core-2.41.5-cp314-cp314t-win32.whl", hash = "sha256:b4ececa40ac28afa90871c2cc2b9ffd2ff0bf749380fbdf57d165fd23da353aa", size = 1988906, upload-time = "2025-11-04T13:41:56.606Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/182129d83032702912c2e2d8bbe33c036f342cc735737064668585dac28f/pydantic_core-2.41.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80aa89cad80b32a912a65332f64a4450ed00966111b6615ca6816153d3585a8c", size = 1981607, upload-time = "2025-11-04T13:41:58.889Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/ed/068e41660b832bb0b1aa5b58011dea2a3fe0ba7861ff38c4d4904c1c1a99/pydantic_core-2.41.5-cp314-cp314t-win_arm64.whl", hash = "sha256:35b44f37a3199f771c3eaa53051bc8a70cd7b54f333531c59e29fd4db5d15008", size = 1974769, upload-time = "2025-11-04T13:42:01.186Z" },
+]
+
+[[package]]
+name = "pydantic-settings"
+version = "2.13.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/52/6d/fffca34caecc4a3f97bda81b2098da5e8ab7efc9a66e819074a11955d87e/pydantic_settings-2.13.1.tar.gz", hash = "sha256:b4c11847b15237fb0171e1462bf540e294affb9b86db4d9aa5c01730bdbe4025", size = 223826, upload-time = "2026-02-19T13:45:08.055Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/00/4b/ccc026168948fec4f7555b9164c724cf4125eac006e176541483d2c959be/pydantic_settings-2.13.1-py3-none-any.whl", hash = "sha256:d56fd801823dbeae7f0975e1f8c8e25c258eb75d278ea7abb5d9cebb01b56237", size = 58929, upload-time = "2026-02-19T13:45:06.034Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
+]
+
+[[package]]
+name = "pytest-asyncio"
+version = "1.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f0/26/19cadc79a718c5edbec86fd4919a6b6d3f681039a2f6d66d14be94e75fb9/python_dotenv-1.2.1.tar.gz", hash = "sha256:42667e897e16ab0d66954af0e60a9caa94f0fd4ecf3aaf6d2d260eec1aa36ad6", size = 44221, upload-time = "2025-10-26T15:12:10.434Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/1b/a298b06749107c305e1fe0f814c6c74aea7b2f1e10989cb30f544a1b3253/python_dotenv-1.2.1-py3-none-any.whl", hash = "sha256:b81ee9561e9ca4004139c6cbba3a238c32b03e4894671e181b671e8cb8425d61", size = 21230, upload-time = "2025-10-26T15:12:09.109Z" },
+]
+
+[[package]]
+name = "starlette"
+version = "0.52.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c4/68/79977123bb7be889ad680d79a40f339082c1978b5cfcf62c2d8d196873ac/starlette-0.52.1.tar.gz", hash = "sha256:834edd1b0a23167694292e94f597773bc3f89f362be6effee198165a35d62933", size = 2653702, upload-time = "2026-01-18T13:34:11.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/81/0d/13d1d239a25cbfb19e740db83143e95c772a1fe10202dda4b76792b114dd/starlette-0.52.1-py3-none-any.whl", hash = "sha256:0029d43eb3d273bc4f83a08720b4912ea4b071087a3b48db01b7c839f7954d74", size = 74272, upload-time = "2026-01-18T13:34:09.188Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "uvicorn"
+version = "0.41.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/32/ce/eeb58ae4ac36fe09e3842eb02e0eb676bf2c53ae062b98f1b2531673efdd/uvicorn-0.41.0.tar.gz", hash = "sha256:09d11cf7008da33113824ee5a1c6422d89fbc2ff476540d69a34c87fab8b571a", size = 82633, upload-time = "2026-02-16T23:07:24.1Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/83/e4/d04a086285c20886c0daad0e026f250869201013d18f81d9ff5eada73a88/uvicorn-0.41.0-py3-none-any.whl", hash = "sha256:29e35b1d2c36a04b9e180d4007ede3bcb32a85fbdfd6c6aeb3f26839de088187", size = 68783, upload-time = "2026-02-16T23:07:22.357Z" },
+]

protonmail/CLAUDE.md

@@ -0,0 +1,40 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working
+with code in this repository.
+
+## Overview
+
+protonmail is a CLI tool for accessing and managing ProtonMail emails via Bridge.
+All commands work with local cached .eml files for fast, offline access.
+
+## Commands
+
+```bash
+uv sync                            # Install dependencies
+uv run protonmail --version        # Show version
+uv run protonmail sync             # Sync emails from Bridge
+uv run protonmail list             # List cached emails
+uv run protonmail read <file>      # Read a specific email
+uv run protonmail search <query>   # Search by subject/sender
+uv run pytest tests/ -v            # Run tests
+uv run ruff check .                # Lint
+uv run ruff format .               # Format
+```
+
+## Architecture
+
+- `src/protonmail/main.py` — CLI entry point, all email operations
+- `src/protonmail/__init__.py` — Package version (`__version__`)
+- `tests/` — pytest tests
+
+## Configuration
+
+Environment variables (set by castle or manually):
+- `PROTONMAIL_USERNAME` — ProtonMail Bridge username
+- `PROTONMAIL_API_KEY` — ProtonMail Bridge API key
+- `PROTONMAIL_DATA_DIR` — Where to store synced .eml files (default: /data/messages/email/protonmail)
+
+## Dependencies
+
+stdlib-only — no third-party packages required.