diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index efcc3a998..ccea311c2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -28,9 +28,27 @@ jobs:
       - name: Setup uv virtual environment
         run: uv venv
 
-      - name: Install dependencies
+      - name: Install lean dependencies
         run: uv pip install -e .
 
+      - name: Verify lean install keeps native extras optional
+        run: |
+          uv run python - <<'PY'
+          import importlib.util
+
+          optional_modules = ["PIL", "playwright", "regex", "ripgrep", "tiktoken"]
+          installed = [name for name in optional_modules if importlib.util.find_spec(name)]
+          if installed:
+              raise SystemExit(f"Lean install unexpectedly included optional modules: {installed}")
+          print("Lean install optional-native smoke check passed")
+          PY
+
+      - name: Install CI test extras
+        # The full historical test suite exercises image/search behavior.
+        # macOS CI can use the PyPI ripgrep [search] extra; Android/Termux uses
+        # system rg from `pkg install ripgrep` instead.
+        run: uv pip install -e ".[images,search]"
+
       - name: Install pexpect for integration tests
         run: uv pip install pexpect>=4.9.0
 
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
index 07b100d2a..bc26a8cde 100644
--- a/.github/workflows/publish.yml
+++ b/.github/workflows/publish.yml
@@ -34,11 +34,29 @@ jobs:
       - name: Setup uv virtual environment
         run: uv venv
 
-      - name: Install dependencies
+      - name: Install lean durable dependencies
         # [durable] extras pulls in dbos, required by integration test
         # tests/integration/test_dbos_enabled.py
         run: uv pip install -e ".[durable]"
 
+      - name: Verify lean install keeps native extras optional
+        run: |
+          uv run python - <<'PY'
+          import importlib.util
+
+          optional_modules = ["PIL", "playwright", "regex", "ripgrep", "tiktoken"]
+          installed = [name for name in optional_modules if importlib.util.find_spec(name)]
+          if installed:
+              raise SystemExit(f"Lean install unexpectedly included optional modules: {installed}")
+          print("Lean install optional-native smoke check passed")
+          PY
+
+      - name: Install CI test extras
+        # The full historical test suite exercises image/search behavior.
+        # macOS CI can use the PyPI ripgrep [search] extra; Android/Termux uses
+        # system rg from `pkg install ripgrep` instead.
+        run: uv pip install -e ".[durable,images,search]"
+
       - name: Install pexpect for integration tests
         run: uv pip install pexpect>=4.9.0
 
diff --git a/README.md b/README.md
index acc9cb7ae..c7f4e1141 100644
--- a/README.md
+++ b/README.md
@@ -75,6 +75,73 @@ powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | ie
 uvx code-puppy
 ```
 
+#### Android / Termux
+
+Code Puppy installs lean on Android/Termux. Read the full guide at
+[`docs/ANDROID_INSTALL.md`](docs/ANDROID_INSTALL.md). Android's Python wheel
+availability is different from desktop Linux, so the installer keeps optional
+native-heavy features detached and makes the required Termux build toolchain
+explicit.
+
+**The one-command path (recommended):** the interactive bootstrap *wizard*
+detects the device and walks you through every remaining step (native helper
+packages, Code Puppy) with a `[Y/n]` confirmation before each one, then verifies
+the install. Install `uv rust clang` first because `uvx --from code-puppy ...`
+must resolve Code Puppy's required Python dependencies before the wizard can run:
+
+```bash
+pkg update
+pkg install python git uv rust clang
+uvx --from code-puppy code-puppy-bootstrap wizard
+```
+
+The wizard is stdlib-only, gates every state-changing step behind a prompt, and
+finishes with a verification + reconciliation summary. Add `--yes` to
+auto-confirm for scripted installs, or `--dry-run` to preview without executing
+anything. You can also inspect the plan without running it:
+
+```bash
+uvx --from code-puppy code-puppy-bootstrap detect   # what the wizard sees
+uvx --from code-puppy code-puppy-bootstrap plan      # the lean install plan
+```
+
+<details>
+<summary>Prefer to drive it by hand? Here is the manual flow the wizard runs.</summary>
+
+```bash
+# In Termux
+pkg update
+pkg install python git uv rust clang ripgrep proot
+uv tool install --refresh code-puppy
+code-puppy -i
+```
+
+</details>
+
+Install `ripgrep` from Termux (`pkg install ripgrep`) so the file-search and
+recursive-listing tools work — Code Puppy uses the system `rg` binary. Android
+support does not remove search support; it only prevents the PyPI `ripgrep`
+package from being installed on Android/Termux, where it is known to fail.
+Desktop and CI installs using the optional `[search]` extra remain unchanged.
+
+#### Optional: Browser automation
+
+Browser tools are powered by [Playwright](https://playwright.dev/), which has no
+wheels for some platforms (e.g. Android/Termux). It is therefore an optional
+extra and is **not** part of the base install. On supported platforms, opt in:
+
+```bash
+pip install "code-puppy[browser]"
+# or
+uv tool install "code-puppy[browser]"
+
+# then download the browser binaries
+playwright install chromium
+```
+
+Without this extra, Code Puppy runs normally; browser tools simply report that
+the optional `browser` dependency is missing when they are invoked.
+
 #### Optional: DBOS durable execution
 
 Code Puppy ships with an optional [DBOS](https://github.com/dbos-inc/dbos-transact-py)-backed
diff --git a/code_puppy/bootstrap.py b/code_puppy/bootstrap.py
new file mode 100644
index 000000000..3c71510d1
--- /dev/null
+++ b/code_puppy/bootstrap.py
@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from typing import Any
+
+from code_puppy.bootstrap_profiles import (
+    available_profiles,
+    build_install_plan,
+    detect_environment,
+)
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Code Puppy bootstrap planner for lean environment-aware installs"
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    detect_parser = subparsers.add_parser(
+        "detect",
+        help="Inspect the current environment without importing the runtime CLI",
+    )
+    detect_parser.add_argument("--json", action="store_true", help="Print JSON output")
+
+    plan_parser = subparsers.add_parser(
+        "plan",
+        help="Build a lean install/reattach plan from a builtin profile and optional manifest",
+    )
+    plan_parser.add_argument(
+        "--profile",
+        default="auto",
+        choices=["auto", *available_profiles()],
+        help="Builtin install profile to use",
+    )
+    plan_parser.add_argument(
+        "--manifest-json",
+        default="",
+        help="Inline JSON manifest with extras_add/extras_remove/notes overrides",
+    )
+    plan_parser.add_argument(
+        "--manifest-file",
+        default="",
+        help="Path to a JSON manifest file with plan overrides",
+    )
+    plan_parser.add_argument("--json", action="store_true", help="Print JSON output")
+
+    wizard_parser = subparsers.add_parser(
+        "wizard",
+        help="Interactively install Code Puppy step-by-step with confirmation",
+    )
+    wizard_parser.add_argument(
+        "--profile",
+        default="auto",
+        choices=["auto", *available_profiles()],
+        help="Builtin install profile to use",
+    )
+    wizard_parser.add_argument(
+        "--yes",
+        action="store_true",
+        help="Auto-confirm every step (non-interactive automation)",
+    )
+    wizard_parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would run without executing anything",
+    )
+
+    return parser
+
+
+def _human_detect(environment: dict[str, Any]) -> str:
+    lines = [
+        "Code Puppy bootstrap environment",
+        f"- python: {environment['python_executable']}",
+        f"- version: {environment['python_version']}",
+        f"- platform: {environment['platform_system']} {environment['platform_release']} ({environment['platform_machine']})",
+        f"- termux: {'yes' if environment['is_termux'] else 'no'}",
+        f"- android: {'yes' if environment['is_android'] else 'no'}",
+        f"- uv: {'yes' if environment['has_uv'] else 'no'}",
+        f"- uvx: {'yes' if environment['has_uvx'] else 'no'}",
+        f"- proot: {'yes' if environment['has_proot'] else 'no'}",
+        f"- ripgrep: {'yes' if environment['has_ripgrep'] else 'no'}",
+        f"- rust: {'yes' if environment['has_rust'] else 'no'}",
+        f"- clang: {'yes' if environment['has_clang'] else 'no'}",
+    ]
+    return "\n".join(lines)
+
+
+def _human_plan(plan: dict[str, Any]) -> str:
+    lines = [
+        f"Profile: {plan['profile']}",
+        f"Package spec: {plan['package_spec']}",
+        f"Install: {plan['install_command']}",
+        f"Reattach: {plan['reattach_command']}",
+        f"Run: {plan['run_command']}",
+    ]
+    if plan["extras"]:
+        lines.append(f"Extras: {', '.join(plan['extras'])}")
+    if plan["degraded_capabilities"]:
+        lines.append("Degraded until reattach:")
+        lines.extend(f"- {item}" for item in plan["degraded_capabilities"])
+    if plan["system_packages"]:
+        lines.append("Suggested system packages:")
+        lines.extend(f"- {item}" for item in plan["system_packages"])
+    if plan["notes"]:
+        lines.append("Notes:")
+        lines.extend(f"- {item}" for item in plan["notes"])
+    return "\n".join(lines)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    command = args.command or "plan"
+
+    try:
+        if command == "wizard":
+            from code_puppy.bootstrap_wizard import run_wizard
+
+            return run_wizard(
+                profile=getattr(args, "profile", "auto"),
+                assume_yes=getattr(args, "yes", False),
+                dry_run=getattr(args, "dry_run", False),
+            )
+
+        if command == "detect":
+            environment = detect_environment()
+            if args.json:
+                print(json.dumps(environment, indent=2, sort_keys=True))
+            else:
+                print(_human_detect(environment))
+            return 0
+
+        plan = build_install_plan(
+            requested_profile=getattr(args, "profile", "auto"),
+            manifest_json=getattr(args, "manifest_json", ""),
+            manifest_file=getattr(args, "manifest_file", ""),
+        )
+        if getattr(args, "json", False):
+            print(json.dumps(plan, indent=2, sort_keys=True))
+        else:
+            print(_human_plan(plan))
+        return 0
+    except ValueError as exc:
+        parser.exit(status=2, message=f"error: {exc}\n")
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))
diff --git a/code_puppy/bootstrap_profiles.py b/code_puppy/bootstrap_profiles.py
new file mode 100644
index 000000000..09f3aef7b
--- /dev/null
+++ b/code_puppy/bootstrap_profiles.py
@@ -0,0 +1,276 @@
+from __future__ import annotations
+
+import json
+import os
+import platform
+import shlex
+import shutil
+import sys
+from copy import deepcopy
+from pathlib import Path
+from typing import Any
+
+DEFAULT_PACKAGE_NAME = "code-puppy"
+
+_BUILTIN_PROFILES: dict[str, dict[str, Any]] = {
+    "core": {
+        "description": "Lean base runtime with no optional extras attached.",
+        "extras": [],
+        "notes": [
+            "Use this when a launcher only needs the core CLI/runtime.",
+            "Optional capabilities should reattach later based on deployment policy.",
+        ],
+        "system_packages": [],
+    },
+    "android-termux-lean": {
+        "description": "Android/Termux-safe profile that keeps Python deps lean.",
+        "extras": [],
+        "notes": [
+            "Install the Termux build toolchain first; pydantic-core has no Android wheel.",
+            "Avoid browser/image/search extras during initial attach.",
+            "Reattach optional capabilities only after the target environment is known.",
+        ],
+        "system_packages": [
+            "pkg install rust clang",
+            "pkg install ripgrep proot",
+        ],
+    },
+    "desktop-browser": {
+        "description": "Desktop-oriented profile with local browser, image, and search helpers.",
+        "extras": ["browser", "images", "search"],
+        "notes": [
+            "Useful for developer laptops and desktop automation environments.",
+        ],
+        "system_packages": [],
+    },
+    "developer-full": {
+        "description": "Broad developer profile with provider and tooling extras attached.",
+        "extras": [
+            "bedrock",
+            "browser",
+            "durable",
+            "images",
+            "search",
+        ],
+        "notes": [
+            "This is intentionally heavy; use it only when the environment is known-good.",
+        ],
+        "system_packages": [],
+    },
+}
+
+
+def available_profiles() -> list[str]:
+    return sorted(_BUILTIN_PROFILES)
+
+
+def detect_environment() -> dict[str, Any]:
+    executable = Path(sys.executable).expanduser().resolve()
+    release = platform.release()
+    system_name = platform.system()
+    termux_prefix = os.environ.get("PREFIX", "")
+    termux_version = os.environ.get("TERMUX_VERSION", "")
+    is_termux = (
+        bool(termux_version)
+        or "com.termux" in str(executable)
+        or (system_name == "Linux" and "com.termux" in termux_prefix)
+    )
+    is_android = is_termux or "android" in release.lower()
+
+    return {
+        "python_executable": str(executable),
+        "python_version": platform.python_version(),
+        "platform_system": system_name,
+        "platform_release": release,
+        "platform_machine": platform.machine(),
+        "is_android": is_android,
+        "is_termux": is_termux,
+        "is_windows": system_name == "Windows",
+        "is_macos": system_name == "Darwin",
+        "is_linux": system_name == "Linux",
+        "has_uv": shutil.which("uv") is not None,
+        "has_uvx": shutil.which("uvx") is not None,
+        "has_proot": shutil.which("proot") is not None,
+        "has_ripgrep": shutil.which("rg") is not None,
+        "has_rust": shutil.which("rustc") is not None
+        and shutil.which("cargo") is not None,
+        "has_clang": shutil.which("clang") is not None,
+        "has_git": shutil.which("git") is not None,
+    }
+
+
+def auto_profile_name(environment: dict[str, Any]) -> str:
+    if environment.get("is_termux") or environment.get("is_android"):
+        return "android-termux-lean"
+    if environment.get("is_windows") or environment.get("is_macos"):
+        return "desktop-browser"
+    if environment.get("is_linux"):
+        return "desktop-browser"
+    return "core"
+
+
+def resolve_profile_name(
+    requested_profile: str | None, environment: dict[str, Any]
+) -> str:
+    raw = (
+        requested_profile or os.environ.get("CODE_PUPPY_INSTALL_PROFILE", "auto")
+    ).strip()
+    if not raw or raw == "auto":
+        return auto_profile_name(environment)
+    if raw not in _BUILTIN_PROFILES:
+        choices = ", ".join(available_profiles())
+        raise ValueError(f"unknown install profile '{raw}'. Choices: auto, {choices}")
+    return raw
+
+
+def _parse_manifest_json(raw: str) -> dict[str, Any]:
+    data = json.loads(raw)
+    if not isinstance(data, dict):
+        raise ValueError("bootstrap manifest must be a JSON object")
+    return data
+
+
+def load_manifest(
+    *,
+    manifest_json: str = "",
+    manifest_file: str = "",
+) -> dict[str, Any]:
+    raw_json = (
+        manifest_json.strip()
+        or os.environ.get("CODE_PUPPY_BOOTSTRAP_MANIFEST_JSON", "").strip()
+    )
+    raw_file = (
+        manifest_file.strip()
+        or os.environ.get("CODE_PUPPY_BOOTSTRAP_MANIFEST_FILE", "").strip()
+    )
+
+    if raw_json and raw_file:
+        raise ValueError("choose manifest_json or manifest_file, not both")
+    if raw_json:
+        return _parse_manifest_json(raw_json)
+    if raw_file:
+        return _parse_manifest_json(
+            Path(raw_file).expanduser().read_text(encoding="utf-8")
+        )
+    return {}
+
+
+def _normalize_list(value: Any, *, field_name: str) -> list[str]:
+    if value in (None, ""):
+        return []
+    if not isinstance(value, list) or not all(isinstance(item, str) for item in value):
+        raise ValueError(
+            f"bootstrap manifest field '{field_name}' must be a list of strings"
+        )
+    return [item.strip() for item in value if item.strip()]
+
+
+def merge_profile(
+    profile_name: str,
+    manifest: dict[str, Any] | None = None,
+) -> tuple[dict[str, Any], list[str]]:
+    profile = deepcopy(_BUILTIN_PROFILES[profile_name])
+    reasons = [f"base profile: {profile_name}"]
+    manifest = manifest or {}
+    if not manifest:
+        return profile, reasons
+
+    profile_override = manifest.get("profile", "")
+    if profile_override and profile_override != profile_name:
+        raise ValueError(
+            f"manifest profile '{profile_override}' does not match resolved profile '{profile_name}'"
+        )
+
+    extras = set(profile["extras"])
+    extras.update(_normalize_list(manifest.get("extras_add"), field_name="extras_add"))
+    extras.difference_update(
+        _normalize_list(manifest.get("extras_remove"), field_name="extras_remove")
+    )
+    profile["extras"] = sorted(extras)
+
+    for key in ("notes", "system_packages"):
+        profile[key] = profile[key] + _normalize_list(manifest.get(key), field_name=key)
+
+    description = manifest.get("description", "")
+    if description:
+        if not isinstance(description, str):
+            raise ValueError("bootstrap manifest field 'description' must be a string")
+        profile["description"] = description.strip()
+
+    package_name = manifest.get("package_name", "")
+    if package_name:
+        if not isinstance(package_name, str):
+            raise ValueError("bootstrap manifest field 'package_name' must be a string")
+        profile["package_name"] = package_name.strip()
+
+    if manifest:
+        reasons.append("manifest overrides applied")
+    return profile, reasons
+
+
+def package_spec(package_name: str, extras: list[str]) -> str:
+    if not extras:
+        return package_name
+    return f"{package_name}[{','.join(sorted(extras))}]"
+
+
+def install_command(spec: str, environment: dict[str, Any]) -> str:
+    if environment.get("has_uv"):
+        return f"uv tool install --refresh {shlex.quote(spec)}"
+    return f"python -m pip install {shlex.quote(spec)}"
+
+
+def reattach_command(spec: str, environment: dict[str, Any]) -> str:
+    if environment.get("has_uv"):
+        return f"uv tool install --refresh {shlex.quote(spec)}"
+    return f"python -m pip install --upgrade {shlex.quote(spec)}"
+
+
+def build_install_plan(
+    *,
+    requested_profile: str | None = None,
+    manifest_json: str = "",
+    manifest_file: str = "",
+) -> dict[str, Any]:
+    environment = detect_environment()
+    resolved_profile = resolve_profile_name(requested_profile, environment)
+    manifest = load_manifest(manifest_json=manifest_json, manifest_file=manifest_file)
+    profile, reasons = merge_profile(resolved_profile, manifest)
+    selected_package = profile.get("package_name", DEFAULT_PACKAGE_NAME)
+    selected_extras = profile["extras"]
+    spec = package_spec(selected_package, selected_extras)
+
+    degraded = []
+    if resolved_profile == "android-termux-lean":
+        degraded = [
+            "browser automation extras detached",
+            "image/search extras detached",
+        ]
+
+    missing_system_packages = []
+    if resolved_profile == "android-termux-lean" and not environment.get("has_rust"):
+        missing_system_packages.append("rust")
+    if resolved_profile == "android-termux-lean" and not environment.get("has_clang"):
+        missing_system_packages.append("clang")
+    if resolved_profile == "android-termux-lean" and not environment.get("has_ripgrep"):
+        missing_system_packages.append("ripgrep")
+    if resolved_profile == "android-termux-lean" and not environment.get("has_proot"):
+        missing_system_packages.append("proot")
+
+    return {
+        "profile": resolved_profile,
+        "package_name": selected_package,
+        "package_spec": spec,
+        "description": profile["description"],
+        "extras": selected_extras,
+        "notes": profile["notes"],
+        "system_packages": profile["system_packages"],
+        "missing_system_packages": missing_system_packages,
+        "environment": environment,
+        "reasons": reasons,
+        "install_command": install_command(spec, environment),
+        "reattach_command": reattach_command(spec, environment),
+        "run_command": "code-puppy -i",
+        "degraded_capabilities": degraded,
+        "manifest_applied": bool(manifest),
+    }
diff --git a/code_puppy/bootstrap_wizard.py b/code_puppy/bootstrap_wizard.py
new file mode 100644
index 000000000..bb61991b0
--- /dev/null
+++ b/code_puppy/bootstrap_wizard.py
@@ -0,0 +1,259 @@
+"""Interactive, environment-aware install wizard for Code Puppy.
+
+The bootstrap *planner* (``code_puppy.bootstrap_profiles``) decides *what*
+should be installed. This module is the *wizard*: it walks an operator --
+especially an Android/Termux newcomer -- through *doing* it, one confirmed
+step at a time, then verifies and reconciles the result.
+
+Design rules honored here:
+- stdlib-only (``subprocess``/``shutil``) so it runs before any heavy deps
+- destructive/state-altering steps are gated behind explicit confirmation
+- ``--dry-run`` never executes; ``--yes`` auto-confirms for automation
+- the wizard always ends with a verification + reconciliation summary
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+from code_puppy.bootstrap_profiles import build_install_plan, detect_environment
+
+
+@dataclass
+class WizardStep:
+    """A single confirmable unit of install work."""
+
+    key: str
+    title: str
+    command: str
+    explanation: str
+    # Returns True when the step's goal is *already* satisfied (skip it).
+    is_satisfied: Callable[[], bool] = field(default=lambda: False)
+    required: bool = True
+
+
+@dataclass
+class StepOutcome:
+    key: str
+    status: str  # satisfied | done | skipped | failed | dry-run
+    detail: str = ""
+
+
+def _has(binary: str) -> bool:
+    return shutil.which(binary) is not None
+
+
+def build_steps(profile: str | None = None) -> tuple[list[WizardStep], dict[str, Any]]:
+    """Derive the ordered wizard steps from the canonical install plan.
+
+    Reusing :func:`build_install_plan` keeps a single source of truth for
+    *what* to install -- the wizard only decides *how* to walk it.
+    """
+
+    plan = build_install_plan(requested_profile=profile)
+    env = plan["environment"]
+    steps: list[WizardStep] = []
+
+    # 1. Package manager (uv) -- the engine everything else rides on.
+    if not env.get("has_uv"):
+        if env.get("is_termux") or env.get("is_android"):
+            uv_cmd = "pkg install -y uv"
+        else:
+            uv_cmd = "curl -LsSf https://astral.sh/uv/install.sh | sh"
+        steps.append(
+            WizardStep(
+                key="uv",
+                title="Install the uv package manager",
+                command=uv_cmd,
+                explanation=(
+                    "uv installs and runs Code Puppy in an isolated tool env; "
+                    "Termux should use its packaged uv instead of building uv from PyPI."
+                ),
+                is_satisfied=lambda: _has("uv"),
+            )
+        )
+
+    # 2. System packages: Android build toolchain + native helper binaries.
+    missing = plan.get("missing_system_packages") or []
+    if missing:
+        steps.append(
+            WizardStep(
+                key="system_packages",
+                title=f"Install Termux system packages: {', '.join(missing)}",
+                command=f"pkg install -y {' '.join(missing)}",
+                explanation=(
+                    "Termux needs rust/clang to build unavoidable native Python "
+                    "deps (pydantic-core), plus helper binaries like ripgrep/proot."
+                ),
+                is_satisfied=lambda missing=missing: all(
+                    _has({"ripgrep": "rg", "rust": "rustc"}.get(m, m)) for m in missing
+                ),
+            )
+        )
+
+    # 3. Code Puppy itself.
+    steps.append(
+        WizardStep(
+            key="code_puppy",
+            title=f"Install Code Puppy ({plan['package_spec']})",
+            command=plan["install_command"],
+            explanation=plan["description"],
+            is_satisfied=lambda: False,  # always (re)attach; --refresh is idempotent
+        )
+    )
+
+    return steps, plan
+
+
+def _confirm(prompt: str, *, assume_yes: bool) -> bool:
+    if assume_yes:
+        print(f"{prompt} [auto-yes]")
+        return True
+    if not sys.stdin.isatty():
+        # Non-interactive without --yes: refuse to act, don't hang.
+        print(f"{prompt} [no TTY -- skipping; pass --yes to auto-run]")
+        return False
+    try:
+        answer = input(f"{prompt} [Y/n] ").strip().lower()
+    except (EOFError, KeyboardInterrupt):
+        print()
+        return False
+    return answer in ("", "y", "yes")
+
+
+def _run_command(command: str) -> tuple[int, str]:
+    """Run a shell command, streaming nothing, capturing combined output."""
+
+    try:
+        proc = subprocess.run(
+            command,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=1800,
+        )
+    except subprocess.TimeoutExpired:
+        return 124, "timed out after 1800s"
+    except Exception as exc:  # never crash the wizard
+        return 1, f"failed to launch: {exc}"
+    output = (proc.stdout or "") + (proc.stderr or "")
+    return proc.returncode, output.strip()
+
+
+def _verify(plan: dict[str, Any]) -> StepOutcome:
+    """Confirm Code Puppy actually landed and can answer for itself."""
+
+    if not _has("code-puppy"):
+        return StepOutcome(
+            "verify",
+            "failed",
+            "`code-puppy` not found on PATH after install.",
+        )
+    code, out = _run_command("code-puppy --help")
+    if code != 0:
+        tail = out.splitlines()[-3:] if out else []
+        return StepOutcome("verify", "failed", "; ".join(tail) or f"exit {code}")
+    return StepOutcome("verify", "done", "`code-puppy --help` runs cleanly.")
+
+
+def run_wizard(
+    *,
+    profile: str | None = None,
+    assume_yes: bool = False,
+    dry_run: bool = False,
+) -> int:
+    """Execute the interactive install wizard. Returns a process exit code."""
+
+    steps, plan = build_steps(profile)
+    env = plan["environment"]
+
+    print("Code Puppy install wizard")
+    print(f"  profile : {plan['profile']}")
+    print(
+        "  device  : "
+        f"{env['platform_system']} {env['platform_release']} ({env['platform_machine']})"
+    )
+    print(f"  python  : {env['python_version']}")
+    print(f"  steps   : {len(steps)}")
+    if dry_run:
+        print("  mode    : DRY-RUN (nothing will be executed)")
+    print()
+
+    outcomes: list[StepOutcome] = []
+
+    for index, step in enumerate(steps, start=1):
+        print(f"[{index}/{len(steps)}] {step.title}")
+        print(f"      why: {step.explanation}")
+        print(f"      run: {step.command}")
+
+        if step.is_satisfied():
+            print("      -> already satisfied, skipping.\n")
+            outcomes.append(StepOutcome(step.key, "satisfied"))
+            continue
+
+        if dry_run:
+            print("      -> dry-run, not executed.\n")
+            outcomes.append(StepOutcome(step.key, "dry-run"))
+            continue
+
+        if not _confirm("      proceed?", assume_yes=assume_yes):
+            status = "skipped"
+            print(f"      -> {status}.\n")
+            outcomes.append(StepOutcome(step.key, status))
+            if step.required:
+                print(
+                    "      (this step is required -- later steps may fail without it)\n"
+                )
+            continue
+
+        code, out = _run_command(step.command)
+        if code == 0:
+            print("      -> done.\n")
+            outcomes.append(StepOutcome(step.key, "done"))
+        else:
+            tail = "\n        ".join(out.splitlines()[-5:]) if out else f"exit {code}"
+            print(f"      -> FAILED (exit {code}):\n        {tail}\n")
+            outcomes.append(StepOutcome(step.key, "failed", f"exit {code}"))
+            if step.required:
+                print("Required step failed -- stopping. Fix the above and re-run.\n")
+                _print_summary(outcomes, verify=None)
+                return 1
+
+    verify = None
+    if not dry_run:
+        verify = _verify(plan)
+        symbol = "OK" if verify.status == "done" else "FAILED"
+        print(f"Verification: {symbol} -- {verify.detail}\n")
+
+    _print_summary(outcomes, verify=verify)
+
+    failed = any(o.status == "failed" for o in outcomes)
+    if verify is not None and verify.status == "failed":
+        failed = True
+    return 1 if failed else 0
+
+
+def _print_summary(outcomes: list[StepOutcome], *, verify: StepOutcome | None) -> None:
+    print("Summary (state reconciliation):")
+    for outcome in outcomes:
+        line = f"  - {outcome.key}: {outcome.status}"
+        if outcome.detail:
+            line += f" ({outcome.detail})"
+        print(line)
+    if verify is not None:
+        line = f"  - verify: {verify.status}"
+        if verify.detail:
+            line += f" ({verify.detail})"
+        print(line)
+    if verify is not None and verify.status == "done":
+        print("\nAll set -- run it with:  code-puppy -i")
+
+
+def detect_summary() -> dict[str, Any]:
+    """Thin re-export so callers can pre-flight without importing profiles."""
+
+    return detect_environment()
diff --git a/code_puppy/tools/browser/browser_manager.py b/code_puppy/tools/browser/browser_manager.py
index d1b4da07d..ca1b7be08 100644
--- a/code_puppy/tools/browser/browser_manager.py
+++ b/code_puppy/tools/browser/browser_manager.py
@@ -7,14 +7,58 @@
 import atexit
 import contextvars
 import os
+import sys
+import types
 from pathlib import Path
-from typing import Callable, Dict, Optional
-
-from playwright.async_api import Browser, BrowserContext, Page
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional
 
 from code_puppy import config
 from code_puppy.messaging import emit_info, emit_success, emit_warning
 
+if TYPE_CHECKING:
+    from playwright.async_api import Browser, BrowserContext, Page
+else:
+    Browser = BrowserContext = Page = Any
+
+
+def _missing_playwright(*_args, **_kwargs):
+    """Raise a friendly error when Playwright is unavailable."""
+    raise RuntimeError(
+        "Playwright is not installed in this environment. "
+        "Browser tools require the optional 'playwright' dependency "
+        "(install code-puppy[browser]) on a supported platform."
+    )
+
+
+def _install_playwright_stub() -> None:
+    """Register a minimal stub so browser modules stay importable.
+
+    Keeps optional browser support from crashing startup on platforms where
+    Playwright wheels are unavailable (e.g. Android/Termux). Browser tools then
+    fail loudly only when actually invoked, instead of at import time.
+    """
+    playwright_module = sys.modules.get("playwright")
+    if playwright_module is None:
+        playwright_module = types.ModuleType("playwright")
+        sys.modules["playwright"] = playwright_module
+
+    async_api_module = sys.modules.get("playwright.async_api")
+    if async_api_module is None:
+        async_api_module = types.ModuleType("playwright.async_api")
+        async_api_module.Browser = Browser
+        async_api_module.BrowserContext = BrowserContext
+        async_api_module.Page = Page
+        async_api_module.async_playwright = _missing_playwright
+        sys.modules["playwright.async_api"] = async_api_module
+
+    setattr(playwright_module, "async_api", async_api_module)
+
+
+try:
+    import playwright.async_api as _playwright_async_api  # noqa: F401
+except ImportError:
+    _install_playwright_stub()
+
 # Registry for custom browser types from plugins (e.g., Camoufox for stealth browsing)
 _CUSTOM_BROWSER_TYPES: Dict[str, Callable] = {}
 _BROWSER_TYPES_LOADED: bool = False
diff --git a/code_puppy/tools/image_tools.py b/code_puppy/tools/image_tools.py
index 9081a09db..57e8a434c 100644
--- a/code_puppy/tools/image_tools.py
+++ b/code_puppy/tools/image_tools.py
@@ -16,7 +16,18 @@
 from pathlib import Path
 from typing import Any, Dict, Union
 
-from PIL import Image, UnidentifiedImageError
+try:
+    from PIL import Image, UnidentifiedImageError
+
+    PIL_AVAILABLE = True
+except ImportError:  # Pillow is optional; install code-puppy[images]
+    Image = None
+
+    class UnidentifiedImageError(Exception):
+        """Fallback used only when Pillow is not installed."""
+
+    PIL_AVAILABLE = False
+
 from pydantic_ai import BinaryContent, RunContext, ToolReturn
 
 from code_puppy.messaging import emit_error, emit_info, emit_success
@@ -40,6 +51,11 @@ def _validate_and_prepare_image(
     file extension. If the image is resized, the output is normalized to PNG so
     the returned bytes and MIME type stay in sync like civilized software.
     """
+    if not PIL_AVAILABLE or Image is None:
+        raise ValueError(
+            "Image tools require Pillow. Install with: pip install 'code-puppy[images]'"
+        )
+
     try:
         with Image.open(io.BytesIO(image_bytes)) as verified_image:
             verified_image.verify()
diff --git a/docs/ANDROID_INSTALL.md b/docs/ANDROID_INSTALL.md
new file mode 100644
index 000000000..aaee3603e
--- /dev/null
+++ b/docs/ANDROID_INSTALL.md
@@ -0,0 +1,160 @@
+# Code Puppy on Android / Termux
+
+This guide is for a **fresh Termux install on Android**. Code Puppy works on
+Android, but it is not a normal desktop Python install: several dependencies use
+native code, and Android does not receive the same PyPI wheels as Linux/macOS.
+
+The installer path below is intentionally conservative: install the Termux build
+toolchain first, keep optional heavyweight features detached, then install the
+lean Code Puppy runtime.
+
+## 0. Use the real Termux
+
+Install Termux from F-Droid or GitHub releases. The Play Store build is stale and
+will cause weird package failures. Weird as in "why is my phone haunted?" weird.
+
+## 1. Recommended: run the bootstrap wizard
+
+After installing Termux, run:
+
+```bash
+pkg update
+pkg install python git uv rust clang
+uvx --from code-puppy code-puppy-bootstrap wizard
+```
+
+Install `uv` from Termux (`pkg install uv`) instead of PyPI. On Android, PyPI may
+fall back to building `uv` from source, which needs Rust before you even have the
+installer. That is a very silly bootstrapping sandwich, so we skip it.
+
+The wizard detects your device, explains each step, asks before changing state,
+and finishes by verifying `code-puppy --help`.
+
+For scripted installs:
+
+```bash
+uvx --from code-puppy code-puppy-bootstrap wizard --yes
+```
+
+To preview only:
+
+```bash
+uvx --from code-puppy code-puppy-bootstrap wizard --dry-run
+```
+
+## 2. Manual install path
+
+If you prefer to drive the meat wagon yourself:
+
+```bash
+pkg update
+pkg install python git uv rust clang ripgrep proot
+uv tool install --refresh code-puppy
+code-puppy -i
+```
+
+### Why `rust clang` are required
+
+`pydantic-core` is a required dependency of `pydantic`, which Code Puppy uses
+through `pydantic-ai`. PyPI does not currently publish Android/Termux wheels for
+`pydantic-core`, and Termux does not ship a prebuilt `python-pydantic` package in
+the default repo. A fresh Android user therefore needs the Termux Rust/C build
+toolchain so pip/uv can build that dependency locally. Install it before running
+`uvx --from code-puppy ...`, because `uvx` must install Code Puppy before the
+wizard code can execute.
+
+The base install deliberately avoids other native-heavy optional packages:
+
+- Playwright is in the `[browser]` extra.
+- PyPI's bundled `ripgrep` package is in the `[search]` extra; the Android path
+  uses Termux's system `rg` from `pkg install ripgrep` instead.
+- Pillow is in the `[images]` extra.
+- `pydantic-ai-slim[openai]` is intentionally avoided in base because it pulls
+  `tiktoken` and `regex`, which require additional native builds on Android.
+
+Android support does not remove search support; it only prevents the PyPI
+`ripgrep` package from being installed on Android/Termux, where it is known to
+fail. Desktop and CI installs using `[search]` remain unchanged.
+
+## 3. Optional features
+
+Install these only after the lean runtime is working.
+
+```bash
+# Image loading / resizing tools
+uv tool install --refresh 'code-puppy[images]'
+
+# From a source checkout / editable install on Android, keep search desktop-only.
+# Plain `uv sync` installs dev tools such as Ruff and may try to build them
+# from source on Android; use --no-dev for runtime validation.
+uv sync --no-dev --python "$(command -v python)"
+
+# Or, from an activated lean venv:
+uv pip install -e '.[images]'
+
+# Desktop/browser automation environments only; not recommended on native Android
+uv tool install --refresh 'code-puppy[browser]'
+
+# Desktop/CI only: PyPI ripgrep bundle for non-Termux systems.
+# Android/Termux should prefer: pkg install ripgrep
+uv tool install --refresh 'code-puppy[search]'
+
+# DBOS-backed durable execution
+uv tool install --refresh 'code-puppy[durable]'
+```
+
+## 4. Verify the install
+
+```bash
+code-puppy --help
+code-puppy-bootstrap detect
+code-puppy-bootstrap plan --profile auto
+```
+
+On Android/Termux, the plan should select `android-termux-lean`.
+
+## Troubleshooting
+
+### `aarch64-linux-android-clang: No such file or directory`
+
+Install the compiler:
+
+```bash
+pkg install clang
+```
+
+### `Rust not found` or `maturin` fails building `pydantic-core`
+
+Install Rust:
+
+```bash
+pkg install rust
+```
+
+Then retry:
+
+```bash
+uv tool install --refresh code-puppy
+```
+
+### `rg` / search tools are unavailable
+
+Install Termux ripgrep:
+
+```bash
+pkg install ripgrep
+```
+
+### Image tools say Pillow is missing
+
+That is expected on the lean Android install. Reattach the optional image extra:
+
+```bash
+uv tool install --refresh 'code-puppy[images]'
+```
+
+### The install is slow
+
+Compiling Rust/C dependencies on a phone can take a while. Keep Termux in the
+foreground, keep the screen awake if needed, and avoid running it while Android
+is aggressively saving battery.
diff --git a/pyproject.toml b/pyproject.toml
index fb69e0450..47f07b7e9 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -9,7 +9,7 @@ description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"
 dependencies = [
-    "pydantic-ai-slim[openai,anthropic,mcp]==1.56.0",
+    "pydantic-ai-slim[anthropic,mcp]==1.56.0",
     "typer>=0.12.0",
     "mcp>=1.9.4",
     "httpx[http2]>=0.24.1",
@@ -22,10 +22,7 @@ dependencies = [
     "pyfiglet>=0.8.post1",
     "rapidfuzz>=3.13.0",
     "openai>=1.99.1",
-    "ripgrep==14.1.0",
-    "playwright>=1.40.0",
     "termflow-md>=0.1.11",
-    "Pillow>=10.0.0",
     "azure-identity>=1.15.0",
     "anthropic==0.79.0",
     "boto3>=1.43.9",
@@ -53,7 +50,10 @@ classifiers = [
 
 [project.optional-dependencies]
 bedrock = ["boto3>=1.35.0"]
+browser = ["playwright>=1.40.0"]
 durable = ["dbos>=2.11.0"]
+images = ["Pillow>=10.0.0"]
+search = ["ripgrep==14.1.0"]
 
 [project.urls]
 repository = "https://github.com/mpfaffenberger/code_puppy"
@@ -63,6 +63,7 @@ HomePage = "https://github.com/mpfaffenberger/code_puppy"
 [project.scripts]
 code-puppy = "code_puppy.main:main_entry"
 pup = "code_puppy.main:main_entry"
+code-puppy-bootstrap = "code_puppy.bootstrap:main"
 
 [tool.logfire]
 ignore_no_config = true
diff --git a/tests/test_bootstrap.py b/tests/test_bootstrap.py
new file mode 100644
index 000000000..840b27c58
--- /dev/null
+++ b/tests/test_bootstrap.py
@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+from code_puppy import bootstrap, bootstrap_profiles
+
+
+def test_bootstrap_import_does_not_pull_cli_runner():
+    result = subprocess.run(
+        [
+            sys.executable,
+            "-c",
+            "import sys; import code_puppy.bootstrap; print('code_puppy.cli_runner' in sys.modules)",
+        ],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    assert result.stdout.strip() == "False"
+
+
+def test_detect_environment_termux(monkeypatch):
+    monkeypatch.setenv("TERMUX_VERSION", "0.119")
+    monkeypatch.setenv("PREFIX", "/data/data/com.termux/files/usr")
+    environment = bootstrap_profiles.detect_environment()
+    assert environment["is_termux"] is True
+    assert environment["is_android"] is True
+
+
+def test_auto_profile_prefers_android_termux(monkeypatch):
+    monkeypatch.setenv("TERMUX_VERSION", "0.119")
+    monkeypatch.setenv("PREFIX", "/data/data/com.termux/files/usr")
+    plan = bootstrap_profiles.build_install_plan(requested_profile="auto")
+    assert plan["profile"] == "android-termux-lean"
+    assert plan["extras"] == []
+    assert "browser automation extras detached" in plan["degraded_capabilities"]
+
+
+def test_build_install_plan_applies_manifest_overrides(tmp_path: Path):
+    manifest_path = tmp_path / "manifest.json"
+    manifest_path.write_text(
+        json.dumps(
+            {
+                "profile": "android-termux-lean",
+                "extras_add": ["browser", "search"],
+                "extras_remove": ["search"],
+                "notes": ["cloud picked a browser-friendly lane"],
+            }
+        )
+    )
+    plan = bootstrap_profiles.build_install_plan(
+        requested_profile="android-termux-lean",
+        manifest_file=str(manifest_path),
+    )
+    assert plan["extras"] == ["browser"]
+    assert plan["manifest_applied"] is True
+    assert "cloud picked a browser-friendly lane" in plan["notes"]
+    assert plan["package_spec"] == "code-puppy[browser]"
+
+
+def test_build_install_plan_rejects_profile_mismatch(tmp_path: Path):
+    manifest_path = tmp_path / "manifest.json"
+    manifest_path.write_text(json.dumps({"profile": "desktop-browser"}))
+    with pytest.raises(ValueError, match="does not match"):
+        bootstrap_profiles.build_install_plan(
+            requested_profile="android-termux-lean",
+            manifest_file=str(manifest_path),
+        )
+
+
+def test_cli_detect_json(capsys):
+    exit_code = bootstrap.main(["detect", "--json"])
+    assert exit_code == 0
+    payload = json.loads(capsys.readouterr().out)
+    assert "python_executable" in payload
+    assert "is_termux" in payload
+
+
+def test_cli_plan_defaults_to_auto_json(capsys):
+    exit_code = bootstrap.main(["plan", "--json"])
+    assert exit_code == 0
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["profile"] in bootstrap_profiles.available_profiles()
+    assert payload["package_spec"].startswith("code-puppy")
+
+
+def test_build_install_plan_rejects_unknown_profile():
+    with pytest.raises(ValueError, match="unknown install profile"):
+        bootstrap_profiles.build_install_plan(requested_profile="not-a-real-profile")
+
+
+def test_build_install_plan_rejects_multiple_manifest_sources(tmp_path: Path):
+    manifest_path = tmp_path / "manifest.json"
+    manifest_path.write_text("{}")
+    with pytest.raises(ValueError, match="choose manifest_json or manifest_file"):
+        bootstrap_profiles.build_install_plan(
+            requested_profile="core",
+            manifest_json="{}",
+            manifest_file=str(manifest_path),
+        )
+
+
+def test_build_install_plan_falls_back_to_pip_without_uv(monkeypatch):
+    monkeypatch.setattr(
+        bootstrap_profiles,
+        "detect_environment",
+        lambda: {
+            "has_uv": False,
+            "has_uvx": False,
+            "has_proot": True,
+            "has_ripgrep": True,
+            "has_rust": True,
+            "has_clang": True,
+            "is_android": False,
+            "is_termux": False,
+            "is_linux": True,
+            "is_macos": False,
+            "is_windows": False,
+        },
+    )
+    plan = bootstrap_profiles.build_install_plan(requested_profile="core")
+    assert plan["install_command"] == "python -m pip install code-puppy"
+    assert plan["reattach_command"] == "python -m pip install --upgrade code-puppy"
+
+
+def test_build_install_plan_reports_missing_android_system_packages(monkeypatch):
+    monkeypatch.setattr(
+        bootstrap_profiles,
+        "detect_environment",
+        lambda: {
+            "has_uv": True,
+            "has_uvx": True,
+            "has_proot": False,
+            "has_ripgrep": False,
+            "has_rust": False,
+            "has_clang": False,
+            "is_android": True,
+            "is_termux": True,
+            "is_linux": True,
+            "is_macos": False,
+            "is_windows": False,
+        },
+    )
+    plan = bootstrap_profiles.build_install_plan(requested_profile="auto")
+    assert plan["profile"] == "android-termux-lean"
+    assert plan["missing_system_packages"] == ["rust", "clang", "ripgrep", "proot"]
+
+
+def test_cli_plan_human_output(capsys):
+    exit_code = bootstrap.main(["plan"])
+    assert exit_code == 0
+    output = capsys.readouterr().out
+    assert "Profile:" in output
+    assert "Install:" in output
+    assert "Run:" in output
+
+
+def test_cli_plan_rejects_bad_manifest_json(capsys):
+    with pytest.raises(SystemExit) as exc_info:
+        bootstrap.main(["plan", "--manifest-json", "[]"])
+    assert exc_info.value.code == 2
+    assert "bootstrap manifest must be a JSON object" in capsys.readouterr().err
diff --git a/tests/test_bootstrap_wizard.py b/tests/test_bootstrap_wizard.py
new file mode 100644
index 000000000..1e8894784
--- /dev/null
+++ b/tests/test_bootstrap_wizard.py
@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+
+from code_puppy import bootstrap, bootstrap_profiles, bootstrap_wizard
+
+
+def _fake_env(**overrides):
+    base = {
+        "python_executable": "/usr/bin/python3",
+        "python_version": "3.13.13",
+        "platform_system": "Linux",
+        "platform_release": "android",
+        "platform_machine": "aarch64",
+        "has_uv": True,
+        "has_uvx": True,
+        "has_proot": True,
+        "has_ripgrep": True,
+        "has_rust": True,
+        "has_clang": True,
+        "has_git": True,
+        "is_android": False,
+        "is_termux": False,
+        "is_linux": True,
+        "is_macos": False,
+        "is_windows": False,
+    }
+    base.update(overrides)
+    return base
+
+
+def _patch_env(monkeypatch, **overrides):
+    monkeypatch.setattr(
+        bootstrap_profiles,
+        "detect_environment",
+        lambda: _fake_env(**overrides),
+    )
+
+
+def test_bare_termux_device_builds_three_steps(monkeypatch):
+    """A fresh phone with nothing installed gets packaged uv -> packages -> code-puppy."""
+
+    _patch_env(
+        monkeypatch,
+        is_android=True,
+        is_termux=True,
+        has_uv=False,
+        has_proot=False,
+        has_ripgrep=False,
+        has_rust=False,
+        has_clang=False,
+    )
+    steps, plan = bootstrap_wizard.build_steps(profile="auto")
+    keys = [s.key for s in steps]
+    assert keys == ["uv", "system_packages", "code_puppy"]
+
+    by_key = {s.key: s for s in steps}
+    # Termux should use its packaged uv instead of building uv from PyPI.
+    assert by_key["uv"].command == "pkg install -y uv"
+    assert (
+        by_key["system_packages"].command == "pkg install -y rust clang ripgrep proot"
+    )
+    assert plan["profile"] == "android-termux-lean"
+
+
+def test_loaded_device_collapses_to_single_step(monkeypatch):
+    """When uv + native packages are present, only the install step remains."""
+
+    _patch_env(monkeypatch, is_android=True, is_termux=True)
+    steps, _ = bootstrap_wizard.build_steps(profile="auto")
+    assert [s.key for s in steps] == ["code_puppy"]
+
+
+def test_desktop_missing_uv_uses_curl_installer(monkeypatch):
+    _patch_env(monkeypatch, has_uv=False)
+    steps, _ = bootstrap_wizard.build_steps(profile="core")
+    uv_step = next(s for s in steps if s.key == "uv")
+    assert "astral.sh/uv/install.sh" in uv_step.command
+
+
+def test_dry_run_executes_nothing(monkeypatch, capsys):
+    _patch_env(monkeypatch, is_android=True, is_termux=True)
+
+    def _boom(_command):  # pragma: no cover - must never be called
+        raise AssertionError("dry-run must not execute commands")
+
+    monkeypatch.setattr(bootstrap_wizard, "_run_command", _boom)
+    code = bootstrap_wizard.run_wizard(profile="auto", dry_run=True)
+    out = capsys.readouterr().out
+    assert code == 0
+    assert "DRY-RUN" in out
+    assert "dry-run, not executed" in out
+
+
+def test_yes_runs_steps_and_verifies(monkeypatch, capsys):
+    _patch_env(
+        monkeypatch,
+        is_android=True,
+        is_termux=True,
+        has_ripgrep=False,
+        has_proot=False,
+        has_rust=False,
+        has_clang=False,
+    )
+
+    calls = []
+
+    def _fake_run(command):
+        calls.append(command)
+        return 0, "ok"
+
+    monkeypatch.setattr(bootstrap_wizard, "_run_command", _fake_run)
+    # Native packages still absent (so the step runs); code-puppy present after install.
+    monkeypatch.setattr(bootstrap_wizard, "_has", lambda b: b == "code-puppy")
+
+    code = bootstrap_wizard.run_wizard(profile="auto", assume_yes=True)
+    out = capsys.readouterr().out
+    assert code == 0
+    # system packages + code-puppy install + the verify --help call
+    assert any("pkg install -y rust clang ripgrep proot" in c for c in calls)
+    assert any("uv tool install" in c for c in calls)
+    assert "Verification: OK" in out
+
+
+def test_required_failure_stops_and_returns_one(monkeypatch, capsys):
+    _patch_env(
+        monkeypatch,
+        is_android=True,
+        is_termux=True,
+        has_ripgrep=False,
+        has_proot=False,
+        has_rust=False,
+        has_clang=False,
+    )
+
+    def _fail(_command):
+        return 1, "pkg: network unreachable"
+
+    monkeypatch.setattr(bootstrap_wizard, "_run_command", _fail)
+    code = bootstrap_wizard.run_wizard(profile="auto", assume_yes=True)
+    out = capsys.readouterr().out
+    assert code == 1
+    assert "FAILED" in out
+    assert "stopping" in out.lower()
+
+
+def test_verify_fails_when_binary_absent(monkeypatch):
+    _patch_env(monkeypatch)
+    monkeypatch.setattr(bootstrap_wizard, "_has", lambda _b: False)
+    outcome = bootstrap_wizard._verify({})
+    assert outcome.status == "failed"
+
+
+def test_cli_wizard_dry_run_via_main(capsys):
+    exit_code = bootstrap.main(["wizard", "--dry-run"])
+    assert exit_code == 0
+    assert "install wizard" in capsys.readouterr().out.lower()
diff --git a/tests/test_browser_optional.py b/tests/test_browser_optional.py
new file mode 100644
index 000000000..e759d4d8d
--- /dev/null
+++ b/tests/test_browser_optional.py
@@ -0,0 +1,45 @@
+"""Browser automation must be an optional capability.
+
+Playwright has no wheels for some platforms (e.g. Android/Termux), so it is an
+optional ``[browser]`` extra. Importing ``code_puppy.tools`` must not crash when
+Playwright is unavailable; browser tools should only fail when actually invoked.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+import textwrap
+
+
+def test_tools_import_without_playwright():
+    script = textwrap.dedent(
+        """
+        import sys
+
+        # Simulate a platform where Playwright is not installed.
+        sys.modules["playwright"] = None
+        sys.modules["playwright.async_api"] = None
+
+        # Must not raise even though Playwright is unavailable.
+        import code_puppy.tools  # noqa: F401
+        from code_puppy.tools.browser import browser_manager  # noqa: F401
+
+        # The stub keeps the module importable but inert.
+        from playwright.async_api import async_playwright
+
+        try:
+            async_playwright()
+        except RuntimeError:
+            print("OK")
+        else:
+            raise AssertionError("expected RuntimeError from stubbed async_playwright")
+        """
+    )
+    result = subprocess.run(
+        [sys.executable, "-c", script],
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode == 0, result.stderr
+    assert result.stdout.strip().splitlines()[-1] == "OK"
diff --git a/uv.lock b/uv.lock
index 4776a4596..37f441922 100644
--- a/uv.lock
+++ b/uv.lock
@@ -310,17 +310,14 @@ dependencies = [
     { name = "json-repair" },
     { name = "mcp" },
     { name = "openai" },
-    { name = "pillow" },
-    { name = "playwright" },
     { name = "prompt-toolkit" },
     { name = "pydantic" },
-    { name = "pydantic-ai-slim", extra = ["anthropic", "mcp", "openai"] },
+    { name = "pydantic-ai-slim", extra = ["anthropic", "mcp"] },
     { name = "pyfiglet" },
     { name = "python-dotenv" },
     { name = "rapidfuzz" },
     { name = "requests" },
     { name = "rich" },
-    { name = "ripgrep" },
     { name = "termflow-md" },
     { name = "typer" },
 ]
@@ -329,9 +326,18 @@ dependencies = [
 bedrock = [
     { name = "boto3" },
 ]
+browser = [
+    { name = "playwright" },
+]
 durable = [
     { name = "dbos" },
 ]
+images = [
+    { name = "pillow" },
+]
+search = [
+    { name = "ripgrep" },
+]
 
 [package.dev-dependencies]
 dev = [
@@ -353,21 +359,21 @@ requires-dist = [
     { name = "json-repair", specifier = ">=0.46.2" },
     { name = "mcp", specifier = ">=1.9.4" },
     { name = "openai", specifier = ">=1.99.1" },
-    { name = "pillow", specifier = ">=10.0.0" },
-    { name = "playwright", specifier = ">=1.40.0" },
+    { name = "pillow", marker = "extra == 'images'", specifier = ">=10.0.0" },
+    { name = "playwright", marker = "extra == 'browser'", specifier = ">=1.40.0" },
     { name = "prompt-toolkit", specifier = ">=3.0.52" },
     { name = "pydantic", specifier = ">=2.4.0" },
-    { name = "pydantic-ai-slim", extras = ["openai", "anthropic", "mcp"], specifier = "==1.56.0" },
+    { name = "pydantic-ai-slim", extras = ["anthropic", "mcp"], specifier = "==1.56.0" },
     { name = "pyfiglet", specifier = ">=0.8.post1" },
     { name = "python-dotenv", specifier = ">=1.0.0" },
     { name = "rapidfuzz", specifier = ">=3.13.0" },
     { name = "requests", specifier = ">=2.28.0" },
     { name = "rich", specifier = ">=13.4.2" },
-    { name = "ripgrep", specifier = "==14.1.0" },
+    { name = "ripgrep", marker = "extra == 'search'", specifier = "==14.1.0" },
     { name = "termflow-md", specifier = ">=0.1.11" },
     { name = "typer", specifier = ">=0.12.0" },
 ]
-provides-extras = ["bedrock", "durable"]
+provides-extras = ["bedrock", "browser", "durable", "images", "search"]
 
 [package.metadata.requires-dev]
 dev = [
@@ -1325,10 +1331,6 @@ anthropic = [
 mcp = [
     { name = "mcp" },
 ]
-openai = [
-    { name = "openai" },
-    { name = "tiktoken" },
-]
 
 [[package]]
 name = "pydantic-core"
@@ -1745,110 +1747,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" },
 ]
 
-[[package]]
-name = "regex"
-version = "2026.5.9"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/dc/0e/49aee608ad09480e7fd276898c99ec6192985fa331abe4eb3a986094490b/regex-2026.5.9.tar.gz", hash = "sha256:a8234aa23ec39894bfe4a3f1b85616a7032481964a13ac6fc9f10de4f6fca270", size = 416074, upload-time = "2026-05-09T23:15:19.37Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c2/dc/c1f2df4027e82fc54b5a473e4b250f5139faca49a0fbe29a48668d228f34/regex-2026.5.9-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ccf5249114cc3e772ecdd88a98a86eca0fd74c61ce32a94743758c083fc05d48", size = 489445, upload-time = "2026-05-09T23:12:06.111Z" },
-    { url = "https://files.pythonhosted.org/packages/03/d2/59f01110660081cce9c0bc30ebd0b5ee250dacf658e3248ed92f01e0e8ee/regex-2026.5.9-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:46f1326ca6e65b0879d23ca302c0f2415aad42ff0309b9c818e7949fe19a41d8", size = 291271, upload-time = "2026-05-09T23:12:07.731Z" },
-    { url = "https://files.pythonhosted.org/packages/58/b6/14b2c84ff90ddb370c81d27503f4a0fcf071496416f4855f6cc8c5d81c35/regex-2026.5.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ef31cbfe458e21c6122ba8150ff060e0c7789ed0d26eb423f25472584920b555", size = 289212, upload-time = "2026-05-09T23:12:09.266Z" },
-    { url = "https://files.pythonhosted.org/packages/03/d0/4db86529117320de0c84afd90e70bb47434625875e34fcef9d8c127c5b16/regex-2026.5.9-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:992604d02e6d9c6d786c24a706a71ecffe1020fc1ef264044474cd81fa2c3919", size = 792310, upload-time = "2026-05-09T23:12:11.416Z" },
-    { url = "https://files.pythonhosted.org/packages/07/78/fe4800cd322f862ecffd2d553409b20d80650e5ed71b9d178f853d020b82/regex-2026.5.9-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c9411dd64ca95477225734a93dfc8583b51916b8d5942f99d6cac21e09965451", size = 861721, upload-time = "2026-05-09T23:12:13.681Z" },
-    { url = "https://files.pythonhosted.org/packages/b5/d0/b3618a895dd8feb897c61bb2954edd265e1767d82a01d53065d5871127a3/regex-2026.5.9-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3dd4a3ff360dfb836fecdb93a4598f9d6e2ac81e3e397125145c6221bf58cf4c", size = 906460, upload-time = "2026-05-09T23:12:15.443Z" },
-    { url = "https://files.pythonhosted.org/packages/33/6f/1481597e859ef19508b345eec4afd1416ed6e6b459c75a64026ef193aecf/regex-2026.5.9-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2a661a7d270a61f7cf460caee8b9fa2d5ef9e5c681234bcb9e0fe14f488e7dfc", size = 799843, upload-time = "2026-05-09T23:12:16.892Z" },
-    { url = "https://files.pythonhosted.org/packages/73/59/955734c803f59108deccba3597ae440c76b62a652733c0006e6243758420/regex-2026.5.9-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f079e50a0d3cc3cd5091fa9ff45869a2e6b2cd35895731edafb0327901a8d86d", size = 773610, upload-time = "2026-05-09T23:12:19.127Z" },
-    { url = "https://files.pythonhosted.org/packages/68/8f/70c04a236d651c81881dac42ef8538bddda6121434509d0a22d9e601503b/regex-2026.5.9-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:4ebe8f0b5ec5a5024dc4a4c59f444c4e9afc5f2abdbb8962065b75d27fb971f9", size = 781645, upload-time = "2026-05-09T23:12:20.806Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/96/05c7434d88185e5d27fe54aeb74df86bd77cd79f52f0b4eae54faa8fea70/regex-2026.5.9-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:97cf3bc1b7d7d2306772ec07366c80d9df00ff79e79cea32898883a646d2fae2", size = 854473, upload-time = "2026-05-09T23:12:22.465Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/c1/6e3d8202d981f3117004bf341ee74893ba4ba8a9fbaf4b94615846550a08/regex-2026.5.9-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0f9eede6a5cbdc02d4978090186390936e1776a7d1359b21e41014c609880bcf", size = 763311, upload-time = "2026-05-09T23:12:24.351Z" },
-    { url = "https://files.pythonhosted.org/packages/93/c7/e7737f1526b3fb32bd4c337fd6c71c3ebb5c8296fc34d11197e0955d2e35/regex-2026.5.9-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:01f0f5f55f4b64dacec85dc116d3c05fd23ad3ff037bbc73a2085775953c2611", size = 844593, upload-time = "2026-05-09T23:12:26.341Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/27/0daffb1a535bb39f422c3d200f4ab023c71110ad66a32b366bee708baba0/regex-2026.5.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1268eddd8486dc561d08eee1156e40aa3a8fe10f4bdec8fa653b455fcbffd12c", size = 789167, upload-time = "2026-05-09T23:12:27.975Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/fc/294fe4fac4f2ed67207b17471815870c1c45b3a489e08e0ac96daea16ef6/regex-2026.5.9-cp311-cp311-win32.whl", hash = "sha256:8676474c07469d6f33dd1085ca2cd45f65785f32518f2b20e36d9953ca07f994", size = 266249, upload-time = "2026-05-09T23:12:30.141Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/b0/8dce459f6245bcf8f6e9f23ac9569f1a0f15c131cc0745e82b43226204cf/regex-2026.5.9-cp311-cp311-win_amd64.whl", hash = "sha256:246de9d60aa3f8538b519834dd95cbf276ea263d6a7bd5a3666dc3fa0230505b", size = 278423, upload-time = "2026-05-09T23:12:31.676Z" },
-    { url = "https://files.pythonhosted.org/packages/db/8d/f9aeff6ad63a3ef720386f2907e6d34a35a510a6e498ebad28b0fb3f6ab6/regex-2026.5.9-cp311-cp311-win_arm64.whl", hash = "sha256:d726ca3f0d76969bf1e8e477d160d3d666bbf999f6860bd314889e5345782046", size = 270420, upload-time = "2026-05-09T23:12:33.194Z" },
-    { url = "https://files.pythonhosted.org/packages/50/9b/6550044bc44e17c84d312c031c2ec42fbdb6a4ec4e29093be3a172d08772/regex-2026.5.9-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:57eeeb05db7979413dec5438f2db21d7ecbba787cde7a711df1a6f6df672aa06", size = 490451, upload-time = "2026-05-09T23:12:34.72Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/95/fc7ba4303b5a0f92446a12ee6778ef2c6c799233f5060042a31bf390cfe9/regex-2026.5.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:398c521292f4c7fb807001dcd54694d3a1fcafc179a36ad9cc56f98df85930b6", size = 292112, upload-time = "2026-05-09T23:12:36.285Z" },
-    { url = "https://files.pythonhosted.org/packages/54/4b/ee27938d1b2c443e89a9a10e00d2d19aa5ee300cd3d61140644e93bb083e/regex-2026.5.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f7a7c26137296beba7784de6eba69c6a93a63ccebc385e4962fe67e267a91225", size = 289599, upload-time = "2026-05-09T23:12:38.089Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/dd/ba103dc19614e25f3880800ca67ce093d6e21b325d72b8383c7bf906e9fa/regex-2026.5.9-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6441cc660d76107934a09c22167200839a0e89604a6297f78a974e66e931d2c0", size = 796732, upload-time = "2026-05-09T23:12:40.062Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/e7/f035b4fd858b050b0080bf302968dc0f59ba34e391872d54936758e6844e/regex-2026.5.9-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:91328f1c23d47595ca3ef0a7557fa129c5a23404b775c770697d2f35b33e0107", size = 865440, upload-time = "2026-05-09T23:12:42.059Z" },
-    { url = "https://files.pythonhosted.org/packages/0a/51/8cd301ecc899aea28124357f729f4272f44de7806fc7ca02490bfbe253e8/regex-2026.5.9-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:93a7860539414dddaefba2b40f8771765ae17949d4c7182b876ce429e11a8309", size = 912329, upload-time = "2026-05-09T23:12:44.373Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/1e/3fbe2fa1e8cebd62f3bb7d3321cff1640aca2e240b51d9bd624aad949260/regex-2026.5.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dd2810d22146b6d838acc5ec15602cb6b47920aa4e33015df3868eedfd20bab8", size = 801239, upload-time = "2026-05-09T23:12:46.268Z" },
-    { url = "https://files.pythonhosted.org/packages/17/2f/6f6008682bf2cf98040a0d3153a8e557b6ab728d7713d045cee4ce544ab8/regex-2026.5.9-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:daff2bdbaf1d23e52fdff7c0b7bc2048b68f978df6a4d107ac981f94caef2e66", size = 777054, upload-time = "2026-05-09T23:12:48.051Z" },
-    { url = "https://files.pythonhosted.org/packages/19/2b/eee0d20a6842ba04df4b8847a920b57ef56853f14ef85405473e586b605a/regex-2026.5.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4eeb011098fcb77af513dcef521a3dbecbf8849b1e38940759d293b7a93f5026", size = 785098, upload-time = "2026-05-09T23:12:49.851Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/98/6fc1e6410feefb92159edaed5041992bfe390e8d26c721865434acbca558/regex-2026.5.9-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:ea9c8ecfa1b73c73b626534d6626e5340d429630943672b8480724f44e84b962", size = 860095, upload-time = "2026-05-09T23:12:51.666Z" },
-    { url = "https://files.pythonhosted.org/packages/18/a3/bd855e0f2cb1a978ecf6fa6bb69632dd9c3f6ea3b81cde62fde14c9daec7/regex-2026.5.9-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:cd2846168eb9ee3c513902bc8225409cb1caab31d04728b145171fa1625d9621", size = 765762, upload-time = "2026-05-09T23:12:53.413Z" },
-    { url = "https://files.pythonhosted.org/packages/dc/66/0ae8c092e60b14c79d24f8e0b7f0aea5bfbffdcab00b5483d13404d3c3a5/regex-2026.5.9-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:39617fb0cde9c0e6306dc70e3bfc096f3da793219879f7ae7aa341a69fbdcf6d", size = 852100, upload-time = "2026-05-09T23:12:55.256Z" },
-    { url = "https://files.pythonhosted.org/packages/21/de/8dfde60fc1b21c946a893ba273403b72617edb261370cb1087099a83f088/regex-2026.5.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fd03c4f0e33280d15cae17159b899245d6b7c53d21def19b263b39655061f5ce", size = 789479, upload-time = "2026-05-09T23:12:57.573Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/1c/bdcc98f9a4af4fdd166c74941174619ccff4726d3ce32faa8e9a2ecd38dd/regex-2026.5.9-cp312-cp312-win32.whl", hash = "sha256:164eba9b755ea6f244b0d881196fbc1fac09714e9782c9e2732b813142033c8e", size = 266699, upload-time = "2026-05-09T23:12:59.14Z" },
-    { url = "https://files.pythonhosted.org/packages/78/87/240d36864f9e48ace85f72e79ced97ceb7f27ce87739a947dcb834b4e6bc/regex-2026.5.9-cp312-cp312-win_amd64.whl", hash = "sha256:86f40a5d6444db30a125c9c9177e6b25dad981cbc37451fd838f145e6edac92e", size = 277783, upload-time = "2026-05-09T23:13:00.789Z" },
-    { url = "https://files.pythonhosted.org/packages/4f/b5/7b30f312b0669dff5beebe5b0989dc2d1a312b1a44fab852199c387a5b96/regex-2026.5.9-cp312-cp312-win_arm64.whl", hash = "sha256:96f5f58b54a063d7ea9dca08e1cf57bfe10499c4d579ee672da284f57f5f0070", size = 270513, upload-time = "2026-05-09T23:13:02.426Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/da/797e91ecec6f84135da778ddce78c20e0af5d2a15c26f87a81bc3eadb6db/regex-2026.5.9-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:d626b84406444b165fc0ba981604edea39f0588ff1f92baa23fe50799ea9afdb", size = 490303, upload-time = "2026-05-09T23:13:04.382Z" },
-    { url = "https://files.pythonhosted.org/packages/44/da/bf30abaaa737b58f4a4b8c4a03659e02fd92092c822e0197ed9e0daab917/regex-2026.5.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d7bdc0ab8f3dd7e1b4f9ab88634e13374669db86bb3c72e8292f07ae313f539f", size = 292019, upload-time = "2026-05-09T23:13:06.022Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/e7/d0eaf5713828417b9e5648cf81fa9bacd4961f6ab98c380c2034f8716e35/regex-2026.5.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a8820737949116ffff55fe18f9fc644530063ba6ebfcb8314239416e78f1347c", size = 289468, upload-time = "2026-05-09T23:13:08.214Z" },
-    { url = "https://files.pythonhosted.org/packages/d3/9b/b3fdd62b003baa1a9b593cd8c8699c9651c2e80cc21a5c715707983c42d7/regex-2026.5.9-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa0fbdbac82cb3e4450d0ccde7d7a35607f4cb2dd9fba4b8b69bfaf8c9fa6aed", size = 796749, upload-time = "2026-05-09T23:13:10.573Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/30/66ab84588765f5b4b271a9ca09ef7ce2b87caa95176ec3d2ad65d7bc4902/regex-2026.5.9-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:57e8915c7986aa33d25e4d3629cef711cd2863f2961b10409f0c04cb8b7d9020", size = 865445, upload-time = "2026-05-09T23:13:12.523Z" },
-    { url = "https://files.pythonhosted.org/packages/1a/89/f05169e8588aac365f35ffc7f3bc3184f095ef4cfded7cfaa3c7fd5dbd89/regex-2026.5.9-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:508f56a89ba9cb26e4168cbc37dbd60a28d82430a9e18ad1d25fe0883c314ca2", size = 912322, upload-time = "2026-05-09T23:13:14.281Z" },
-    { url = "https://files.pythonhosted.org/packages/30/e1/c93444052cf41581f3c884ab3fb5823daf0992f11cd4388d4275ca610558/regex-2026.5.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b6d189041f15691cfa2b6c4290448ec221244d225b3f5fe9e7771b34ffcdf6e2", size = 801269, upload-time = "2026-05-09T23:13:16.569Z" },
-    { url = "https://files.pythonhosted.org/packages/50/fe/0cf96b882f540e62e8b9956599798203d599c44cf4c77917ca27400ff69b/regex-2026.5.9-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e82db382b44d0111b22601c509c89f64434816c9e0eef9d1989cda8cc6ff1c04", size = 777085, upload-time = "2026-05-09T23:13:18.675Z" },
-    { url = "https://files.pythonhosted.org/packages/23/5c/d78d4924e7fc875557b9e9b768423925fdfaac5549d06da7810019a9bd26/regex-2026.5.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2acfb48634f64996b57f90f39afa692ff362162722581921fe92239a59960f3c", size = 785153, upload-time = "2026-05-09T23:13:20.525Z" },
-    { url = "https://files.pythonhosted.org/packages/bf/e0/5214774090e7b4524dcea3e3c4aa74141d43043f8beb49c1599db1c8b53a/regex-2026.5.9-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:d29eebfc9525db68cad3c97eedd7f754fa265aa5cd0cf4f863b2421e1b48fc9f", size = 860164, upload-time = "2026-05-09T23:13:22.263Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/e1/4a57a83350319b1271f0d7a249b8672513ed928b237a741631270de6caea/regex-2026.5.9-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:debb893095e944091c16e641a6e33c1b0f4cb61ab945ec5afbf53ce7068834d8", size = 765731, upload-time = "2026-05-09T23:13:24.277Z" },
-    { url = "https://files.pythonhosted.org/packages/12/f4/499e74a20c156fc75836ee04a72a38d1a063978f600937f9760467beb1b0/regex-2026.5.9-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:d659eee77986549c9ea45b861c7567e44d6287c3dc9a4565478853f7b9fe2ff6", size = 852062, upload-time = "2026-05-09T23:13:26.125Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/92/7eebc0d0a01e78629695f342ba17e0deaff8fb45e79cc0d7b98287da6e3e/regex-2026.5.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2efa205e6d98b24d1f3ab395c11aa15cdf10935bca283d0285e0499c284fba21", size = 789577, upload-time = "2026-05-09T23:13:27.814Z" },
-    { url = "https://files.pythonhosted.org/packages/05/a4/018e71f7d2ad48c1ebe6d3ae0026f9b7cb4802fd15c7cc02fdf724355102/regex-2026.5.9-cp313-cp313-win32.whl", hash = "sha256:f3844f134e834076677dd369976e9f5068679fcb8e50102fdf6b7ac96a3ec127", size = 266691, upload-time = "2026-05-09T23:13:29.549Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/1d/861a93719fb9ee7dbfc3761b3797b7a3e112a5d42c6129459d2d741be9b5/regex-2026.5.9-cp313-cp313-win_amd64.whl", hash = "sha256:3527bb4942d2c14552155406cdedd906567456821848aed1cb4933a391bf5eca", size = 277747, upload-time = "2026-05-09T23:13:31.859Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/c6/0a2436ae4da1ba76e51cb98943c6838a9a721faa40ebe2dce07694ae34e3/regex-2026.5.9-cp313-cp313-win_arm64.whl", hash = "sha256:56a33f191f17d8c417f99945ebdc1e691d3af9605d86ec68c7e54a57e3e17af6", size = 270500, upload-time = "2026-05-09T23:13:33.525Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/e9/d21346f7b60ed58789371358ed66b09d00f832e1bd7c06e55d9da5679882/regex-2026.5.9-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:01f28d868834624c934b8d2e0aa1c8341337e37831f4a012f18a5afcba4cbaf3", size = 494172, upload-time = "2026-05-09T23:13:35.935Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/43/fd1177a2032037c681baecdb3422ee4e1424aec4e4f470ef47793d325274/regex-2026.5.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:48036f6374aaa79eb3b754ec29c61d1c6b1606749d705a13f8854fa2539671f6", size = 293952, upload-time = "2026-05-09T23:13:38.307Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/7d/9fbf919768368d3f8a4f6c692cf2aa61e482b2b81ec6a298ace4cbf02480/regex-2026.5.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b96350aa424e79d4fd6b567b344dcbe2b2d6bfc48dfe7717587e1fa6d43da6ff", size = 292314, upload-time = "2026-05-09T23:13:40.353Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/6c/e41bfeecb589716843e7c4df09ba46ff2a42961457afece19059d85caeef/regex-2026.5.9-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f3af7a4903c5c04a11a196a5aa75cdd7dd3f8508132f9fb3259d9f5908e3b88", size = 811681, upload-time = "2026-05-09T23:13:42.543Z" },
-    { url = "https://files.pythonhosted.org/packages/87/83/a5c1c525fba0aa656e88ad0face0b1829788ef4c2fb6b26df58aa1151b84/regex-2026.5.9-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7e87577720152d2caae19fe2baaf1f8d5ca12091e9e229f03915c37d1e4b9178", size = 871135, upload-time = "2026-05-09T23:13:44.326Z" },
-    { url = "https://files.pythonhosted.org/packages/18/d4/80882e799e440dd878b0979cbebf8fa4d54624a332c83037c7a701649e3f/regex-2026.5.9-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c8b9b9d294cfea3cd19c718ade7cc93492b2c4991abd9a68d0b3477ae6d8e100", size = 917265, upload-time = "2026-05-09T23:13:47.295Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/ff/8db60211e2286e396aad7dc7725356c502bff0901ea05bd6cdc2e1a042b9/regex-2026.5.9-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:728d8bfd28a8845c8b6bc5dc7ce010453d206396786c0765c2740cb65f37791e", size = 816311, upload-time = "2026-05-09T23:13:49.885Z" },
-    { url = "https://files.pythonhosted.org/packages/4c/47/742ef579c61730f8d268e5cf1f9ce0e37e2ea041ad0f5644724f2378e463/regex-2026.5.9-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7e30b874d341fac767d7df5a0870540541c2c054b80cfaac116e8d367a8a7ff2", size = 785498, upload-time = "2026-05-09T23:13:52.25Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/ab/cb0999802dcb0fb95b1ab005e8d4163d8afdd67efc2cb6b6630ac13f8cb1/regex-2026.5.9-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:fd190e88a895a8901325fad284a3f74ea52b1da8525b76cc811fa9b1edf0ce2b", size = 801348, upload-time = "2026-05-09T23:13:54.127Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/62/8ca59a24c55bc34d166eefaf3717bd77772f329fdbf984d86581e0a3571c/regex-2026.5.9-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:8e76e8161ad00694cfce6767d5dea860c6391ac5b83e5c3a39661e696f11fc7e", size = 866493, upload-time = "2026-05-09T23:13:56.067Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/3d/30f2ae62cef3278bb5bb821f467277a55fb73f01032cf85997e15e8289a8/regex-2026.5.9-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ddda5340e6c01a293027dd46232fa79eaff1b48058ce7a98f572b6445b088041", size = 772811, upload-time = "2026-05-09T23:13:57.867Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/ae/7d2089bcd78ad0c0161bc684339df50032acb438a7bd3305e7ddb1193cec/regex-2026.5.9-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:205109e96b3cf5adf8f4cd62bedde9487feb282b9497a3535451e5a24cd706a0", size = 856584, upload-time = "2026-05-09T23:13:59.679Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/29/92ff47f75990131ea4f24ba17819e5a9d141e10819807e09addd73409af6/regex-2026.5.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dfbe4579b9f08036aa7d101d1835437a20783574ac66327e6b29b4018a138081", size = 803453, upload-time = "2026-05-09T23:14:01.978Z" },
-    { url = "https://files.pythonhosted.org/packages/04/99/eff29f1037dcab36702c9ee5d6858cf1ce2336ea8ea2987f64245b99ea5e/regex-2026.5.9-cp313-cp313t-win32.whl", hash = "sha256:ed2c9e8068b614c574d8d30e543d617cf5379b0535d46f97ef00e904745a08b5", size = 269951, upload-time = "2026-05-09T23:14:03.661Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/9d/8870b8981d27b22cda77bb26a5ac7ebfa9c7d9e0dea195a834a82380e748/regex-2026.5.9-cp313-cp313t-win_amd64.whl", hash = "sha256:b46b0f094dc1d3b90356c85a0bd2c9bafc4a6a190b9d6f8ddd5a033b6e088ed4", size = 281240, upload-time = "2026-05-09T23:14:05.56Z" },
-    { url = "https://files.pythonhosted.org/packages/72/b1/3379415e8f135c13ac551353397cc4fe97b4978f3cac73c5fcbcded548b8/regex-2026.5.9-cp313-cp313t-win_arm64.whl", hash = "sha256:872acc074bd29ffc9913ecdfedf6ea77502312ca44a4aa0d3779089c6069d8de", size = 272383, upload-time = "2026-05-09T23:14:07.843Z" },
-    { url = "https://files.pythonhosted.org/packages/13/3e/9c3cd292d8808b3645a2ce517e200179b6d0e903f176300bd8b542e14de5/regex-2026.5.9-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:1bd7587a2948b4085195d5a3374eaf4a425dc3e55784c038175355ecf3bbbf8a", size = 490376, upload-time = "2026-05-09T23:14:09.64Z" },
-    { url = "https://files.pythonhosted.org/packages/60/70/d43ee8a2ca0a8b68d167f21658b85520ac0574617c7f320367c5047f7556/regex-2026.5.9-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:dea2e88e1cce4522496cce630e11e67b98b7076620bc4336c3f674bc21a375f4", size = 291964, upload-time = "2026-05-09T23:14:11.424Z" },
-    { url = "https://files.pythonhosted.org/packages/21/91/9d50b433828d8e74196904e168a43abf1e6e88b2a15d47ed742456720c37/regex-2026.5.9-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2099f7e7ff7b6aa3192312650a56e91cc091e49d50b04e4f6f8b6e28b3b27f1c", size = 289682, upload-time = "2026-05-09T23:14:13.123Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/d2/b835e3cafbb9d977736912436259ff551d60919f7d7b3d37d46659c63564/regex-2026.5.9-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ecd353045824e4477562a2ac718c25799cdaaa41f7aa925a806a8a3e6848a5b9", size = 796996, upload-time = "2026-05-09T23:14:14.923Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/a6/9f992d00019166b9de01c546dd4549bc679f2a68df11b877740b0760b7c2/regex-2026.5.9-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:65c8c8c37377794bd5b2f3ebe51919042bf17aec802e23c833d89782ed0c78af", size = 866089, upload-time = "2026-05-09T23:14:17.757Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/08/4d32af657e049b19cb62b02e46e38fe1518797bfb2203ee93a510b21b0dc/regex-2026.5.9-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5b73ab8afcf66c622db143d1c6fda4e58e4d537ee4f125229ad47b1ab80f34c0", size = 911530, upload-time = "2026-05-09T23:14:20.353Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/27/2af43dd1dc201d1fecefda64a45f4ad0995855b92724f795a777b402ee69/regex-2026.5.9-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0de5cf193997384ed2ca6f1cd4f78055b255d93d82d5a8cd6ba0d11c10b167e4", size = 800643, upload-time = "2026-05-09T23:14:22.265Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/dd/23a249047013b5321d4a60c4d2437462086f601b061776a525e5fba2a59f/regex-2026.5.9-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d641a8c9a61618047796d572a39a79b26167b0411d2c3031937b2fe2d081e2cf", size = 777223, upload-time = "2026-05-09T23:14:24.179Z" },
-    { url = "https://files.pythonhosted.org/packages/94/6a/e85ed9538cd19586d0465076a4578a12e093ce776d15f3f8ce92733a8dd6/regex-2026.5.9-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:24b2355ef5cc9aa5b8f07d17704face1c166fdcc2290fa7bd6e6c925655a8346", size = 785760, upload-time = "2026-05-09T23:14:26.065Z" },
-    { url = "https://files.pythonhosted.org/packages/2a/c4/f25473209438638e947c55f9156fd8f236f74169229028cc99116380868e/regex-2026.5.9-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:a24852d3c29ad9e47593593d8a247c44ccc3d0548ef12c822d6ed0810affe676", size = 860891, upload-time = "2026-05-09T23:14:28.17Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/f7/f4f86e3c74419c37370e91f150ae0c2ef7d34b2e0e4cdd5da046a02e4022/regex-2026.5.9-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:916714069da19329ef7de197dcbc77bb3104145c7c2c864dbfbe318f46b88b14", size = 765891, upload-time = "2026-05-09T23:14:30.06Z" },
-    { url = "https://files.pythonhosted.org/packages/26/70/704d8e13765939146b1cd0ef4e2feb71d7929727d2290f026eed10095955/regex-2026.5.9-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:fa411799ca8da32a8d38d020a88faa5b6f91657d284761352940ecf9f7c3bbdd", size = 851380, upload-time = "2026-05-09T23:14:32.123Z" },
-    { url = "https://files.pythonhosted.org/packages/26/29/1a13582a8460038edc38e49f64ceb0dd7c60f5caba77571f4bf6601965d9/regex-2026.5.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1e6da47d679b7010ef27556b6e0f99771b744936db1792a10ceac6547ae1503e", size = 789350, upload-time = "2026-05-09T23:14:34.799Z" },
-    { url = "https://files.pythonhosted.org/packages/73/56/3dcafe34fc72e271d62ad9a291801e88a1457bb251c132f15fcc2e5aad1a/regex-2026.5.9-cp314-cp314-win32.whl", hash = "sha256:98bd73080e8756255137e1bd3f3f00295bbc5aa383c0e0f973920e9134d7c4ad", size = 272130, upload-time = "2026-05-09T23:14:36.729Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/9c/02eebf0be95efe416c664db7fb8b6b05b7a0b06a7544f2884f2558b0526f/regex-2026.5.9-cp314-cp314-win_amd64.whl", hash = "sha256:ff8d372ac2acdc048d1c19916f27ee61bc5722728458ba6ca5052f2c72d51763", size = 280999, upload-time = "2026-05-09T23:14:39.126Z" },
-    { url = "https://files.pythonhosted.org/packages/70/5a/1dd1abee76cb7a846a0bcf42fdc87e5720c3c33c24f3e37814310a513d9f/regex-2026.5.9-cp314-cp314-win_arm64.whl", hash = "sha256:e1d93bf647916292e8edcec150c07ddf3dc50179ccaf770c04a7f9e452155372", size = 273500, upload-time = "2026-05-09T23:14:41.059Z" },
-    { url = "https://files.pythonhosted.org/packages/86/c1/c5f619b0057a7965cb78ec559c1d7a45ce8c99a35bea95483d64959a93d9/regex-2026.5.9-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:83d0ee4a57d1c87cb549e195ec300b8f0ec3a82eba66d835e4e2ed8634fe4499", size = 494269, upload-time = "2026-05-09T23:14:42.869Z" },
-    { url = "https://files.pythonhosted.org/packages/05/2c/5d01f1aee33de4bbe60c8452945bfc8477ca7c5ae4450f6bfe711036cb36/regex-2026.5.9-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:d3d7eb5c9a7f6df82ed3cfac9beb93882a5cbcb5b8b157b56cb2b3b276574ac1", size = 293954, upload-time = "2026-05-09T23:14:44.822Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/fe/e8988b2ae2108c6ef71bd4aa8d87fbe257976dd0810e826cd75f701c68b6/regex-2026.5.9-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:075160bf16658e16d35233300b8453aac25de4cbea808d22348b6979668e924d", size = 292405, upload-time = "2026-05-09T23:14:47.211Z" },
-    { url = "https://files.pythonhosted.org/packages/79/34/d2b0937faa7859263f7f0a3c6b103a1296306be6952dc173d0154e9a2f49/regex-2026.5.9-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:45375819235558a4ff1c4971dc32881f022613abdb180128f5cb4768c1765a1c", size = 811855, upload-time = "2026-05-09T23:14:49.21Z" },
-    { url = "https://files.pythonhosted.org/packages/80/fe/daf53a47457a8486db66c66c01ceb9c2303eecee3f87197f1e77eb1a736d/regex-2026.5.9-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ead4b163ac30a29574510cd4b3e2e985ac5290c05fc7095557d6a5f403fc31b5", size = 871189, upload-time = "2026-05-09T23:14:51.555Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/75/058fc4470cbfbf57d800aff1a0022b929a3f9fa553ee10a0cdf2070eb31f/regex-2026.5.9-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8c6e4218fbdfbcd4f6c19efca40930d24a621bf4b48cb76bc6640543bd28ef20", size = 917485, upload-time = "2026-05-09T23:14:53.633Z" },
-    { url = "https://files.pythonhosted.org/packages/88/e7/179cfda3a28bc843b5c6cfe7f79f23489c791ed95f151083803660878432/regex-2026.5.9-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6351571c8a42b505eb555c0dc47d740d0fb66977dc142919eea6f4325b7c56a0", size = 816369, upload-time = "2026-05-09T23:14:56.198Z" },
-    { url = "https://files.pythonhosted.org/packages/41/90/6f0cc422071688266d344fca8462d787cba0a2c144acb25721f9a61ec265/regex-2026.5.9-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:002205cafd2a9e78c6290c7d1df277bf3277b3b7a30e0b4bb0dac2e2e3f7cb2d", size = 785869, upload-time = "2026-05-09T23:14:58.602Z" },
-    { url = "https://files.pythonhosted.org/packages/02/67/a31f1760f09c27b251ef39e9beb541f462cf977381d067faa764c2c0e393/regex-2026.5.9-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8abd33fef90b2a9efac5557d6033ca82d1195ed3a15fea5af15ba7b463c6a63b", size = 801427, upload-time = "2026-05-09T23:15:00.642Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/c4/1a80654597b6bc1e1ea0494824c31200e8a956abe290afae9b19a166a148/regex-2026.5.9-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:31037c82eccb44b7ea2e9e221d7c01429430e989a1f4b91ea5a855f6017b509a", size = 866482, upload-time = "2026-05-09T23:15:03.384Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/11/960724e06482c08466ff5611e242e86f80062949cdf6b4b9cc317b9dd93d/regex-2026.5.9-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:5604dfd046dc37eca90250fc3be938b076c8059fa772ac0ed6f499b0f0fb0415", size = 773022, upload-time = "2026-05-09T23:15:05.625Z" },
-    { url = "https://files.pythonhosted.org/packages/50/a8/a9979c3e7918280e93159ebcab5ef1a65116dd4f3bd6091be0eae4a126e8/regex-2026.5.9-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0e1b1b4e496afbb24f4a62aba855ee4f88f25578927697b340702e48c9ee6bc2", size = 856642, upload-time = "2026-05-09T23:15:07.966Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/d4/a9b732f2f0072c0ab12227483abb24fffcb9f73f8a2b203df0a6d0434735/regex-2026.5.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:be3372b9df6ddecff6486d37e19095a7b4973137caf5512407a89f4455361f41", size = 803552, upload-time = "2026-05-09T23:15:10.215Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/fe/1b3113817447a1d4155e4ac76d2e072f42c0bcba2f43fa8a0e756ea2cd91/regex-2026.5.9-cp314-cp314t-win32.whl", hash = "sha256:3ddd90103f9e5c471c49c7852ecc1fe27c7e45eb99e977aefe7caa4e779f4f58", size = 275746, upload-time = "2026-05-09T23:15:12.609Z" },
-    { url = "https://files.pythonhosted.org/packages/92/73/93d42045302636c91f2e5ef588b65b84b01428f28ec77de256b1dfdfbe5c/regex-2026.5.9-cp314-cp314t-win_amd64.whl", hash = "sha256:ca518ed29c46eecba6010b15f1b9a479314d2de409536e71b6a13aa04e3b8a77", size = 285685, upload-time = "2026-05-09T23:15:15.086Z" },
-    { url = "https://files.pythonhosted.org/packages/da/80/35b4c33c804a165a7f55289afda3ea9e3eb6d15800341a2d66455c0f1f30/regex-2026.5.9-cp314-cp314t-win_arm64.whl", hash = "sha256:5e41809d2683fcde7d5a8c87a6567ba1fb1ce0de9f31bff578de00a4b2d76daa", size = 275713, upload-time = "2026-05-09T23:15:16.98Z" },
-]
-
 [[package]]
 name = "requests"
 version = "2.34.2"
@@ -2168,60 +2066,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/15/49/0fa8324879351c59ceb169f443c578fd6f8272ee3e71268f0b9140589614/termflow_md-0.1.11-py3-none-any.whl", hash = "sha256:4fd6f375b4a06aa06987dfc80d2910fed2b27e9576c50d49c7f3903c67195b2a", size = 58710, upload-time = "2026-04-18T17:05:23.738Z" },
 ]
 
-[[package]]
-name = "tiktoken"
-version = "0.13.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "regex" },
-    { name = "requests" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/e4/e5/5f3cb2159769d0f4324c0e9e87f9de3c4b1cd45848a96b2eb3566ad5ca77/tiktoken-0.13.0.tar.gz", hash = "sha256:c9435714c3a84c2319499de9a300c0e604449dd0799ff246458b3bb6a7f433c1", size = 38986, upload-time = "2026-05-15T04:51:27.153Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/1a/4c/1bc81f4cd53e827c4ee67ca951b5935724716049452d8dfa09b8b82372bb/tiktoken-0.13.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:7bfe1849caa65d1e1d9871817170ec497bbb7984e182012e1bdce72f66608cdb", size = 1036353, upload-time = "2026-05-15T04:50:21.757Z" },
-    { url = "https://files.pythonhosted.org/packages/75/91/10b9c7076bc02c246c853201fdbbe300a4b8c5ed7b84c25f7403f4e32655/tiktoken-0.13.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:91c180fe255bd5a86d8316210d2833a1d4d33d026cd86a67812f4773743c8d26", size = 984644, upload-time = "2026-05-15T04:50:23.256Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/e4/fceae98015fab47fcd49b8bd7f46145bcd187a47e0add1e5378ed67ef980/tiktoken-0.13.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:059c8ecf554eb5b41e6e054ba467b871b03277d267dee7244380aca4359747d4", size = 1119261, upload-time = "2026-05-15T04:50:24.348Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/39/fe42ad00de01a8c4a49ad8649a2c8a316835a9cad5961b11d21eac0020a5/tiktoken-0.13.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:36217497eaffc158607a3b26f065300db2aefd43b115263f3b9688ce38146173", size = 1138253, upload-time = "2026-05-15T04:50:25.505Z" },
-    { url = "https://files.pythonhosted.org/packages/03/c4/ccee1ecccca107e9a16efcecdeeb964c325305038554d466ece65b42338f/tiktoken-0.13.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:303f7d91b4fce3baddbcde05c139091d4caa5026ac7214c1dc7ff7a71ee429ff", size = 1185747, upload-time = "2026-05-15T04:50:27.02Z" },
-    { url = "https://files.pythonhosted.org/packages/9d/03/cd0cba295522b91eb55c6b2704f1df895f8226cfe60ab10d4d51d0cc9e69/tiktoken-0.13.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5d48843bee149630eb735a99e1f4a85b47308d21868ea63163f6e87768d3cfed", size = 1241265, upload-time = "2026-05-15T04:50:28.815Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/25/a10efd564402d82c2ff50d12057353ace447aa8007deceaa48641f63d35c/tiktoken-0.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:fc1c44cd37b43fc46bae593129164f4f281e82ea116b57a85aa81bda57eafc94", size = 876509, upload-time = "2026-05-15T04:50:30.026Z" },
-    { url = "https://files.pythonhosted.org/packages/85/8e/144bde4e01df66b34bb865557c7cd754ed08b036217ebd79c9db5e9048a9/tiktoken-0.13.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:32ac870a806cfb260a02d0cb70426aef02e038297f8ad50df5040bb5af360791", size = 1034888, upload-time = "2026-05-15T04:50:31.579Z" },
-    { url = "https://files.pythonhosted.org/packages/36/18/d4ac9d20956cdebca04841316660ed584c2fecdc2b81722a28bc7ad3b1e4/tiktoken-0.13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4d9980f11429ed2d737c463bb1fb78cf330caa026adf002f714aced7849a687b", size = 982970, upload-time = "2026-05-15T04:50:32.961Z" },
-    { url = "https://files.pythonhosted.org/packages/74/ed/6bb8d05b9f731f749fee5c6f5ca63e981143c826a5985877330507bd13b7/tiktoken-0.13.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:3f277ebea5edd7b8bf03c6f9431e1d67d517530115572b2dc1d465326e8f88c7", size = 1115741, upload-time = "2026-05-15T04:50:34.475Z" },
-    { url = "https://files.pythonhosted.org/packages/34/de/2ca96b07a82d972b74fe4b46de055b79c904e45c7eab699354a0bfa697dc/tiktoken-0.13.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:a116178fa7e1b4065bff05214360373a65cac22f965be7b3f73d00a0dbfe7649", size = 1136523, upload-time = "2026-05-15T04:50:35.782Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/dc/9dafec002c2d4424378563cf4cf5c7fb93631d2a55013c8b87554ee4012c/tiktoken-0.13.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2c397ddda233208345b01bd30f2fca79ff730e55731d0108a603f9bc57f6af3b", size = 1181954, upload-time = "2026-05-15T04:50:36.99Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/d0/1f8578c45b2f24759b46f0b50d31878c63c73e6bf0f2227e10ec5c5408dc/tiktoken-0.13.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:95097e4f89b06403976e498abf61a0ee73a7497e73fb599cb211d8197a054d91", size = 1240069, upload-time = "2026-05-15T04:50:38.221Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/90/28d7f154888610aa9237e541986beb62b479df29d193a5a0617dbb1514d0/tiktoken-0.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:8f2d16e7a7c783ad81f36e457d046d1f1c8af70b22aec8a13238efe531977c41", size = 874748, upload-time = "2026-05-15T04:50:39.587Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/83/b096c859c2a47c11731bf2f5885f4028b809dfe2396582883eed9cae372f/tiktoken-0.13.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5df5d1507bd245f1ccad4a074698240021239e455eb0bb4ced4e3d7181872154", size = 1034228, upload-time = "2026-05-15T04:50:40.988Z" },
-    { url = "https://files.pythonhosted.org/packages/53/61/c68e123b6d753e3fc2751e9b18e732c9d8bf1e1926762e736eee935d931c/tiktoken-0.13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8fe806a50664e83a6ffd56cbd1e4f5dcc6cd32a3e7538f70dc38b1a271384545", size = 982978, upload-time = "2026-05-15T04:50:42.195Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/8b/96cc178cc584e65d363134500f297790b06cd48cdeb1e8fcf7bbe60f4715/tiktoken-0.13.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:125bc05005e747f993a83dc67934249932d6e4209854452cd4c0b1d53fba3ba2", size = 1116355, upload-time = "2026-05-15T04:50:43.564Z" },
-    { url = "https://files.pythonhosted.org/packages/86/f5/bab735d2c72ea55404b295d02d092644eb5f7cc6205e34d35eb9abfb9ab2/tiktoken-0.13.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:5e6358911cab4adee6712da27d65573496a4f68cf8a2b5fca6a4ad10fc5748cf", size = 1135772, upload-time = "2026-05-15T04:50:44.782Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/b9/6de04ebdf904edfaad87788011b3735087a0c9ea671b9027e1e4e965e8c8/tiktoken-0.13.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:975cbd78d085d75d26b59660e262736dcaed1e35f8f142cd6291025c01d25486", size = 1182415, upload-time = "2026-05-15T04:50:46.422Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/9c/470a05f3b1caf038f44880e334d47ab674e0c80d514c66b375d14d5afa10/tiktoken-0.13.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:75ab9bc99fa020a4c283424590ecd7f3afd70c1c281cb3fa3192a6c3af9f9615", size = 1239879, upload-time = "2026-05-15T04:50:48.052Z" },
-    { url = "https://files.pythonhosted.org/packages/42/a6/c1936d16055436cb32e6c6128d68629622e00f4768562f55653752d34768/tiktoken-0.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:6b1615f0ff71953d19729ceb18865429c185b0a23c5353f1bbca34a394bf60f7", size = 874829, upload-time = "2026-05-15T04:50:49.202Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/07/acb5992c3772b5a36284f742cfb7a5895aa4471d1848ac31464ad50d7fdf/tiktoken-0.13.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:6eb4a5bfbc6426938026b1a334e898ac53541360d62d8c689870160cc80abd67", size = 1033600, upload-time = "2026-05-15T04:50:50.4Z" },
-    { url = "https://files.pythonhosted.org/packages/14/e9/742e9aec30f59b9f161f7ff7cd072e02ea836c9e1c0854a8076dfcd40d5c/tiktoken-0.13.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:43cee3e5400573b2046fbf092cc7a5bc30164f9e4c95ce20714da929df48737a", size = 982516, upload-time = "2026-05-15T04:50:52.03Z" },
-    { url = "https://files.pythonhosted.org/packages/72/74/ca1541b053e7648254d2e4b42a253e1bb4359f2c91a0a8d49228c794e1a0/tiktoken-0.13.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:7de52e3f566d19b3b11bd37eea552c6c305ad74081f736882bd44d148ed4c48d", size = 1115518, upload-time = "2026-05-15T04:50:53.543Z" },
-    { url = "https://files.pythonhosted.org/packages/46/e3/93825eaf5a4a504795b787e5d5dea07fbeb3dabf97aa7b450be8bde59c89/tiktoken-0.13.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:51384448aa508e4df84c0f7c1dc3211c7f7b8096325660ee5fc82f3e11b381ce", size = 1136867, upload-time = "2026-05-15T04:50:55.191Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/46/002b68de6827091d5ae90b048f326e8aad8d953520950e5ce1508879414f/tiktoken-0.13.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e28157350f7ebf35008dd8e9e0fdb621f976e4230c881099c85e8cf07eaa50e2", size = 1181826, upload-time = "2026-05-15T04:50:56.296Z" },
-    { url = "https://files.pythonhosted.org/packages/db/c6/d393e3185a276505182f7abd93fe714f3c444a2be9180798fa052347504e/tiktoken-0.13.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:165cf1820ea4a354985c2490a5205d4cc74661c934aca79dd0368232fff94e0f", size = 1239489, upload-time = "2026-05-15T04:50:57.918Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/4d/bc07d1f1635d4897a202acc0ae11c2886eaa7325c359ba4741b47bf8e225/tiktoken-0.13.0-cp313-cp313t-win_amd64.whl", hash = "sha256:6c43a675ca14f6f2749ba7f12075d37456015a24b859f2517b9beb4ef30807ec", size = 873820, upload-time = "2026-05-15T04:50:59.528Z" },
-    { url = "https://files.pythonhosted.org/packages/8c/93/0dd6adca026a616c3a92974566b43381eea4b475ce1f36c062b8271a9ac5/tiktoken-0.13.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaaaef47c2406277181d2086484c317bf7fc433e2d5d03ff94f56b0dcec87471", size = 1034977, upload-time = "2026-05-15T04:51:00.957Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/77/5ec6e6bc5b30bed6d93f7f2162d8f6b32437b3ba27cb527cfe004f6109c9/tiktoken-0.13.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ca8b310bd93b3772cb1b7922d915446864860f562bdfe4825c63a0aed3fb28cd", size = 983635, upload-time = "2026-05-15T04:51:02.629Z" },
-    { url = "https://files.pythonhosted.org/packages/94/b0/c8ae9aff00d625c50659b4513e707a0462c4bf5d4d6cc1b802103225c02e/tiktoken-0.13.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:32e0c12305105002c047b3bb1070b0dd9a73b0cb3b2856a8972b810e7a4f5881", size = 1116036, upload-time = "2026-05-15T04:51:04.082Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/ac/6a5dddd1d0a6018ecb389bd0353e6b4a515eb4d2286611bd0ace1937b9e1/tiktoken-0.13.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:5ba5fd62507a932d1241346179e3b39bc7bf7408f03c272652d93b3bedf5db24", size = 1135544, upload-time = "2026-05-15T04:51:05.229Z" },
-    { url = "https://files.pythonhosted.org/packages/f4/b8/585032b4384b2f7dcdaddcb52865c83a701a420d09e3c2b4a2be1c450c57/tiktoken-0.13.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d108bc2d470fc53c8ecd24f2c0fd2b5f98c33e87cdb6aa2e9b8c5dced703d273", size = 1182217, upload-time = "2026-05-15T04:51:06.517Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/b6/993ff1ded3958215fd341a847b8e5ffeb5de473f435296870d314fc91ac4/tiktoken-0.13.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:cb99cb5127449f58d0a2d5f5ccfb390d8dbdfd919c221246caaee29d8725ed51", size = 1239404, upload-time = "2026-05-15T04:51:07.843Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/3d/fef7e06e3b33e7538db0ced734cf9fe23b6832d2ac4990c119c377aec55e/tiktoken-0.13.0-cp314-cp314-win_amd64.whl", hash = "sha256:115c4f26ffa11caac8b54eea35c2ad38c612c20a48d35dd15d70a02ac6f51f58", size = 918686, upload-time = "2026-05-15T04:51:08.925Z" },
-    { url = "https://files.pythonhosted.org/packages/c1/82/a7fc44582bc32ab00de988a2299bf77c077f59068b233109e34b7d6ca7e6/tiktoken-0.13.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:472527e9132952f2fbf77cd290658bacf003d4d5a3fabc18e5fbd407cbae4d9b", size = 1034454, upload-time = "2026-05-15T04:51:10.035Z" },
-    { url = "https://files.pythonhosted.org/packages/37/d0/24d8a890c14f432a05cea669c17bebeaa99f96a7c79523b590f564246411/tiktoken-0.13.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:4e2f67d27c9626cdd25fe33d9313c5cdb3d8d82da646b68d6eb8e7e9c20e6448", size = 982976, upload-time = "2026-05-15T04:51:11.23Z" },
-    { url = "https://files.pythonhosted.org/packages/49/b7/2ab43f62788a9266187a9bfc1d3af99ad83e5eaa25fbef168a69cd5ad14f/tiktoken-0.13.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:2b920b35805cd64585a37c3dc7ce65fba4d2d36016be01e1d7942482ca29093a", size = 1115526, upload-time = "2026-05-15T04:51:12.608Z" },
-    { url = "https://files.pythonhosted.org/packages/64/39/1494321ed323ce7a14d88e3cd6cb9058625977df1c6961ddc492bd10a9f3/tiktoken-0.13.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:493af3aa28a4aaf2e3d2600a2ee717252c9bf5ab38fff94eb5a02db5ab77e5ad", size = 1136466, upload-time = "2026-05-15T04:51:13.926Z" },
-    { url = "https://files.pythonhosted.org/packages/96/d9/dfd086aa2d918c563a140720e0ce296cada1634efd2783d5cf51e05f984e/tiktoken-0.13.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6644c9c2b5cf3916f5a3641d7d12fdb3f006a7b3d9ff6acdaec44e29ab1ff91e", size = 1181863, upload-time = "2026-05-15T04:51:15.025Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/68/a18b4f307086954fdae32714cb4f85562e34f9d34ab206e61f1816aa6018/tiktoken-0.13.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5cb65b60b9408563676d874a3a4ee573370066f0dc4e29d84e82e989c6517424", size = 1239218, upload-time = "2026-05-15T04:51:16.103Z" },
-    { url = "https://files.pythonhosted.org/packages/16/5b/f2aa703a4fc5d2dff73460a7d46cc2f3f44aa0f3dd8eeb20d2a0ecf68862/tiktoken-0.13.0-cp314-cp314t-win_amd64.whl", hash = "sha256:85b78cc3a2c3d48723ca751fa981f1fedccd54194ca0471b957364353a898b07", size = 918110, upload-time = "2026-05-15T04:51:17.237Z" },
-]
-
 [[package]]
 name = "tomli"
 version = "2.4.1"