diff --git a/.gitignore b/.gitignore
index caa963c5..18d796db 100644
--- a/.gitignore
+++ b/.gitignore
@@ -16,6 +16,14 @@ docs/
 
 # Local scratch scripts (often contain live keys)
 transcribe/
+# But do track the packaged template
+!aai_cli/init/templates/transcribe/
 
 # Wrong tool for this project (hatchling + uv); never commit a poetry lock
 poetry.lock
+
+# Brainstorming visual-companion scratch
+.superpowers/
+
+# Playwright MCP scratch
+.playwright-mcp/
diff --git a/README.md b/README.md
index cb099db2..65513843 100644
--- a/README.md
+++ b/README.md
@@ -28,6 +28,17 @@ aai login                 # store your API key (browser-assisted)
 aai transcribe --sample   # transcribe the hosted wildfires.mp3 sample
 ```
 
+## Scaffold a starter app
+
+```sh
+aai init                   # pick a template, scaffold it, install deps, open the browser
+aai init transcribe myapp  # non-interactive: template + directory
+```
+
+`aai init` copies a small, self-contained FastAPI + HTML project you can run locally
+and deploy to Vercel as-is. Your key is written to a git-ignored `.env` (and is never
+sent to the browser). Use `--no-install` to scaffold only.
+
 ## API key & security
 
 `aai` resolves your key in this order:
diff --git a/aai_cli/commands/claude.py b/aai_cli/commands/claude.py
index ef8ccb09..dd21c315 100644
--- a/aai_cli/commands/claude.py
+++ b/aai_cli/commands/claude.py
@@ -4,14 +4,13 @@
 import shutil
 import subprocess
 from pathlib import Path
-from typing import TypedDict
 
 import typer
-from rich.markup import escape
 
-from aai_cli import output, theme
+from aai_cli import output
 from aai_cli.context import AppState, run_command
 from aai_cli.errors import UsageError
+from aai_cli.steps import Step, render_steps
 
 app = typer.Typer(
     help="Wire up Claude Code for AssemblyAI (docs MCP + skill).",
@@ -22,14 +21,7 @@
 MCP_URL = "https://mcp.assemblyai.com/docs"
 SKILL_REPO = "AssemblyAI/assemblyai-skill"
 _VALID_SCOPES = ("user", "project", "local")
-
-
-class Step(TypedDict):
-    """One line of setup output: a named step, its status, and a human detail."""
-
-    name: str
-    status: str
-    detail: str
+_STEPS_HEADING = "AssemblyAI coding-agent setup:"
 
 
 def _run(cmd: list[str], *, timeout: float = 120) -> subprocess.CompletedProcess:
@@ -191,15 +183,8 @@ def _remove_skill() -> Step:
     return {"name": "skill", "status": "removed", "detail": str(_skill_dir())}
 
 
-def _render_steps(data: dict[str, list[Step]]) -> str:
-    lines = []
-    for s in data["steps"]:
-        style = theme.status_style(s["status"])
-        lines.append(
-            f"  {escape(s['name'])}: "
-            f"[{style}]{escape(s['status'])}[/{style}] — {escape(s['detail'])}"
-        )
-    return "[aai.heading]AssemblyAI coding-agent setup:[/aai.heading]\n" + "\n".join(lines)
+def _render(data: dict[str, list[Step]]) -> str:
+    return render_steps(data["steps"], heading=_STEPS_HEADING)
 
 
 @app.command()
@@ -224,7 +209,7 @@ def body(_state: AppState, json_mode: bool) -> None:
                 f"Invalid --scope '{scope}'. Choose one of: {', '.join(_VALID_SCOPES)}."
             )
         steps = [_install_mcp(scope, force), _install_skill(force)]
-        output.emit({"steps": steps}, _render_steps, json_mode=json_mode)
+        output.emit({"steps": steps}, _render, json_mode=json_mode)
         if any(s["status"] == "failed" for s in steps):
             raise typer.Exit(code=1)
 
@@ -240,7 +225,7 @@ def status(
 
     def body(_state: AppState, json_mode: bool) -> None:
         steps = [_mcp_status(), _skill_status()]
-        output.emit({"steps": steps}, _render_steps, json_mode=json_mode)
+        output.emit({"steps": steps}, _render, json_mode=json_mode)
 
     run_command(ctx, body, json=json_out)
 
@@ -266,7 +251,7 @@ def body(_state: AppState, json_mode: bool) -> None:
                 f"Invalid --scope '{scope}'. Choose one of: {', '.join(_VALID_SCOPES)}."
             )
         steps = [_remove_mcp(scope), _remove_skill()]
-        output.emit({"steps": steps}, _render_steps, json_mode=json_mode)
+        output.emit({"steps": steps}, _render, json_mode=json_mode)
         if any(s["status"] == "failed" for s in steps):
             raise typer.Exit(code=1)
 
diff --git a/aai_cli/commands/init.py b/aai_cli/commands/init.py
new file mode 100644
index 00000000..b983a971
--- /dev/null
+++ b/aai_cli/commands/init.py
@@ -0,0 +1,190 @@
+# aai_cli/commands/init.py
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import typer
+from rich.markup import escape
+
+from aai_cli import __version__, environments, output, steps
+from aai_cli.context import AppState, run_command
+from aai_cli.errors import CLIError
+from aai_cli.init import keys, runner, scaffold, templates
+
+# Single-command sub-typer flattened to `aai init` (the exact pattern `aai transcribe`
+# uses): one @app.command() named `init`, registered via app.add_typer(init.app) with
+# no name. Bare `aai init` runs the command with template=None -> the interactive picker.
+app = typer.Typer()
+
+
+def _pick_template() -> str:
+    """Interactive picker; raises a usage error when there's no TTY to prompt on."""
+    if not sys.stdin.isatty() or not sys.stdout.isatty():
+        raise CLIError(
+            "No template given and not running interactively. "
+            f"Pass one of: {', '.join(templates.TEMPLATE_ORDER)}.",
+            error_type="usage_error",
+            exit_code=1,
+        )
+    try:
+        import questionary
+    except ImportError as exc:  # a broken/stale install missing the declared dep
+        raise CLIError(
+            "The interactive picker needs 'questionary'. Reinstall the CLI "
+            "(e.g. `uv tool install --reinstall aai-cli`), or pass a template "
+            f"directly: {', '.join(templates.TEMPLATE_ORDER)}.",
+            error_type="missing_dependency",
+            exit_code=1,
+        ) from exc
+
+    choice = questionary.select(
+        "Pick a template",
+        choices=[
+            questionary.Choice(title=templates.title_for(t), value=t)
+            for t in templates.TEMPLATE_ORDER
+        ],
+    ).ask()
+    if choice is None:  # user pressed Ctrl-C
+        raise typer.Exit(code=130)
+    return str(choice)
+
+
+def _resolve_dir(directory: str | None, template: str, *, here: bool) -> Path:
+    if here:
+        return Path.cwd()
+    if directory:
+        return Path(directory)
+    return Path.cwd() / f"{template}-app"
+
+
+@app.command()
+def init(
+    ctx: typer.Context,
+    template: str = typer.Argument(None, help="Template to scaffold (omit to pick interactively)."),
+    directory: str = typer.Argument(None, help="Target directory (default: <template>-app)."),
+    no_install: bool = typer.Option(
+        False, "--no-install", help="Scaffold only; don't install or launch."
+    ),
+    no_open: bool = typer.Option(
+        False, "--no-open", help="Install + launch, but don't open the browser."
+    ),
+    force: bool = typer.Option(False, "--force", help="Overwrite a non-empty target directory."),
+    here: bool = typer.Option(False, "--here", help="Scaffold into the current directory."),
+    port: int = typer.Option(3000, "--port", help="Local server port."),
+    json_out: bool = typer.Option(False, "--json", help="Output raw JSON."),
+) -> None:
+    """Pick a template, scaffold it, install deps, launch the server, open the browser."""
+
+    def body(state: AppState, json_mode: bool) -> None:
+        if not json_mode:
+            # Vercel-style banner at the top of the run.
+            output.console.print(
+                f"[aai.heading]AssemblyAI CLI[/aai.heading] [aai.muted]{__version__}[/aai.muted]"
+            )
+        chosen = template
+        if chosen is None:
+            chosen = _pick_template()
+        if not templates.is_template(chosen):
+            raise CLIError(
+                f"Unknown template {chosen!r}. Choose one of: "
+                f"{', '.join(templates.TEMPLATE_ORDER)}.",
+                error_type="usage_error",
+                exit_code=1,
+            )
+
+        if here and directory:
+            raise CLIError(
+                "Pass either a DIRECTORY or --here, not both.",
+                error_type="usage_error",
+                exit_code=1,
+            )
+        target = _resolve_dir(directory, chosen, here=here)
+        if scaffold.target_conflict(target) and not force:
+            raise CLIError(
+                f"{target} already exists and is not empty. "
+                f"Use --force to overwrite or pick another directory.",
+                error_type="usage_error",
+                exit_code=1,
+            )
+
+        api_key = keys.resolve_optional_api_key(profile=state.profile)
+        # Pin the app to the active environment's hosts so a sandbox key (minted by
+        # `aai login` against a non-prod env) isn't rejected by the production defaults.
+        env = environments.active()
+        env_vars = {
+            "ASSEMBLYAI_BASE_URL": env.api_base,
+            "ASSEMBLYAI_LLM_GATEWAY_URL": env.llm_gateway_base,
+            "ASSEMBLYAI_STREAMING_HOST": env.streaming_host,
+            # Voice Agent host mirrors the streaming host's naming across environments.
+            "ASSEMBLYAI_AGENTS_HOST": env.streaming_host.replace("streaming", "agents", 1),
+        }
+        scaffold.scaffold(chosen, target, api_key=api_key, env_vars=env_vars)
+
+        report: list[steps.Step] = [
+            {"name": "scaffold", "status": "created", "detail": str(target)}
+        ]
+        if api_key is None:
+            report.append(
+                {
+                    "name": "key",
+                    "status": "skipped",
+                    "detail": "no API key found; wrote a placeholder to .env (run `aai login`)",
+                }
+            )
+
+        use_uv = runner.has_uv()
+        will_launch = not no_install and api_key is not None
+        if no_install:
+            report.append({"name": "install", "status": "skipped", "detail": "--no-install"})
+        else:
+            setup = runner.run_setup(target, use_uv=use_uv)
+            if setup.returncode != 0:
+                report.append(
+                    {
+                        "name": "install",
+                        "status": "failed",
+                        "detail": (setup.stderr or setup.stdout).strip()[:300],
+                    }
+                )
+                will_launch = False
+            else:
+                report.append(
+                    {
+                        "name": "install",
+                        "status": "installed",
+                        "detail": "uv" if use_uv else "venv + pip",
+                    }
+                )
+
+        # Deps are installed but there's no key, so the server can't start — say so
+        # rather than exiting silently.
+        if not no_install and api_key is None:
+            report.append(
+                {
+                    "name": "launch",
+                    "status": "skipped",
+                    "detail": f"no API key; run `aai login`, then: cd {target} && uv run uvicorn api.index:app",
+                }
+            )
+
+        output.emit(
+            report, lambda d: steps.render_steps(d, heading="aai init:"), json_mode=json_mode
+        )
+        if any(s["status"] == "failed" for s in report):
+            raise typer.Exit(code=1)
+
+        if will_launch:
+            chosen_port = runner.find_free_port(port)
+            url = f"http://localhost:{chosen_port}"
+            if not json_mode:
+                output.console.print(
+                    f"[aai.heading]Starting[/aai.heading] {escape(url)}  (Ctrl-C to stop)"
+                )
+            code = runner.launch_and_open(
+                target, port=chosen_port, use_uv=use_uv, open_browser=not no_open
+            )
+            if code:
+                raise typer.Exit(code=code)
+
+    run_command(ctx, body, json=json_out)
diff --git a/aai_cli/commands/login.py b/aai_cli/commands/login.py
index 924546fb..5a71bdb6 100644
--- a/aai_cli/commands/login.py
+++ b/aai_cli/commands/login.py
@@ -17,7 +17,7 @@ def login(
     api_key: str = typer.Option(None, "--api-key", help="Provide key non-interactively."),
     json_out: bool = typer.Option(False, "--json", help="Output raw JSON."),
 ) -> None:
-    """Authenticate via your browser (Stytch); stores a CLI API key."""
+    """Authenticate via your browser; stores a CLI API key."""
 
     def body(state: AppState, json_mode: bool) -> None:
         profile = resolve_profile(state)
diff --git a/aai_cli/init/__init__.py b/aai_cli/init/__init__.py
new file mode 100644
index 00000000..52e487a8
--- /dev/null
+++ b/aai_cli/init/__init__.py
@@ -0,0 +1,5 @@
+# aai_cli/init/__init__.py
+# Submodules (templates, keys, scaffold, runner, steps) are imported directly by
+# consumers (e.g. `from aai_cli.init import scaffold`); re-exporting their members
+# here would shadow the same-named submodule (notably `scaffold`), so we don't.
+from __future__ import annotations
diff --git a/aai_cli/init/keys.py b/aai_cli/init/keys.py
new file mode 100644
index 00000000..892c4604
--- /dev/null
+++ b/aai_cli/init/keys.py
@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from aai_cli import config
+from aai_cli.errors import NotAuthenticated
+
+
+def resolve_optional_api_key(*, profile: str | None) -> str | None:
+    """The CLI's key chain (env -> keyring), but None instead of raising when absent.
+
+    `aai init` scaffolds even without a key (writing a placeholder), so it must not
+    fail the way run commands do.
+    """
+    try:
+        return config.resolve_api_key(profile=profile)
+    except NotAuthenticated:
+        return None
diff --git a/aai_cli/init/runner.py b/aai_cli/init/runner.py
new file mode 100644
index 00000000..9e3f4eda
--- /dev/null
+++ b/aai_cli/init/runner.py
@@ -0,0 +1,98 @@
+# aai_cli/init/runner.py
+from __future__ import annotations
+
+import os
+import shutil
+import socket
+import subprocess
+import sys
+import time
+import webbrowser
+from pathlib import Path
+
+from aai_cli.errors import CLIError
+
+
+def has_uv() -> bool:
+    return shutil.which("uv") is not None
+
+
+def venv_python(target: Path) -> Path:
+    if os.name == "nt":
+        return target / ".venv" / "Scripts" / "python.exe"
+    return target / ".venv" / "bin" / "python"
+
+
+def env_setup_commands(target: Path, *, use_uv: bool) -> list[list[str]]:
+    """Commands (run with cwd=target) to create a venv and install requirements."""
+    if use_uv:
+        return [["uv", "venv"], ["uv", "pip", "install", "-r", "requirements.txt"]]
+    py = str(venv_python(target))
+    return [
+        [sys.executable, "-m", "venv", ".venv"],
+        [py, "-m", "pip", "install", "-r", "requirements.txt"],
+    ]
+
+
+def serve_command(target: Path, *, port: int, use_uv: bool) -> list[str]:
+    if use_uv:
+        return ["uv", "run", "uvicorn", "api.index:app", "--port", str(port)]
+    return [str(venv_python(target)), "-m", "uvicorn", "api.index:app", "--port", str(port)]
+
+
+def _port_open(port: int) -> bool:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        return s.connect_ex(("127.0.0.1", port)) == 0
+
+
+def find_free_port(preferred: int, *, tries: int = 20) -> int:
+    """The preferred port if free, else the next free port; OS-assigned when preferred is 0."""
+    if preferred == 0:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(("127.0.0.1", 0))
+            return int(s.getsockname()[1])
+    for candidate in range(preferred, preferred + tries):
+        if not _port_open(candidate):
+            return candidate
+    raise CLIError(
+        f"No free port found in {preferred}-{preferred + tries - 1}. "
+        "Pass --port to choose another.",
+        error_type="port_unavailable",
+        exit_code=1,
+    )
+
+
+def wait_for_port(port: int, *, timeout: float = 30.0) -> bool:
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        if _port_open(port):
+            return True
+        time.sleep(0.2)
+    return False
+
+
+def run_setup(target: Path, *, use_uv: bool) -> subprocess.CompletedProcess:
+    """Run env-setup commands in order; return the first failure or the last success."""
+    last = subprocess.CompletedProcess(args=[], returncode=0, stdout="", stderr="")
+    for cmd in env_setup_commands(target, use_uv=use_uv):
+        last = subprocess.run(cmd, cwd=target, capture_output=True, text=True)
+        if last.returncode != 0:
+            return last
+    return last
+
+
+def launch_and_open(target: Path, *, port: int, use_uv: bool, open_browser: bool) -> int:
+    """Start the dev server, wait for it, open the browser, and block until Ctrl-C.
+
+    Returns the process exit code (0 on a clean Ctrl-C shutdown).
+    """
+    proc = subprocess.Popen(serve_command(target, port=port, use_uv=use_uv), cwd=target)
+    try:
+        if wait_for_port(port) and open_browser:
+            webbrowser.open(f"http://localhost:{port}")
+        proc.wait()
+    except KeyboardInterrupt:
+        proc.terminate()
+        proc.wait()
+        return 0
+    return proc.returncode
diff --git a/aai_cli/init/scaffold.py b/aai_cli/init/scaffold.py
new file mode 100644
index 00000000..cb412a37
--- /dev/null
+++ b/aai_cli/init/scaffold.py
@@ -0,0 +1,86 @@
+# aai_cli/init/scaffold.py
+from __future__ import annotations
+
+from importlib import resources
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from aai_cli.errors import CLIError
+from aai_cli.init import templates
+
+if TYPE_CHECKING:
+    # Annotations only (PEP 563 strings), so no runtime import — `Traversable`'s
+    # module location differs across 3.10/3.11 but that never matters at runtime.
+    from importlib.resources.abc import Traversable
+
+PLACEHOLDER_KEY = "your_assemblyai_api_key_here"
+
+# Template files stored under plain names -> their real dotted names on copy.
+_DOTFILE_RENAMES = {"gitignore": ".gitignore", "env.example": ".env.example"}
+
+# Never copy build/test detritus into the user's fresh project. (Loading a template's
+# api/index.py during our own tests leaves a __pycache__ next to it.)
+_SKIP_NAMES = {"__pycache__"}
+
+
+def _template_root(template: str) -> Traversable:
+    if not templates.is_template(template):
+        raise CLIError(
+            f"Unknown template {template!r}. Choose one of: {', '.join(templates.TEMPLATE_ORDER)}.",
+            error_type="unknown_template",
+            exit_code=1,
+        )
+    # Navigate from the `aai_cli.init` package (templates/ has no __init__.py, so it
+    # is not itself an importable package).
+    root = resources.files("aai_cli.init") / "templates" / template
+    # Defense in depth: the registry should only list shipped templates, but if it ever
+    # drifts ahead of the on-disk directories, fail cleanly instead of with a traceback.
+    if not root.is_dir():
+        raise CLIError(
+            f"Template {template!r} is registered but its files are missing. "
+            "This is a packaging bug — please report it.",
+            error_type="template_missing",
+            exit_code=1,
+        )
+    return root
+
+
+def target_conflict(target: Path) -> bool:
+    """True when the target exists and is a non-empty directory."""
+    return target.is_dir() and any(target.iterdir())
+
+
+def _copy_tree(node: Traversable, dest: Path) -> None:
+    for child in node.iterdir():
+        if child.name in _SKIP_NAMES or child.name.endswith(".pyc"):
+            continue
+        name = _DOTFILE_RENAMES.get(child.name, child.name)
+        out = dest / name
+        if child.is_dir():
+            out.mkdir(parents=True, exist_ok=True)
+            _copy_tree(child, out)
+        else:
+            out.parent.mkdir(parents=True, exist_ok=True)
+            out.write_bytes(child.read_bytes())
+
+
+def scaffold(
+    template: str,
+    target: Path,
+    *,
+    api_key: str | None,
+    env_vars: dict[str, str] | None = None,
+) -> Path:
+    """Copy the template into `target` and write `.env`. Returns `target`.
+
+    `env_vars` (the active environment's hosts) are appended to `.env` so the generated
+    app targets the same AssemblyAI environment the key was minted for — otherwise a
+    sandbox key would be rejected by the production defaults the templates fall back to.
+    """
+    root = _template_root(template)
+    target.mkdir(parents=True, exist_ok=True)
+    _copy_tree(root, target)
+    lines = [f"ASSEMBLYAI_API_KEY={api_key or PLACEHOLDER_KEY}"]
+    lines += [f"{k}={v}" for k, v in (env_vars or {}).items()]
+    (target / ".env").write_text("\n".join(lines) + "\n")
+    return target
diff --git a/aai_cli/init/templates.py b/aai_cli/init/templates.py
new file mode 100644
index 00000000..912ef1e0
--- /dev/null
+++ b/aai_cli/init/templates.py
@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+# id -> human-facing title shown in the picker. Ids mirror the CLI's commands.
+#
+# Every id here MUST have a directory under templates/<id>/ (a test enforces both
+# directions) — the picker must never advertise a template that would crash on scaffold.
+TEMPLATES: dict[str, str] = {
+    "transcribe": "Transcribe a pre-recorded file (+ chat with it via LLM Gateway)",
+    "stream": "Live captions (mic → browser)",
+    "agent": "Talk to a voice agent",
+}
+
+# Display order for the picker and `--help`, matching the CLI's command order.
+TEMPLATE_ORDER: tuple[str, ...] = ("transcribe", "stream", "agent")
+
+
+def is_template(name: str) -> bool:
+    return name in TEMPLATES
+
+
+def title_for(name: str) -> str:
+    """The human title for a template id, or the raw id if unknown."""
+    return TEMPLATES.get(name, name)
diff --git a/aai_cli/init/templates/agent/README.md b/aai_cli/init/templates/agent/README.md
new file mode 100644
index 00000000..e57a5548
--- /dev/null
+++ b/aai_cli/init/templates/agent/README.md
@@ -0,0 +1,29 @@
+# Talk to a voice agent — AssemblyAI Voice Agent starter
+
+Click connect and talk to a voice agent: speech in → LLM → speech out, with built-in
+turn detection, TTS, and barge-in. The browser connects **directly** to AssemblyAI's
+Voice Agent WebSocket using a one-time token minted by the backend, so your API key
+never reaches the client and no audio is proxied through your server.
+
+## Run locally
+
+```sh
+uvicorn api.index:app --reload --port 3000
+# open http://localhost:3000  (allow microphone access; headphones recommended)
+```
+
+`ASSEMBLYAI_API_KEY` is read from `.env` (created for you if you ran `aai init`).
+The Voice Agent API requires a plan with access enabled.
+
+## Deploy to Vercel
+
+Push this folder to a Git repo and import it on Vercel. Set `ASSEMBLYAI_API_KEY` as a
+Vercel environment variable (the local `.env` is git-ignored). The backend is just the
+`/api/token` function; the WebSocket runs browser → AssemblyAI, so nothing long-running
+is needed.
+
+## Ideas to extend
+
+- Change the `greeting`, `system_prompt`, or `voice` in `index.html`'s `session.update`.
+- Add tools (function calling) so the agent can look things up or take actions.
+- Tune `input.turn_detection` (`min_silence`/`max_silence`) for your use case.
diff --git a/aai_cli/init/templates/agent/api/index.py b/aai_cli/init/templates/agent/api/index.py
new file mode 100644
index 00000000..452d0488
--- /dev/null
+++ b/aai_cli/init/templates/agent/api/index.py
@@ -0,0 +1,49 @@
+"""Talk to a voice agent — AssemblyAI Voice Agent starter (FastAPI).
+
+The browser connects directly to AssemblyAI's Voice Agent WebSocket (speech-in → LLM →
+speech-out, with built-in turn detection and TTS) using a short-lived, single-use token
+minted here — so your API key never reaches the client.
+
+  POST /api/token -> {"token": ..., "ws_url": "wss://.../v1/ws"}
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import httpx
+from dotenv import load_dotenv
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import FileResponse
+
+load_dotenv()
+API_KEY = os.environ.get("ASSEMBLYAI_API_KEY", "")
+# `aai init` writes this for you; defaults to production. (No scheme — host only.)
+AGENTS_HOST = os.environ.get("ASSEMBLYAI_AGENTS_HOST", "agents.assemblyai.com")
+
+ROOT = Path(__file__).resolve().parent.parent
+app = FastAPI()
+
+
+@app.get("/")
+def index() -> FileResponse:
+    return FileResponse(ROOT / "index.html")
+
+
+@app.post("/api/token")
+def token() -> dict[str, str]:
+    """Mint a one-time Voice Agent token. The browser uses it to open the WebSocket."""
+    # NOTE: the Voice Agent token uses Bearer auth (unlike the streaming token).
+    try:
+        resp = httpx.get(
+            f"https://{AGENTS_HOST}/v1/token",
+            params={"expires_in_seconds": 60},
+            headers={"Authorization": f"Bearer {API_KEY}"},
+        )
+        resp.raise_for_status()
+    except Exception as exc:  # missing/invalid key, network -> clean 502, not a 500
+        raise HTTPException(
+            status_code=502, detail=f"Could not mint voice-agent token: {exc}"
+        ) from exc
+    return {"token": resp.json()["token"], "ws_url": f"wss://{AGENTS_HOST}/v1/ws"}
diff --git a/aai_cli/init/templates/agent/env.example b/aai_cli/init/templates/agent/env.example
new file mode 100644
index 00000000..1a4621d3
--- /dev/null
+++ b/aai_cli/init/templates/agent/env.example
@@ -0,0 +1,3 @@
+ASSEMBLYAI_API_KEY=your_assemblyai_api_key_here
+# Optional — target a non-production AssemblyAI environment (aai init fills this in):
+# ASSEMBLYAI_AGENTS_HOST=agents.assemblyai.com
diff --git a/aai_cli/init/templates/agent/gitignore b/aai_cli/init/templates/agent/gitignore
new file mode 100644
index 00000000..5b01785a
--- /dev/null
+++ b/aai_cli/init/templates/agent/gitignore
@@ -0,0 +1,3 @@
+.env
+.venv
+__pycache__/
diff --git a/aai_cli/init/templates/agent/index.html b/aai_cli/init/templates/agent/index.html
new file mode 100644
index 00000000..d59935f0
--- /dev/null
+++ b/aai_cli/init/templates/agent/index.html
@@ -0,0 +1,191 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Talk to a voice agent · AssemblyAI</title>
+  <style>
+    :root { --accent: #4338ca; --line: #e5e7eb; --muted: #6b7280; --bg: #f8fafc; }
+    * { box-sizing: border-box; }
+    body { font: 15px/1.6 -apple-system, system-ui, sans-serif; color: #111827;
+           background: var(--bg); margin: 0; padding: 48px 16px; }
+    main { max-width: 720px; margin: 0 auto; }
+    h1 { font-size: 22px; margin: 0 0 4px; }
+    .sub { color: var(--muted); margin: 0 0 24px; }
+    button { background: var(--accent); color: #fff; border: 0; border-radius: 9px;
+             padding: 11px 20px; font-size: 14px; font-weight: 600; cursor: pointer; }
+    button.live { background: #dc2626; }
+    #status { display: inline-block; margin-left: 12px; font-size: 13px; font-weight: 600;
+              padding: 5px 12px; border-radius: 999px; }
+    #status:empty { display: none; }
+    #status.live { background: #dcfce7; color: #166534; }
+    #status.idle { background: #f3f4f6; color: #4b5563; }
+    #status.error { background: #fee2e2; color: #991b1b; }
+    #log { margin-top: 24px; }
+    .turn { padding: 8px 0 8px 12px; border-left: 3px solid var(--line); margin: 8px 0; }
+    .turn.you { border-left-color: #0d9488; }
+    .turn.agent { border-left-color: var(--accent); }
+    .who { font-weight: 700; }
+    .turn.you .who { color: #0d9488; }
+    .turn.agent .who { color: var(--accent); }
+  </style>
+</head>
+<body>
+  <main>
+    <h1>🗣️ Talk to a voice agent</h1>
+    <p class="sub">Click connect and just talk — speech in, LLM reply, speech out, with built-in turn detection and barge-in. The browser connects straight to AssemblyAI's Voice Agent API with a one-time token; your API key stays on the server. (Use headphones for the cleanest result.)</p>
+
+    <button id="conn">● Connect</button>
+    <span id="status"></span>
+
+    <div id="log"></div>
+  </main>
+
+  <script>
+    const connBtn = document.getElementById("conn");
+    const statusEl = document.getElementById("status");
+    const logEl = document.getElementById("log");
+
+    let ws = null, micStream = null, micCtx = null, micProc = null;
+    let playCtx = null, playHead = 0, sources = [];
+    let connected = false;
+
+    connBtn.addEventListener("click", () => (connected ? hangup() : connect().catch(fail)));
+    function setStatus(msg, state) { statusEl.textContent = msg; statusEl.className = state; }
+
+    async function connect() {
+      setStatus("Connecting…", "idle");
+      const res = await fetch("/api/token", { method: "POST" });
+      if (!res.ok) return fail(await res.text());
+      const { token, ws_url } = await res.json();
+
+      ws = new WebSocket(`${ws_url}?token=${encodeURIComponent(token)}`);
+      ws.onopen = () => {
+        ws.send(JSON.stringify({
+          type: "session.update",
+          session: {
+            system_prompt: "You are a friendly, concise voice assistant. Keep replies short and conversational.",
+            greeting: "Hi! I'm your AssemblyAI voice agent. What can I help you with?",
+            input: { format: { encoding: "audio/pcm" } },
+            output: { voice: "ivy", format: { encoding: "audio/pcm" } },
+          },
+        }));
+        startMic().catch(fail);
+      };
+      ws.onmessage = (e) => onEvent(JSON.parse(e.data));
+      ws.onerror = () => fail("WebSocket error");
+      ws.onclose = () => { if (connected) hangup(); };
+    }
+
+    async function startMic() {
+      micStream = await navigator.mediaDevices.getUserMedia({
+        audio: { echoCancellation: true, noiseSuppression: false },  // server runs its own voice focus
+      });
+      micCtx = new (window.AudioContext || window.webkitAudioContext)();
+      playCtx = new (window.AudioContext || window.webkitAudioContext)({ sampleRate: 24000 });
+      // Contexts can start suspended after the await above; resume so audio flows.
+      micCtx.resume();
+      playCtx.resume();
+      const source = micCtx.createMediaStreamSource(micStream);
+      micProc = micCtx.createScriptProcessor(4096, 1, 1);
+      source.connect(micProc);
+      micProc.connect(micCtx.destination);
+      micProc.onaudioprocess = (e) => {
+        if (!ws || ws.readyState !== WebSocket.OPEN) return;
+        const pcm = downsampleToPCM(e.inputBuffer.getChannelData(0), micCtx.sampleRate, 24000);
+        ws.send(JSON.stringify({ type: "input.audio", audio: bytesToB64(pcm) }));
+      };
+      connected = true;
+      connBtn.textContent = "■ Hang up";
+      connBtn.classList.add("live");
+      setStatus("● Connected — just talk", "live");
+    }
+
+    function onEvent(ev) {
+      switch (ev.type) {
+        case "transcript.user": return addTurn("you", "You", ev.text);
+        case "transcript.agent": return addTurn("agent", "Agent", ev.text);
+        case "reply.audio": return playChunk(ev.data);  // base64 PCM16 lives in `data`
+        case "input.speech.started": return bargeIn();  // user interrupted — drop queued agent audio
+        case "reply.done": if (ev.status === "interrupted") bargeIn(); return;
+        case "session.error": return fail(ev.message || "session error");
+      }
+    }
+
+    // --- agent audio playback (24 kHz PCM) -------------------------------
+    function playChunk(b64) {
+      const int16 = b64ToInt16(b64);
+      const buf = playCtx.createBuffer(1, int16.length, 24000);
+      const ch = buf.getChannelData(0);
+      for (let i = 0; i < int16.length; i++) ch[i] = int16[i] / 0x8000;
+      const src = playCtx.createBufferSource();
+      src.buffer = buf;
+      src.connect(playCtx.destination);
+      const startAt = Math.max(playCtx.currentTime, playHead);
+      src.start(startAt);
+      playHead = startAt + buf.duration;
+      sources.push(src);
+      src.onended = () => (sources = sources.filter((s) => s !== src));
+    }
+
+    function bargeIn() {
+      sources.forEach((s) => { try { s.stop(); } catch (_) {} });
+      sources = [];
+      playHead = 0;
+    }
+
+    function addTurn(cls, who, text) {
+      if (!text) return;
+      const div = document.createElement("div");
+      div.className = "turn " + cls;
+      div.innerHTML = `<span class="who">${who}:</span> `;
+      div.appendChild(document.createTextNode(text));
+      logEl.appendChild(div);
+      div.scrollIntoView({ block: "end" });
+    }
+
+    function hangup() {
+      connected = false;
+      connBtn.textContent = "● Connect";
+      connBtn.classList.remove("live");
+      setStatus("Disconnected", "idle");
+      bargeIn();
+      if (ws && ws.readyState === WebSocket.OPEN) ws.close();
+      if (micProc) micProc.disconnect();
+      if (micStream) micStream.getTracks().forEach((t) => t.stop());
+      if (micCtx) micCtx.close();
+      if (playCtx) playCtx.close();
+      ws = micProc = micStream = micCtx = playCtx = null;
+    }
+
+    function fail(msg) {
+      setStatus("Error: " + msg, "error");
+      if (connected) hangup();
+    }
+
+    // --- audio helpers ---------------------------------------------------
+    function downsampleToPCM(input, inRate, outRate) {
+      const ratio = inRate / outRate;
+      const outLen = Math.floor(input.length / ratio);
+      const out = new Int16Array(outLen);
+      for (let i = 0; i < outLen; i++) {
+        const s = Math.max(-1, Math.min(1, input[Math.floor(i * ratio)]));
+        out[i] = s < 0 ? s * 0x8000 : s * 0x7fff;
+      }
+      return out.buffer;
+    }
+    function bytesToB64(buf) {
+      let bin = "";
+      const bytes = new Uint8Array(buf);
+      for (let i = 0; i < bytes.length; i++) bin += String.fromCharCode(bytes[i]);
+      return btoa(bin);
+    }
+    function b64ToInt16(b64) {
+      const bin = atob(b64);
+      const bytes = new Uint8Array(bin.length);
+      for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+      return new Int16Array(bytes.buffer);
+    }
+  </script>
+</body>
+</html>
diff --git a/aai_cli/init/templates/agent/requirements.txt b/aai_cli/init/templates/agent/requirements.txt
new file mode 100644
index 00000000..3263361e
--- /dev/null
+++ b/aai_cli/init/templates/agent/requirements.txt
@@ -0,0 +1,4 @@
+fastapi
+uvicorn
+httpx
+python-dotenv
diff --git a/aai_cli/init/templates/agent/vercel.json b/aai_cli/init/templates/agent/vercel.json
new file mode 100644
index 00000000..7f1e3652
--- /dev/null
+++ b/aai_cli/init/templates/agent/vercel.json
@@ -0,0 +1,6 @@
+{
+  "rewrites": [
+    { "source": "/api/(.*)", "destination": "/api/index" },
+    { "source": "/(.*)", "destination": "/index.html" }
+  ]
+}
diff --git a/aai_cli/init/templates/stream/README.md b/aai_cli/init/templates/stream/README.md
new file mode 100644
index 00000000..b618af19
--- /dev/null
+++ b/aai_cli/init/templates/stream/README.md
@@ -0,0 +1,28 @@
+# Live captions — AssemblyAI Streaming starter
+
+Click record and speak — your microphone streams to AssemblyAI's Streaming v3 API and
+transcribes in real time. The browser captures audio and connects **directly** to
+AssemblyAI using a one-time token minted by the backend, so your API key never reaches
+the client (and no audio is proxied through your server).
+
+## Run locally
+
+```sh
+uvicorn api.index:app --reload --port 3000
+# open http://localhost:3000  (allow microphone access)
+```
+
+`ASSEMBLYAI_API_KEY` is read from `.env` (created for you if you ran `aai init`).
+
+## Deploy to Vercel
+
+Push this folder to a Git repo and import it on Vercel. Set `ASSEMBLYAI_API_KEY` as a
+Vercel environment variable (the local `.env` is git-ignored). The backend is just the
+`/api/token` function; the WebSocket runs browser → AssemblyAI, so nothing long-running
+is needed. `vercel.json` routes the page and the function.
+
+## Ideas to extend
+
+- Add `keyterms_prompt` or a `prompt` for domain vocabulary (the demo uses `u3-rt-pro`).
+- Add `format_turns`/punctuation toggles, or speaker labels (`speaker_labels=true`).
+- Persist the final transcript, or pipe each finalized turn into the LLM Gateway.
diff --git a/aai_cli/init/templates/stream/api/index.py b/aai_cli/init/templates/stream/api/index.py
new file mode 100644
index 00000000..fc12a7fd
--- /dev/null
+++ b/aai_cli/init/templates/stream/api/index.py
@@ -0,0 +1,49 @@
+"""Live captions — AssemblyAI Streaming starter (FastAPI).
+
+The browser streams microphone audio directly to AssemblyAI's Streaming v3 WebSocket
+using a short-lived, single-use token minted here — so your API key never reaches the
+client.
+
+  POST /api/token -> {"token": ..., "ws_url": "wss://.../v3/ws"}
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import httpx
+from dotenv import load_dotenv
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import FileResponse
+
+load_dotenv()
+API_KEY = os.environ.get("ASSEMBLYAI_API_KEY", "")
+# `aai init` writes this for you; defaults to production. (No scheme — host only.)
+STREAMING_HOST = os.environ.get("ASSEMBLYAI_STREAMING_HOST", "streaming.assemblyai.com")
+
+ROOT = Path(__file__).resolve().parent.parent
+app = FastAPI()
+
+
+@app.get("/")
+def index() -> FileResponse:
+    return FileResponse(ROOT / "index.html")
+
+
+@app.post("/api/token")
+def token() -> dict[str, str]:
+    """Mint a one-time streaming token. The browser uses it to open the WebSocket."""
+    # NOTE: the streaming token uses the raw API key as Authorization (no 'Bearer').
+    try:
+        resp = httpx.get(
+            f"https://{STREAMING_HOST}/v3/token",
+            params={"expires_in_seconds": 60},
+            headers={"Authorization": API_KEY},
+        )
+        resp.raise_for_status()
+    except Exception as exc:  # missing/invalid key, network -> clean 502, not a 500
+        raise HTTPException(
+            status_code=502, detail=f"Could not mint streaming token: {exc}"
+        ) from exc
+    return {"token": resp.json()["token"], "ws_url": f"wss://{STREAMING_HOST}/v3/ws"}
diff --git a/aai_cli/init/templates/stream/env.example b/aai_cli/init/templates/stream/env.example
new file mode 100644
index 00000000..ac8149ae
--- /dev/null
+++ b/aai_cli/init/templates/stream/env.example
@@ -0,0 +1,3 @@
+ASSEMBLYAI_API_KEY=your_assemblyai_api_key_here
+# Optional — target a non-production AssemblyAI environment (aai init fills this in):
+# ASSEMBLYAI_STREAMING_HOST=streaming.assemblyai.com
diff --git a/aai_cli/init/templates/stream/gitignore b/aai_cli/init/templates/stream/gitignore
new file mode 100644
index 00000000..5b01785a
--- /dev/null
+++ b/aai_cli/init/templates/stream/gitignore
@@ -0,0 +1,3 @@
+.env
+.venv
+__pycache__/
diff --git a/aai_cli/init/templates/stream/index.html b/aai_cli/init/templates/stream/index.html
new file mode 100644
index 00000000..bfa09698
--- /dev/null
+++ b/aai_cli/init/templates/stream/index.html
@@ -0,0 +1,137 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Live captions · AssemblyAI</title>
+  <style>
+    :root { --accent: #4338ca; --line: #e5e7eb; --muted: #6b7280; --bg: #f8fafc; }
+    * { box-sizing: border-box; }
+    body { font: 15px/1.6 -apple-system, system-ui, sans-serif; color: #111827;
+           background: var(--bg); margin: 0; padding: 48px 16px; }
+    main { max-width: 720px; margin: 0 auto; }
+    h1 { font-size: 22px; margin: 0 0 4px; }
+    .sub { color: var(--muted); margin: 0 0 24px; }
+    button { background: var(--accent); color: #fff; border: 0; border-radius: 9px;
+             padding: 11px 20px; font-size: 14px; font-weight: 600; cursor: pointer; }
+    button.rec { background: #dc2626; }
+    button:disabled { opacity: .55; cursor: default; }
+    #status { display: inline-block; margin-left: 12px; font-size: 13px; font-weight: 600;
+              padding: 5px 12px; border-radius: 999px; }
+    #status:empty { display: none; }
+    #status.live { background: #fee2e2; color: #991b1b; }
+    #status.idle { background: #f3f4f6; color: #4b5563; }
+    #status.error { background: #fee2e2; color: #991b1b; }
+    .caption { margin-top: 24px; font-size: 19px; line-height: 1.7; min-height: 120px;
+               background: #fff; border: 1px solid var(--line); border-radius: 12px; padding: 18px; }
+    .final { color: #111827; }
+    .partial { color: var(--muted); }
+  </style>
+</head>
+<body>
+  <main>
+    <h1>🎙️ Live captions</h1>
+    <p class="sub">Click record and talk — your mic streams to AssemblyAI and transcribes in real time. Audio goes straight from the browser to AssemblyAI with a one-time token; your API key stays on the server.</p>
+
+    <button id="rec">● Record</button>
+    <span id="status"></span>
+
+    <div class="caption"><span id="final" class="final"></span><span id="partial" class="partial"></span></div>
+  </main>
+
+  <script>
+    const recBtn = document.getElementById("rec");
+    const statusEl = document.getElementById("status");
+    const finalEl = document.getElementById("final");
+    const partialEl = document.getElementById("partial");
+
+    let ws = null;
+    let audioCtx = null;
+    let mediaStream = null;
+    let processor = null;
+    let recording = false;
+
+    recBtn.addEventListener("click", () => (recording ? stop() : start().catch(fail)));
+
+    function setStatus(msg, state) { statusEl.textContent = msg; statusEl.className = state; }
+
+    async function start() {
+      setStatus("Connecting…", "idle");
+      const res = await fetch("/api/token", { method: "POST" });
+      if (!res.ok) return fail(await res.text());
+      const { token, ws_url } = await res.json();
+
+      mediaStream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      audioCtx = new (window.AudioContext || window.webkitAudioContext)();
+      const source = audioCtx.createMediaStreamSource(mediaStream);
+      processor = audioCtx.createScriptProcessor(4096, 1, 1);
+
+      const params = new URLSearchParams({
+        token,
+        sample_rate: "16000",
+        encoding: "pcm_s16le",
+        speech_model: "u3-rt-pro",
+        format_turns: "true",
+      });
+      ws = new WebSocket(`${ws_url}?${params}`);
+      ws.binaryType = "arraybuffer";
+
+      ws.onopen = () => {
+        recording = true;
+        recBtn.textContent = "■ Stop";
+        recBtn.classList.add("rec");
+        setStatus("● Live", "live");
+        source.connect(processor);
+        processor.connect(audioCtx.destination);
+        processor.onaudioprocess = (e) => {
+          if (ws && ws.readyState === WebSocket.OPEN) {
+            ws.send(downsampleTo16kPCM(e.inputBuffer.getChannelData(0), audioCtx.sampleRate));
+          }
+        };
+      };
+      ws.onmessage = (e) => onMessage(JSON.parse(e.data));
+      ws.onerror = () => fail("WebSocket error");
+      ws.onclose = () => { if (recording) stop(); };
+    }
+
+    function onMessage(msg) {
+      if (msg.type !== "Turn") return;
+      if (msg.end_of_turn) {
+        finalEl.textContent += (msg.transcript || "") + " ";
+        partialEl.textContent = "";
+      } else {
+        partialEl.textContent = msg.transcript || "";
+      }
+    }
+
+    function stop() {
+      recording = false;
+      recBtn.textContent = "● Record";
+      recBtn.classList.remove("rec");
+      setStatus("Stopped", "idle");
+      if (ws && ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: "Terminate" }));
+      if (processor) processor.disconnect();
+      if (mediaStream) mediaStream.getTracks().forEach((t) => t.stop());
+      if (audioCtx) audioCtx.close();
+      ws = processor = mediaStream = audioCtx = null;
+    }
+
+    // Web Audio gives Float32 at the device rate (often 48k); the API wants 16k PCM16.
+    function downsampleTo16kPCM(input, inRate) {
+      const ratio = inRate / 16000;
+      const outLen = Math.floor(input.length / ratio);
+      const out = new Int16Array(outLen);
+      for (let i = 0; i < outLen; i++) {
+        const s = Math.max(-1, Math.min(1, input[Math.floor(i * ratio)]));
+        out[i] = s < 0 ? s * 0x8000 : s * 0x7fff;
+      }
+      return out.buffer;
+    }
+
+    function fail(msg) {
+      setStatus("Error: " + msg, "error");
+      if (recording) stop();
+    }
+  </script>
+</body>
+</html>
diff --git a/aai_cli/init/templates/stream/requirements.txt b/aai_cli/init/templates/stream/requirements.txt
new file mode 100644
index 00000000..3263361e
--- /dev/null
+++ b/aai_cli/init/templates/stream/requirements.txt
@@ -0,0 +1,4 @@
+fastapi
+uvicorn
+httpx
+python-dotenv
diff --git a/aai_cli/init/templates/stream/vercel.json b/aai_cli/init/templates/stream/vercel.json
new file mode 100644
index 00000000..7f1e3652
--- /dev/null
+++ b/aai_cli/init/templates/stream/vercel.json
@@ -0,0 +1,6 @@
+{
+  "rewrites": [
+    { "source": "/api/(.*)", "destination": "/api/index" },
+    { "source": "/(.*)", "destination": "/index.html" }
+  ]
+}
diff --git a/aai_cli/init/templates/transcribe/README.md b/aai_cli/init/templates/transcribe/README.md
new file mode 100644
index 00000000..b1338430
--- /dev/null
+++ b/aai_cli/init/templates/transcribe/README.md
@@ -0,0 +1,26 @@
+# Transcribe a pre-recorded file — AssemblyAI starter
+
+Transcribe an audio/video URL (defaults to a public sample) or upload a file, and
+see the transcript with speaker labels, chapters, sentiment, entities, and
+highlights. Built with FastAPI + a single HTML page.
+
+## Run locally
+
+```sh
+uvicorn api.index:app --reload --port 3000
+# open http://localhost:3000
+```
+
+`ASSEMBLYAI_API_KEY` is read from `.env` (already created for you if you ran `aai init`).
+
+## Deploy to Vercel
+
+Push this folder to a Git repo and import it on Vercel. Set `ASSEMBLYAI_API_KEY`
+as a Vercel environment variable (the local `.env` is git-ignored and not deployed).
+No extra config — `vercel.json` routes the page and the `/api` function.
+
+## Ideas to extend
+
+- Show chapter summaries and highlight timestamps.
+- Add a waveform / audio player synced to the transcript.
+- Swap the analysis features in `CONFIG` (api/index.py).
diff --git a/aai_cli/init/templates/transcribe/api/index.py b/aai_cli/init/templates/transcribe/api/index.py
new file mode 100644
index 00000000..f8b4401e
--- /dev/null
+++ b/aai_cli/init/templates/transcribe/api/index.py
@@ -0,0 +1,123 @@
+"""Transcribe a pre-recorded file — AssemblyAI starter (FastAPI).
+
+Each call stays short, so it's serverless-friendly:
+  POST /api/transcribe       -> submit an uploaded file, return {"id": ...}
+  POST /api/transcribe-url   -> submit a public URL (defaults to the sample), {"id": ...}
+  GET  /api/status/{id}      -> poll; returns the full transcript JSON when complete
+  POST /api/ask              -> ask a question about a transcript via the LLM Gateway
+
+The browser (index.html) submits a URL or file, then polls status until done.
+Your API key stays on the server — the browser never sees it.
+"""
+
+from __future__ import annotations
+
+import os
+import tempfile
+import uuid
+from pathlib import Path
+
+import assemblyai as aai
+from assemblyai.api import get_transcript  # single non-blocking GET (see status())
+from assemblyai.client import Client
+from dotenv import load_dotenv
+from fastapi import Body, FastAPI, HTTPException, UploadFile
+from fastapi.responses import FileResponse
+from openai import OpenAI  # the LLM Gateway is OpenAI-compatible
+
+load_dotenv()
+API_KEY = os.environ.get("ASSEMBLYAI_API_KEY", "")
+aai.settings.api_key = API_KEY
+# Target the same AssemblyAI environment the key was minted for. `aai init` writes
+# these for you; leave them unset to use the production defaults.
+if base_url := os.environ.get("ASSEMBLYAI_BASE_URL"):
+    aai.settings.base_url = base_url
+LLM_GATEWAY_URL = os.environ.get(
+    "ASSEMBLYAI_LLM_GATEWAY_URL", "https://llm-gateway.assemblyai.com/v1"
+)
+LLM_MODEL = "claude-haiku-4-5-20251001"
+
+# A public sample so you can try it instantly without uploading anything.
+SAMPLE_URL = "https://assembly.ai/wildfires.mp3"
+
+# Audio-intelligence features to showcase. Tweak these — that's the point of a starter.
+CONFIG = aai.TranscriptionConfig(
+    speaker_labels=True,
+    auto_chapters=True,
+    sentiment_analysis=True,
+    entity_detection=True,
+    auto_highlights=True,
+)
+
+ROOT = Path(__file__).resolve().parent.parent
+app = FastAPI()
+
+
+@app.get("/")
+def index() -> FileResponse:
+    return FileResponse(ROOT / "index.html")
+
+
+def _submit(audio: str) -> dict[str, str]:
+    """Submit an audio reference (local file path or public URL); return its id."""
+    try:
+        transcript = aai.Transcriber().submit(audio, config=CONFIG)
+    except Exception as exc:  # missing/invalid key, network, etc. -> clean error, not a 500
+        raise HTTPException(
+            status_code=502, detail=f"Could not start transcription: {exc}"
+        ) from exc
+    return {"id": transcript.id}
+
+
+@app.post("/api/transcribe")
+async def transcribe(file: UploadFile) -> dict[str, str]:
+    suffix = Path(file.filename or "audio").suffix
+    tmp = Path(tempfile.gettempdir()) / f"aai-{uuid.uuid4().hex}{suffix}"
+    tmp.write_bytes(await file.read())
+    try:
+        return _submit(str(tmp))
+    finally:
+        tmp.unlink(missing_ok=True)  # the upload is sent during submit; don't leave it on disk
+
+
+@app.post("/api/transcribe-url")
+def transcribe_url(url: str = Body(default=SAMPLE_URL, embed=True)) -> dict[str, str]:
+    # AssemblyAI transcribes a public URL directly — no upload step needed.
+    return _submit(url.strip() or SAMPLE_URL)
+
+
+@app.post("/api/ask")
+def ask(transcript_id: str = Body(...), question: str = Body(...)) -> dict[str, str]:
+    """Answer a question about a transcript via the LLM Gateway.
+
+    The gateway is OpenAI-compatible: pass `transcript_id` in `extra_body` and it
+    substitutes the `{{ transcript }}` tag with the transcript text server-side.
+    """
+    client = OpenAI(api_key=API_KEY, base_url=LLM_GATEWAY_URL)
+    try:
+        resp = client.chat.completions.create(
+            model=LLM_MODEL,
+            messages=[{"role": "user", "content": f"{question}\n\n{{{{ transcript }}}}"}],
+            max_tokens=1000,
+            extra_body={"transcript_id": transcript_id},
+        )
+    except Exception as exc:  # surface the gateway's own error (e.g. plan access)
+        raise HTTPException(status_code=502, detail=f"LLM Gateway error: {exc}") from exc
+    return {"answer": resp.choices[0].message.content or ""}
+
+
+@app.get("/api/status/{transcript_id}")
+def status(transcript_id: str) -> dict[str, object]:
+    # One non-blocking GET. NOTE: aai.Transcript.get_by_id() BLOCKS until the job
+    # finishes (it calls wait_for_completion) — wrong for a poll endpoint, and it
+    # would time out on serverless. api.get_transcript does a single request and
+    # uses the SDK's configured client (auth + region from aai.settings).
+    try:
+        t = get_transcript(Client.get_default().http_client, transcript_id)
+    except Exception as exc:  # missing key (ValueError), HTTP/network error -> clean 502
+        raise HTTPException(status_code=502, detail=f"Could not fetch transcript: {exc}") from exc
+    if t.status == aai.TranscriptStatus.error:
+        raise HTTPException(status_code=502, detail=t.error or "Transcription failed")
+    if t.status == aai.TranscriptStatus.completed:
+        return {"status": "completed", "transcript": t.dict()}
+    return {"status": str(getattr(t.status, "value", t.status))}
diff --git a/aai_cli/init/templates/transcribe/env.example b/aai_cli/init/templates/transcribe/env.example
new file mode 100644
index 00000000..c989b993
--- /dev/null
+++ b/aai_cli/init/templates/transcribe/env.example
@@ -0,0 +1,4 @@
+ASSEMBLYAI_API_KEY=your_assemblyai_api_key_here
+# Optional — target a non-production AssemblyAI environment (aai init fills these in):
+# ASSEMBLYAI_BASE_URL=https://api.assemblyai.com
+# ASSEMBLYAI_LLM_GATEWAY_URL=https://llm-gateway.assemblyai.com/v1
diff --git a/aai_cli/init/templates/transcribe/gitignore b/aai_cli/init/templates/transcribe/gitignore
new file mode 100644
index 00000000..5b01785a
--- /dev/null
+++ b/aai_cli/init/templates/transcribe/gitignore
@@ -0,0 +1,3 @@
+.env
+.venv
+__pycache__/
diff --git a/aai_cli/init/templates/transcribe/index.html b/aai_cli/init/templates/transcribe/index.html
new file mode 100644
index 00000000..0ff894a3
--- /dev/null
+++ b/aai_cli/init/templates/transcribe/index.html
@@ -0,0 +1,298 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Transcribe a pre-recorded file · AssemblyAI</title>
+  <style>
+    :root { --accent: #4338ca; --line: #e5e7eb; --muted: #6b7280; --bg: #f8fafc; }
+    * { box-sizing: border-box; }
+    body {
+      font: 15px/1.6 -apple-system, system-ui, sans-serif; color: #111827;
+      background: var(--bg); margin: 0; padding: 48px 16px;
+    }
+    main { max-width: 760px; margin: 0 auto; }
+    h1 { font-size: 22px; margin: 0 0 4px; }
+    .sub { color: var(--muted); margin: 0 0 24px; }
+    .card { background: #fff; border: 1px solid var(--line); border-radius: 14px; padding: 20px; }
+    .row { display: flex; gap: 8px; }
+    input[type=url] {
+      flex: 1; min-width: 0; padding: 11px 13px; border: 1px solid var(--line);
+      border-radius: 9px; font-size: 14px;
+    }
+    input[type=url]:focus { outline: none; border-color: var(--accent); }
+    button {
+      background: var(--accent); color: #fff; border: 0; border-radius: 9px;
+      padding: 0 18px; font-size: 14px; font-weight: 600; cursor: pointer; white-space: nowrap;
+    }
+    button:disabled { opacity: .55; cursor: default; }
+    .or { display: flex; align-items: center; gap: 12px; color: var(--muted); font-size: 13px; margin: 16px 0; }
+    .or::before, .or::after { content: ""; flex: 1; height: 1px; background: var(--line); }
+    .upload {
+      display: block; text-align: center; padding: 16px; border: 1.5px dashed var(--line);
+      border-radius: 10px; color: var(--muted); cursor: pointer; font-size: 14px;
+    }
+    .upload:hover { border-color: var(--accent); color: var(--accent); }
+    #status {
+      display: inline-block; margin: 18px 0; padding: 6px 13px; border-radius: 999px;
+      font-size: 13px; font-weight: 600;
+    }
+    #status:empty { display: none; }
+    #status.working { background: #eef2ff; color: var(--accent); }
+    #status.done { background: #dcfce7; color: #166534; }
+    #status.error { background: #fee2e2; color: #991b1b; }
+
+    /* Ask the transcript (LLM Gateway) */
+    #ask { margin: 0 0 18px; }
+    #ask .q { display: flex; gap: 8px; }
+    #ask input { flex: 1; min-width: 0; padding: 11px 13px; border: 1px solid var(--line);
+                 border-radius: 9px; font-size: 14px; }
+    #ask input:focus { outline: none; border-color: var(--accent); }
+    .answer { margin-top: 12px; padding: 12px 14px; background: #f5f3ff; border-radius: 10px;
+              white-space: pre-wrap; color: #1e1b4b; }
+    .answer:empty { display: none; }
+
+    /* Tabs */
+    .tabs { display: flex; flex-wrap: wrap; gap: 6px; margin-bottom: 14px; }
+    .tabs button {
+      background: #fff; color: #374151; border: 1px solid var(--line); border-radius: 999px;
+      padding: 6px 14px; font-size: 13px; font-weight: 600;
+    }
+    .tabs button.active { background: var(--accent); color: #fff; border-color: var(--accent); }
+    .time { color: var(--muted); font-variant-numeric: tabular-nums; font-size: 12px; }
+
+    /* Transcript / sentiment turns */
+    .turn { padding: 8px 0 8px 12px; border-left: 3px solid var(--line); margin: 8px 0; }
+    .spk { font-weight: 700; }
+    .turn .t { color: #374151; }
+
+    /* Chapters */
+    .chapter { padding: 12px 0; border-top: 1px solid var(--line); }
+    .chapter h4 { margin: 0 0 2px; font-size: 15px; }
+    .chapter p { margin: 4px 0 0; color: #374151; }
+
+    /* Entities */
+    .egroup { padding: 10px 0; border-top: 1px solid var(--line); }
+    .elabel { font-size: 11px; text-transform: uppercase; letter-spacing: .05em; color: var(--muted); }
+    .etag { display: inline-block; background: #eef2ff; color: var(--accent); border-radius: 999px;
+            padding: 2px 10px; margin: 4px 4px 0 0; font-size: 13px; }
+
+    /* Highlights */
+    .hl { display: flex; align-items: center; gap: 10px; padding: 8px 0; border-top: 1px solid var(--line); }
+    .hl .count { background: #eef2ff; color: var(--accent); border-radius: 999px; padding: 2px 9px;
+                 font-size: 12px; font-weight: 700; }
+
+    /* Sentiment pills */
+    .sent { font-size: 11px; font-weight: 700; border-radius: 999px; padding: 1px 8px; margin-left: 8px; }
+    .POSITIVE { background: #dcfce7; color: #166534; }
+    .NEGATIVE { background: #fee2e2; color: #991b1b; }
+    .NEUTRAL { background: #f3f4f6; color: #4b5563; }
+    pre { white-space: pre-wrap; margin: 0; font: inherit; }
+  </style>
+</head>
+<body>
+  <main>
+    <h1>🎧 Transcribe a pre-recorded file</h1>
+    <p class="sub">Transcribe an audio or video URL (or upload a file), then explore speakers, chapters, sentiment, entities, and highlights.</p>
+
+    <div class="card">
+      <div class="row">
+        <input id="url" type="url" value="https://assembly.ai/wildfires.mp3"
+               placeholder="https://example.com/audio.mp3" />
+        <button id="go">Transcribe</button>
+      </div>
+      <div class="or">or</div>
+      <label class="upload">
+        <input id="file" type="file" accept="audio/*,video/*" hidden />
+        Upload an audio or video file
+      </label>
+    </div>
+
+    <p id="status"></p>
+
+    <div id="ask" class="card" hidden>
+      <div class="q">
+        <input id="q" type="text" placeholder="Ask a question about this transcript…" />
+        <button id="askBtn">Ask</button>
+      </div>
+      <div id="answer" class="answer"></div>
+    </div>
+
+    <div id="tabs" class="tabs"></div>
+    <div id="view"></div>
+  </main>
+
+  <script>
+    const urlInput = document.getElementById("url");
+    const goBtn = document.getElementById("go");
+    const fileInput = document.getElementById("file");
+    const statusEl = document.getElementById("status");
+    const tabsEl = document.getElementById("tabs");
+    const viewEl = document.getElementById("view");
+    const askPanel = document.getElementById("ask");
+    const qInput = document.getElementById("q");
+    const askBtn = document.getElementById("askBtn");
+    const answerEl = document.getElementById("answer");
+
+    let currentId = null;  // transcript the Ask panel questions against
+
+    goBtn.addEventListener("click", () => transcribeUrl(urlInput.value.trim()));
+    urlInput.addEventListener("keydown", (e) => e.key === "Enter" && goBtn.click());
+    fileInput.addEventListener("change", () => fileInput.files[0] && transcribeFile(fileInput.files[0]));
+    askBtn.addEventListener("click", () => ask(qInput.value.trim()));
+    qInput.addEventListener("keydown", (e) => e.key === "Enter" && askBtn.click());
+
+    async function transcribeUrl(url) {
+      if (!url) return;
+      await start(() =>
+        fetch("/api/transcribe-url", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ url }),
+        })
+      );
+    }
+
+    async function transcribeFile(file) {
+      const body = new FormData();
+      body.append("file", file);
+      await start(() => fetch("/api/transcribe", { method: "POST", body }));
+    }
+
+    async function start(submit) {
+      busy(true);
+      tabsEl.innerHTML = viewEl.innerHTML = answerEl.textContent = "";
+      askPanel.hidden = true;
+      currentId = null;
+      speakerSeen = {};
+      setStatus("Uploading…", "working");
+      try {
+        const res = await submit();
+        if (!res.ok) return fail(await res.text());
+        await poll((await res.json()).id);
+      } catch (e) {
+        fail(e.message || String(e));  // network/parse errors don't leave the UI stuck
+      }
+    }
+
+    async function poll(id) {
+      setStatus("Transcribing…", "working");
+      const res = await fetch("/api/status/" + id);
+      if (!res.ok) return fail(await res.text());
+      const data = await res.json();
+      if (data.status !== "completed")
+        return void setTimeout(() => poll(id).catch((e) => fail(String(e))), 2000);
+      setStatus("✓ Done", "done");
+      busy(false);
+      currentId = id;
+      askPanel.hidden = false;  // transcript stays visible below; ask alongside it
+      explore(data.transcript);
+    }
+
+    async function ask(question) {
+      if (!question || !currentId) return;
+      askBtn.disabled = true;
+      answerEl.textContent = "Thinking…";
+      try {
+        const res = await fetch("/api/ask", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ transcript_id: currentId, question }),
+        });
+        const data = await res.json();
+        answerEl.textContent = res.ok ? data.answer : "Error: " + (data.detail || res.statusText);
+      } finally {
+        askBtn.disabled = false;
+      }
+    }
+
+    // --- speaker colors (reset each transcription via start()) -----------
+    const PALETTE = ["#4338ca", "#0d9488", "#b45309", "#be185d", "#15803d", "#7c3aed"];
+    let speakerSeen = {};
+    function speakerColor(spk) {
+      return (speakerSeen[spk] ??= PALETTE[Object.keys(speakerSeen).length % PALETTE.length]);
+    }
+
+    // --- build the tabbed explorer --------------------------------------
+    function explore(t) {
+      const views = {};
+      const turns = t.utterances || [];
+      views.Transcript = turns.length
+        ? turns.map((u) => turnHtml(u.speaker, u.text)).join("")
+        : `<pre>${esc(t.text || "")}</pre>`;
+
+      if (t.chapters?.length) views[`Chapters · ${t.chapters.length}`] = chaptersHtml(t.chapters);
+      if (t.sentiment_analysis_results?.length)
+        views.Sentiment = t.sentiment_analysis_results.map(sentimentHtml).join("");
+      if (t.entities?.length) views[`Entities · ${t.entities.length}`] = entitiesHtml(t.entities);
+      const hl = t.auto_highlights_result?.results || [];
+      if (hl.length) views.Highlights = highlightsHtml(hl);
+
+      tabsEl.innerHTML = "";
+      Object.keys(views).forEach((name, i) => {
+        const b = document.createElement("button");
+        b.textContent = name;
+        b.onclick = () => {
+          viewEl.innerHTML = views[name];
+          [...tabsEl.children].forEach((c) => c.classList.toggle("active", c === b));
+        };
+        tabsEl.appendChild(b);
+        if (i === 0) b.click();
+      });
+    }
+
+    function turnHtml(speaker, text, extra = "") {
+      const c = speakerColor(speaker);
+      return `<div class="turn" style="border-left-color:${c}">
+        <span class="spk" style="color:${c}">Speaker ${esc(speaker)}</span>${extra}
+        <div class="t">${esc(text)}</div></div>`;
+    }
+
+    function sentimentHtml(s) {
+      const pill = `<span class="sent ${s.sentiment}">${esc(s.sentiment)}</span>`;
+      return turnHtml(s.speaker || "?", s.text, pill);
+    }
+
+    function chaptersHtml(chapters) {
+      return chapters
+        .map(
+          (c) => `<div class="chapter">
+            <h4>${esc(c.headline || c.gist || "Chapter")}</h4>
+            <span class="time">${fmt(c.start)} – ${fmt(c.end)}</span>
+            <p>${esc(c.summary || c.gist || "")}</p></div>`
+        )
+        .join("");
+    }
+
+    function entitiesHtml(entities) {
+      const groups = {};
+      for (const e of entities) (groups[e.entity_type] ??= []).push(e.text);
+      return Object.entries(groups)
+        .map(
+          ([type, items]) => `<div class="egroup"><div class="elabel">${esc(type)}</div>
+            ${[...new Set(items)].map((x) => `<span class="etag">${esc(x)}</span>`).join("")}</div>`
+        )
+        .join("");
+    }
+
+    function highlightsHtml(results) {
+      return results
+        .sort((a, b) => b.rank - a.rank)
+        .map((h) => `<div class="hl"><span class="count">${h.count}×</span> ${esc(h.text)}</div>`)
+        .join("");
+    }
+
+    // --- helpers ---------------------------------------------------------
+    function fmt(ms) {
+      const s = Math.round((ms || 0) / 1000);
+      return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, "0")}`;
+    }
+    function busy(on) { goBtn.disabled = on; }
+    function setStatus(msg, state) { statusEl.textContent = msg; statusEl.className = state; }
+    function fail(msg) { busy(false); setStatus("⚠ " + msg, "error"); }
+    function esc(s) {
+      return String(s ?? "").replace(/[&<>]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;" }[c]));
+    }
+  </script>
+</body>
+</html>
diff --git a/aai_cli/init/templates/transcribe/requirements.txt b/aai_cli/init/templates/transcribe/requirements.txt
new file mode 100644
index 00000000..67a3b4c6
--- /dev/null
+++ b/aai_cli/init/templates/transcribe/requirements.txt
@@ -0,0 +1,6 @@
+fastapi
+uvicorn
+assemblyai>=0.64,<1
+python-dotenv
+python-multipart
+openai
diff --git a/aai_cli/init/templates/transcribe/vercel.json b/aai_cli/init/templates/transcribe/vercel.json
new file mode 100644
index 00000000..7f1e3652
--- /dev/null
+++ b/aai_cli/init/templates/transcribe/vercel.json
@@ -0,0 +1,6 @@
+{
+  "rewrites": [
+    { "source": "/api/(.*)", "destination": "/api/index" },
+    { "source": "/(.*)", "destination": "/index.html" }
+  ]
+}
diff --git a/aai_cli/main.py b/aai_cli/main.py
index d911812c..30026f35 100644
--- a/aai_cli/main.py
+++ b/aai_cli/main.py
@@ -16,6 +16,7 @@
     agent,
     claude,
     doctor,
+    init,
     llm,
     login,
     samples,
@@ -40,6 +41,7 @@
     "whoami",
     "doctor",
     "samples",
+    "init",
     "claude",
     "version",
 )
@@ -100,6 +102,7 @@ def main(
 app.add_typer(login.app)  # login, logout, whoami
 app.add_typer(doctor.app)
 app.add_typer(samples.app, name="samples")
+app.add_typer(init.app)
 app.add_typer(claude.app, name="claude")
 
 
diff --git a/aai_cli/steps.py b/aai_cli/steps.py
new file mode 100644
index 00000000..3172f223
--- /dev/null
+++ b/aai_cli/steps.py
@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import TypedDict
+
+from rich.markup import escape
+
+from aai_cli import theme
+
+
+class Step(TypedDict):
+    """One line of multi-step command output: a named step, its status, and a detail."""
+
+    name: str
+    status: str
+    detail: str
+
+
+def render_steps(items: list[Step], *, heading: str) -> str:
+    """Render steps as a themed heading followed by one status-styled line each.
+
+    Shared by the multi-step commands (`aai init`, `aai claude`); each passes its
+    own heading.
+    """
+    lines = []
+    for s in items:
+        style = theme.status_style(s["status"])
+        lines.append(
+            f"  {escape(s['name'])}: "
+            f"[{style}]{escape(s['status'])}[/{style}] — {escape(s['detail'])}"
+        )
+    return f"[aai.heading]{escape(heading)}[/aai.heading]\n" + "\n".join(lines)
diff --git a/aai_cli/theme.py b/aai_cli/theme.py
index 8b7654d8..b29847cc 100644
--- a/aai_cli/theme.py
+++ b/aai_cli/theme.py
@@ -39,7 +39,7 @@
 )
 
 # Status strings grouped by the semantic style they render in.
-_SUCCESS = {"completed", "installed", "removed", "ok", "present", "authenticated"}
+_SUCCESS = {"completed", "installed", "removed", "ok", "present", "authenticated", "created"}
 _ERROR = {"error", "failed"}
 _WARN = {"queued", "processing", "in_progress", "running"}
 
diff --git a/pyproject.toml b/pyproject.toml
index 2a2142a7..5bd62099 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -38,6 +38,7 @@ dependencies = [
     "sounddevice>=0.5.5",
     "openai>=2.41.0",
     "yt-dlp>=2026.3.17",
+    "questionary>=2.0.1",
     # audioop (used for PCM resampling) left the stdlib in 3.13; this backport provides it.
     "audioop-lts>=0.2; python_version >= '3.13'",
 ]
@@ -55,6 +56,10 @@ dev = [
     "ruff>=0.15.15",
     "mypy>=2.1.0",
     "pre-commit>=4.6.0",
+    "fastapi>=0.115.0",
+    "uvicorn>=0.30.0",
+    "python-dotenv>=1.0.0",
+    "python-multipart>=0.0.9",
 ]
 
 [project.scripts]
@@ -62,6 +67,11 @@ aai = "aai_cli.main:run"
 
 [tool.hatch.build.targets.wheel]
 packages = ["aai_cli"]
+# Force-include the committed template files (incl. renamed dotfiles); the `**` glob
+# would otherwise also sweep in __pycache__/*.pyc left by importing a template during
+# tests, so exclude those from the wheel.
+artifacts = ["aai_cli/init/templates/**"]
+exclude = ["**/__pycache__", "**/*.pyc"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
@@ -97,4 +107,4 @@ ignore = ["E501", "B008", "S603", "S607"]
 
 [tool.ruff.lint.per-file-ignores]
 # Tests assert freely, use throwaway args/temp paths, and don't need pathlib/security lints.
-"tests/**" = ["S101", "S105", "S106", "S108", "ARG001", "ARG002", "ARG005", "PTH123", "SIM117"]
+"tests/**" = ["S101", "S105", "S106", "S107", "S108", "ARG001", "ARG002", "ARG005", "PTH123", "SIM117"]
diff --git a/tests/test_claude_render.py b/tests/test_claude_render.py
index 079299ff..ed90ae50 100644
--- a/tests/test_claude_render.py
+++ b/tests/test_claude_render.py
@@ -1,7 +1,7 @@
 import io
 
 from aai_cli import theme
-from aai_cli.commands.claude import _render_steps
+from aai_cli.commands.claude import _render
 
 
 def test_render_steps_colors_status():
@@ -11,7 +11,7 @@ def test_render_steps_colors_status():
             {"name": "skill", "status": "failed", "detail": "nope"},
         ]
     }
-    rendered = _render_steps(data)
+    rendered = _render(data)
     # The markup string carries the semantic style tags per status...
     assert "[aai.success]installed[/aai.success]" in rendered
     assert "[aai.error]failed[/aai.error]" in rendered
diff --git a/tests/test_init_command.py b/tests/test_init_command.py
new file mode 100644
index 00000000..944ae0cd
--- /dev/null
+++ b/tests/test_init_command.py
@@ -0,0 +1,142 @@
+from typer.testing import CliRunner
+
+from aai_cli.main import app
+
+runner = CliRunner()
+
+
+def test_init_scaffold_only_creates_project(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    result = runner.invoke(app, ["init", "transcribe", "myapp", "--no-install"])
+    assert result.exit_code == 0, result.output
+    assert (tmp_path / "myapp" / "api" / "index.py").exists()
+    assert (tmp_path / "myapp" / ".env").exists()
+
+
+def test_init_writes_key_from_env(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setenv("ASSEMBLYAI_API_KEY", "sk-from-env")
+    runner.invoke(app, ["init", "transcribe", "myapp", "--no-install"])
+    assert "ASSEMBLYAI_API_KEY=sk-from-env" in (tmp_path / "myapp" / ".env").read_text()
+
+
+def test_init_logged_out_installs_but_skips_launch_with_hint(tmp_path, monkeypatch):
+    # Logged out + install: deps install, but the server can't start without a key —
+    # the report must say so (and must not launch) rather than exiting silently.
+    import subprocess
+
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr(
+        "aai_cli.init.runner.run_setup",
+        lambda *a, **k: subprocess.CompletedProcess([], 0, "", ""),
+    )
+    launched = {"v": False}
+    monkeypatch.setattr(
+        "aai_cli.init.runner.launch_and_open",
+        lambda *a, **k: launched.__setitem__("v", True) or 0,
+    )
+    result = runner.invoke(app, ["init", "transcribe", "app"])  # no --no-install, logged out
+    assert result.exit_code == 0, result.output
+    assert launched["v"] is False
+    assert "aai login" in result.output
+
+
+def test_init_writes_base_url_for_active_env(tmp_path, monkeypatch):
+    # The generated .env pins the app to the CLI's active environment hosts.
+    monkeypatch.chdir(tmp_path)
+    runner.invoke(app, ["init", "transcribe", "myapp", "--no-install"])
+    env = (tmp_path / "myapp" / ".env").read_text()
+    assert "ASSEMBLYAI_BASE_URL=https://" in env
+    assert "ASSEMBLYAI_LLM_GATEWAY_URL=https://" in env
+
+
+def test_init_placeholder_key_when_logged_out(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    runner.invoke(app, ["init", "transcribe", "myapp", "--no-install"])
+    env = (tmp_path / "myapp" / ".env").read_text()
+    assert "your_assemblyai_api_key_here" in env
+
+
+def test_init_unknown_template_errors(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    result = runner.invoke(app, ["init", "nope", "myapp", "--no-install"])
+    assert result.exit_code == 1
+
+
+def test_init_refuses_nonempty_dir_without_force(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    assert runner.invoke(app, ["init", "transcribe", "myapp", "--no-install"]).exit_code == 0
+    result = runner.invoke(app, ["init", "transcribe", "myapp", "--no-install"])
+    assert result.exit_code == 1
+
+
+def test_init_force_overwrites(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    assert runner.invoke(app, ["init", "transcribe", "myapp", "--no-install"]).exit_code == 0
+    result = runner.invoke(app, ["init", "transcribe", "myapp", "--no-install", "--force"])
+    assert result.exit_code == 0
+
+
+def test_init_no_template_non_interactive_errors(tmp_path, monkeypatch):
+    # CliRunner has no TTY, so the picker can't run; bare `aai init` must error helpfully.
+    monkeypatch.chdir(tmp_path)
+    result = runner.invoke(app, ["init"])
+    assert result.exit_code != 0
+    assert "transcribe" in result.output  # lists the available templates
+
+
+def test_init_default_dir_is_template_app(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    result = runner.invoke(app, ["init", "transcribe", "--no-install"])
+    assert result.exit_code == 0, result.output
+    assert (tmp_path / "transcribe-app" / "api" / "index.py").exists()
+
+
+def test_init_appears_in_help():
+    result = runner.invoke(app, ["--help"])
+    assert "init" in result.output
+
+
+def test_init_prints_cli_banner_in_human_mode(tmp_path, monkeypatch):
+    # Vercel-style header at the top of an interactive run (human output only).
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr("aai_cli.output._is_agentic", lambda: False)
+    result = runner.invoke(app, ["init", "transcribe", "x", "--no-install"])
+    assert result.exit_code == 0, result.output
+    assert "AssemblyAI CLI" in result.output
+
+
+def test_init_here_scaffolds_into_cwd(tmp_path, monkeypatch):
+    work = tmp_path / "work"  # a fresh empty dir (tmp_path itself holds the test config/)
+    work.mkdir()
+    monkeypatch.chdir(work)
+    result = runner.invoke(app, ["init", "transcribe", "--here", "--no-install"])
+    assert result.exit_code == 0, result.output
+    assert (work / "api" / "index.py").exists()  # scaffolded into cwd, no subdir
+
+
+def test_init_here_with_directory_errors(tmp_path, monkeypatch):
+    work = tmp_path / "work"
+    work.mkdir()
+    monkeypatch.chdir(work)
+    result = runner.invoke(app, ["init", "transcribe", "mydir", "--here", "--no-install"])
+    assert result.exit_code != 0  # ambiguous: directory AND --here both given
+
+
+def test_init_json_output_is_machine_readable(tmp_path, monkeypatch):
+    import json
+
+    monkeypatch.chdir(tmp_path)
+    result = runner.invoke(app, ["init", "transcribe", "myapp", "--no-install", "--json"])
+    assert result.exit_code == 0, result.output
+    payload = json.loads(result.stdout)
+    assert any(step["name"] == "scaffold" and step["status"] == "created" for step in payload)
+
+
+def test_init_unregistered_template_errors_cleanly(tmp_path, monkeypatch):
+    # `llm` isn't a separate template (it's folded into transcribe), so picking it must
+    # give a clean error, not a FileNotFoundError.
+    monkeypatch.chdir(tmp_path)
+    result = runner.invoke(app, ["init", "llm", "x", "--no-install"])
+    assert result.exit_code == 1
+    assert "llm" in result.output
diff --git a/tests/test_init_keys.py b/tests/test_init_keys.py
new file mode 100644
index 00000000..e471a502
--- /dev/null
+++ b/tests/test_init_keys.py
@@ -0,0 +1,17 @@
+from aai_cli import config
+from aai_cli.init import keys
+
+
+def test_resolves_from_env(monkeypatch):
+    monkeypatch.setenv("ASSEMBLYAI_API_KEY", "env-key-123")
+    assert keys.resolve_optional_api_key(profile=None) == "env-key-123"
+
+
+def test_resolves_from_keyring(memory_keyring):
+    config.set_api_key("default", "stored-key-456")
+    assert keys.resolve_optional_api_key(profile=None) == "stored-key-456"
+
+
+def test_returns_none_when_absent():
+    # isolate_env strips the env var and memory_keyring starts empty.
+    assert keys.resolve_optional_api_key(profile=None) is None
diff --git a/tests/test_init_packaging.py b/tests/test_init_packaging.py
new file mode 100644
index 00000000..34e83f5d
--- /dev/null
+++ b/tests/test_init_packaging.py
@@ -0,0 +1,11 @@
+import importlib
+
+
+def test_init_package_imports():
+    mod = importlib.import_module("aai_cli.init")
+    assert mod is not None
+
+
+def test_questionary_is_available():
+    # questionary is a runtime dependency of the CLI (the init picker).
+    assert importlib.import_module("questionary") is not None
diff --git a/tests/test_init_runner.py b/tests/test_init_runner.py
new file mode 100644
index 00000000..9e19a7be
--- /dev/null
+++ b/tests/test_init_runner.py
@@ -0,0 +1,73 @@
+import socket
+import sys
+from pathlib import Path
+
+from aai_cli.init import runner
+
+
+def test_has_uv_reflects_path(monkeypatch):
+    monkeypatch.setattr(runner.shutil, "which", lambda name: "/usr/bin/uv")
+    assert runner.has_uv() is True
+    monkeypatch.setattr(runner.shutil, "which", lambda name: None)
+    assert runner.has_uv() is False
+
+
+def test_venv_python_path_per_platform(monkeypatch):
+    target = Path("/proj")
+    monkeypatch.setattr(runner.os, "name", "posix")
+    assert runner.venv_python(target) == target / ".venv" / "bin" / "python"
+    monkeypatch.setattr(runner.os, "name", "nt")
+    assert runner.venv_python(target) == target / ".venv" / "Scripts" / "python.exe"
+
+
+def test_env_setup_commands_uv():
+    cmds = runner.env_setup_commands(Path("/proj"), use_uv=True)
+    assert cmds == [["uv", "venv"], ["uv", "pip", "install", "-r", "requirements.txt"]]
+
+
+def test_env_setup_commands_venv():
+    target = Path("/proj")
+    cmds = runner.env_setup_commands(target, use_uv=False)
+    py = str(runner.venv_python(target))
+    assert cmds == [
+        [sys.executable, "-m", "venv", ".venv"],
+        [py, "-m", "pip", "install", "-r", "requirements.txt"],
+    ]
+
+
+def test_serve_command_uv_and_venv():
+    target = Path("/proj")
+    assert runner.serve_command(target, port=3000, use_uv=True) == [
+        "uv",
+        "run",
+        "uvicorn",
+        "api.index:app",
+        "--port",
+        "3000",
+    ]
+    py = str(runner.venv_python(target))
+    assert runner.serve_command(target, port=3000, use_uv=False) == [
+        py,
+        "-m",
+        "uvicorn",
+        "api.index:app",
+        "--port",
+        "3000",
+    ]
+
+
+def test_find_free_port_returns_preferred_when_open():
+    port = runner.find_free_port(0)  # 0 -> OS assigns a free port
+    assert isinstance(port, int) and port > 0
+
+
+def test_find_free_port_skips_taken_port():
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.bind(("127.0.0.1", 0))
+    taken = s.getsockname()[1]
+    s.listen(1)
+    try:
+        chosen = runner.find_free_port(taken)
+        assert chosen != taken
+    finally:
+        s.close()
diff --git a/tests/test_init_scaffold.py b/tests/test_init_scaffold.py
new file mode 100644
index 00000000..f60f6a7c
--- /dev/null
+++ b/tests/test_init_scaffold.py
@@ -0,0 +1,81 @@
+import pytest
+
+from aai_cli.errors import CLIError
+from aai_cli.init import scaffold
+
+
+def test_scaffold_copies_files_and_renames_dotfiles(tmp_path):
+    target = tmp_path / "app"
+    scaffold.scaffold("transcribe", target, api_key="sk-real-key")
+    assert (target / "api" / "index.py").exists()
+    assert (target / "index.html").exists()
+    assert (target / "vercel.json").exists()
+    # dotfile templates are renamed to their dotted names
+    assert (target / ".gitignore").exists()
+    assert (target / ".env.example").exists()
+    # the plain-named source files are NOT copied verbatim
+    assert not (target / "gitignore").exists()
+    assert not (target / "env.example").exists()
+
+
+def test_scaffold_writes_env_with_key(tmp_path):
+    target = tmp_path / "app"
+    scaffold.scaffold("transcribe", target, api_key="sk-real-key")
+    env = (target / ".env").read_text()
+    assert "ASSEMBLYAI_API_KEY=sk-real-key" in env
+
+
+def test_scaffold_writes_env_vars(tmp_path):
+    target = tmp_path / "app"
+    scaffold.scaffold(
+        "transcribe",
+        target,
+        api_key="k",
+        env_vars={
+            "ASSEMBLYAI_BASE_URL": "https://api.sb.example",
+            "ASSEMBLYAI_LLM_GATEWAY_URL": "https://llm.sb.example/v1",
+        },
+    )
+    env = (target / ".env").read_text()
+    assert "ASSEMBLYAI_BASE_URL=https://api.sb.example" in env
+    assert "ASSEMBLYAI_LLM_GATEWAY_URL=https://llm.sb.example/v1" in env
+
+
+def test_scaffold_omits_env_vars_when_none(tmp_path):
+    target = tmp_path / "app"
+    scaffold.scaffold("transcribe", target, api_key="k")
+    env = (target / ".env").read_text()
+    assert "ASSEMBLYAI_BASE_URL" not in env
+    assert "ASSEMBLYAI_LLM_GATEWAY_URL" not in env
+
+
+def test_scaffold_skips_pycache(tmp_path):
+    # Importing a template's api/index.py during our own test run leaves a
+    # __pycache__ next to it; the scaffolder must not copy that into the project.
+    target = tmp_path / "app"
+    scaffold.scaffold("transcribe", target, api_key=None)
+    assert not list(target.rglob("__pycache__"))
+    assert not list(target.rglob("*.pyc"))
+
+
+def test_scaffold_writes_placeholder_when_no_key(tmp_path):
+    target = tmp_path / "app"
+    scaffold.scaffold("transcribe", target, api_key=None)
+    env = (target / ".env").read_text()
+    assert scaffold.PLACEHOLDER_KEY in env
+
+
+def test_scaffold_unknown_template_raises(tmp_path):
+    with pytest.raises(CLIError):
+        scaffold.scaffold("nope", tmp_path / "app", api_key=None)
+
+
+def test_target_conflict_detects_nonempty_dir(tmp_path):
+    empty = tmp_path / "empty"
+    empty.mkdir()
+    assert scaffold.target_conflict(empty) is False
+    assert scaffold.target_conflict(tmp_path / "missing") is False
+    nonempty = tmp_path / "full"
+    nonempty.mkdir()
+    (nonempty / "x.txt").write_text("hi")
+    assert scaffold.target_conflict(nonempty) is True
diff --git a/tests/test_init_template_agent.py b/tests/test_init_template_agent.py
new file mode 100644
index 00000000..208b29f7
--- /dev/null
+++ b/tests/test_init_template_agent.py
@@ -0,0 +1,65 @@
+import importlib.util
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from fastapi.testclient import TestClient
+
+TEMPLATE_DIR = Path("aai_cli/init/templates/agent")
+
+
+def _load_app():
+    spec = importlib.util.spec_from_file_location("_tmpl_agent", TEMPLATE_DIR / "api" / "index.py")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _ok_response(token="tok-123"):
+    resp = MagicMock()
+    resp.json.return_value = {"token": token}
+    resp.raise_for_status.return_value = None
+    return resp
+
+
+def test_token_returns_token_and_agent_ws_url(monkeypatch):
+    mod = _load_app()
+    monkeypatch.setattr(mod.httpx, "get", lambda *a, **k: _ok_response())
+    resp = TestClient(mod.app).post("/api/token")
+    assert resp.status_code == 200
+    body = resp.json()
+    assert body["token"] == "tok-123"
+    assert body["ws_url"].startswith("wss://") and body["ws_url"].endswith("/v1/ws")
+
+
+def test_token_uses_bearer_authorization_header(monkeypatch):
+    # The Voice Agent token uses Bearer auth (unlike the streaming token).
+    monkeypatch.setenv("ASSEMBLYAI_API_KEY", "sk-test")
+    mod = _load_app()
+    captured = {}
+
+    def fake_get(url, params=None, headers=None):
+        captured.update(url=url, headers=headers)
+        return _ok_response()
+
+    monkeypatch.setattr(mod.httpx, "get", fake_get)
+    TestClient(mod.app).post("/api/token")
+    assert captured["headers"]["Authorization"] == "Bearer sk-test"
+    assert "/v1/token" in captured["url"]
+
+
+def test_page_reads_reply_audio_from_data_field():
+    # reply.audio carries the base64 PCM in `data` (not `audio`); guard the regression.
+    html = (TEMPLATE_DIR / "index.html").read_text()
+    assert "reply.audio" in html
+    assert "ev.data" in html
+
+
+def test_token_surfaces_error_as_502(monkeypatch):
+    mod = _load_app()
+
+    def boom(*a, **k):
+        raise RuntimeError("network down")
+
+    monkeypatch.setattr(mod.httpx, "get", boom)
+    resp = TestClient(mod.app).post("/api/token")
+    assert resp.status_code == 502
diff --git a/tests/test_init_template_contract.py b/tests/test_init_template_contract.py
new file mode 100644
index 00000000..c64dc08b
--- /dev/null
+++ b/tests/test_init_template_contract.py
@@ -0,0 +1,83 @@
+import ast
+import re
+from pathlib import Path
+
+import pytest
+
+TEMPLATES_ROOT = Path("aai_cli/init/templates")
+TEMPLATE_DIRS = sorted(
+    p for p in TEMPLATES_ROOT.iterdir() if p.is_dir() and not p.name.startswith("__")
+)
+# Map an import name to its PyPI distribution where they differ.
+_PKG_MAP = {"dotenv": "python-dotenv", "multipart": "python-multipart"}
+_STDLIB = {"os", "tempfile", "uuid", "pathlib", "__future__", "json", "typing"}
+
+
+@pytest.fixture(params=TEMPLATE_DIRS, ids=lambda p: p.name)
+def template_dir(request):
+    return request.param
+
+
+def test_required_files_present(template_dir):
+    for rel in (
+        "api/index.py",
+        "index.html",
+        "vercel.json",
+        "requirements.txt",
+        "README.md",
+        "gitignore",
+        "env.example",
+    ):
+        assert (template_dir / rel).exists(), f"{template_dir.name} missing {rel}"
+
+
+def test_no_committed_dotenv_or_real_key(template_dir):
+    assert not (template_dir / ".env").exists(), f"{template_dir.name} ships a real .env"
+    assert "your_assemblyai_api_key_here" in (template_dir / "env.example").read_text()
+
+
+def test_frontend_routes_exist_in_backend(template_dir):
+    """Every /api path the page fetches must be a route the backend registers."""
+    html = (template_dir / "index.html").read_text()
+    fetched = set(re.findall(r'fetch\(\s*["\'`](/api/[^"\'`?]+)', html))
+    # Also catch template-literal paths like fetch(`/api/status/${id}`) and "/api/x/" + id
+    fetched |= set(re.findall(r'["\'`](/api/[A-Za-z0-9_\-/]+?)(?:/?\$\{|/?["\'`]\s*\+)', html))
+    src = (template_dir / "api" / "index.py").read_text()
+    registered = set(re.findall(r'@app\.\w+\(\s*["\']([^"\']+)["\']', src))
+    registered_bases = {re.sub(r"/\{[^}]+\}$", "", r).rstrip("/") for r in registered}
+    for path in fetched:
+        base = path.rstrip("/")
+        assert any(base == r or base.startswith(r + "/") for r in registered_bases), (
+            f"{template_dir.name}: index.html fetches {path!r}, "
+            f"not registered in api/index.py (routes: {sorted(registered_bases)})"
+        )
+
+
+def test_requirements_cover_backend_imports(template_dir):
+    """Every third-party import in api/index.py appears in requirements.txt."""
+    tree = ast.parse((template_dir / "api" / "index.py").read_text())
+    imports: set[str] = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            imports.add(node.names[0].name.split(".")[0])
+        elif isinstance(node, ast.ImportFrom) and node.level == 0 and node.module:
+            imports.add(node.module.split(".")[0])
+    third_party = imports - _STDLIB
+    reqs = (template_dir / "requirements.txt").read_text().lower()
+    for pkg in third_party:
+        dist = _PKG_MAP.get(pkg, pkg)
+        assert dist in reqs, (
+            f"{template_dir.name}: import {pkg!r} ({dist}) missing from requirements.txt"
+        )
+
+
+def test_status_endpoint_does_not_block(template_dir):
+    """Guard against the blocking SDK call: a poll endpoint must not wait_for_completion."""
+    src = (template_dir / "api" / "index.py").read_text()
+    tree = ast.parse(src)
+    blocking = {"get_by_id", "wait_for_completion"}
+    called = {n.attr for n in ast.walk(tree) if isinstance(n, ast.Attribute)}
+    assert not (called & blocking), (
+        f"{template_dir.name}: uses blocking SDK call {called & blocking} — "
+        f"poll endpoints must do a single non-blocking fetch"
+    )
diff --git a/tests/test_init_template_stream.py b/tests/test_init_template_stream.py
new file mode 100644
index 00000000..1e8f2632
--- /dev/null
+++ b/tests/test_init_template_stream.py
@@ -0,0 +1,58 @@
+import importlib.util
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from fastapi.testclient import TestClient
+
+TEMPLATE_DIR = Path("aai_cli/init/templates/stream")
+
+
+def _load_app():
+    spec = importlib.util.spec_from_file_location("_tmpl_stream", TEMPLATE_DIR / "api" / "index.py")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _ok_response(token="tok-123"):
+    resp = MagicMock()
+    resp.json.return_value = {"token": token}
+    resp.raise_for_status.return_value = None
+    return resp
+
+
+def test_token_returns_token_and_streaming_ws_url(monkeypatch):
+    mod = _load_app()
+    monkeypatch.setattr(mod.httpx, "get", lambda *a, **k: _ok_response())
+    resp = TestClient(mod.app).post("/api/token")
+    assert resp.status_code == 200
+    body = resp.json()
+    assert body["token"] == "tok-123"
+    assert body["ws_url"].startswith("wss://") and body["ws_url"].endswith("/v3/ws")
+
+
+def test_token_uses_raw_authorization_header(monkeypatch):
+    # The streaming token uses the raw key as Authorization (NOT Bearer).
+    monkeypatch.setenv("ASSEMBLYAI_API_KEY", "sk-test")
+    mod = _load_app()
+    captured = {}
+
+    def fake_get(url, params=None, headers=None):
+        captured.update(url=url, headers=headers)
+        return _ok_response()
+
+    monkeypatch.setattr(mod.httpx, "get", fake_get)
+    TestClient(mod.app).post("/api/token")
+    assert captured["headers"]["Authorization"] == "sk-test"
+    assert "/v3/token" in captured["url"]
+
+
+def test_token_surfaces_error_as_502(monkeypatch):
+    mod = _load_app()
+
+    def boom(*a, **k):
+        raise RuntimeError("network down")
+
+    monkeypatch.setattr(mod.httpx, "get", boom)
+    resp = TestClient(mod.app).post("/api/token")
+    assert resp.status_code == 502
diff --git a/tests/test_init_template_transcribe.py b/tests/test_init_template_transcribe.py
new file mode 100644
index 00000000..7c3b32c1
--- /dev/null
+++ b/tests/test_init_template_transcribe.py
@@ -0,0 +1,183 @@
+import importlib.util
+import sys
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from fastapi.testclient import TestClient
+
+TEMPLATE_DIR = Path("aai_cli/init/templates/transcribe")
+
+
+def _load_app(monkeypatch):
+    """Import the template's api/index.py as a module and return its FastAPI app.
+
+    The template is a standalone project (not part of aai_cli's import graph), so we
+    load it by file path. The assemblyai SDK is stubbed so no network/key is needed.
+    """
+    fake_aai = MagicMock()
+    fake_aai.TranscriptStatus.completed = "completed"
+    fake_aai.TranscriptStatus.error = "error"
+    submitted = MagicMock(id="t-123")
+    fake_aai.Transcriber.return_value.submit.return_value = submitted
+
+    # The template fetches status via the SDK's non-blocking api.get_transcript,
+    # so stub the assemblyai.api and assemblyai.client submodules too.
+    fake_api = MagicMock()
+    done = MagicMock(status="completed", error=None)
+    done.dict.return_value = {"text": "hello world", "utterances": []}
+    fake_api.get_transcript.return_value = done
+    fake_client = MagicMock()
+
+    monkeypatch.setitem(sys.modules, "assemblyai", fake_aai)
+    monkeypatch.setitem(sys.modules, "assemblyai.api", fake_api)
+    monkeypatch.setitem(sys.modules, "assemblyai.client", fake_client)
+
+    spec = importlib.util.spec_from_file_location(
+        "_tmpl_transcribe", TEMPLATE_DIR / "api" / "index.py"
+    )
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module.app, fake_aai, fake_api
+
+
+def test_required_files_exist():
+    for rel in (
+        "api/index.py",
+        "index.html",
+        "vercel.json",
+        "requirements.txt",
+        "README.md",
+        "gitignore",
+        "env.example",
+    ):
+        assert (TEMPLATE_DIR / rel).exists(), rel
+
+
+def test_template_ships_no_real_key():
+    assert not (TEMPLATE_DIR / ".env").exists()
+    assert "your_assemblyai_api_key_here" in (TEMPLATE_DIR / "env.example").read_text()
+
+
+def test_base_url_env_is_applied(monkeypatch):
+    # aai init writes ASSEMBLYAI_BASE_URL so a sandbox key targets the sandbox host.
+    monkeypatch.setenv("ASSEMBLYAI_BASE_URL", "https://api.sb.example")
+    _app, fake, _api = _load_app(monkeypatch)
+    assert fake.settings.base_url == "https://api.sb.example"
+
+
+def test_page_explores_all_features_and_speakers():
+    # Guard the UI surface: each audio-intelligence view + per-speaker coloring stay wired.
+    html = (TEMPLATE_DIR / "index.html").read_text()
+    for token in (
+        "chapters",
+        "sentiment_analysis_results",
+        "entities",
+        "auto_highlights_result",
+        "speakerColor",
+        "/api/ask",  # the LLM Gateway Q&A panel
+    ):
+        assert token in html, token
+
+
+def test_ask_calls_llm_gateway_with_transcript_id(monkeypatch):
+    # Stub the OpenAI SDK before the template module imports it.
+    fake_openai = MagicMock()
+    msg = MagicMock()
+    msg.content = "It's about wildfires."
+    fake_openai.OpenAI.return_value.chat.completions.create.return_value = MagicMock(
+        choices=[MagicMock(message=msg)]
+    )
+    monkeypatch.setitem(sys.modules, "openai", fake_openai)
+
+    app, _aai, _api = _load_app(monkeypatch)
+    client = TestClient(app)
+    resp = client.post("/api/ask", json={"transcript_id": "t-1", "question": "What is this about?"})
+    assert resp.status_code == 200
+    assert "wildfires" in resp.json()["answer"]
+    # The gateway injects the transcript server-side via extra_body, not inline.
+    kwargs = fake_openai.OpenAI.return_value.chat.completions.create.call_args.kwargs
+    assert kwargs["extra_body"] == {"transcript_id": "t-1"}
+
+
+def test_index_route_serves_page(monkeypatch):
+    app, _aai, _api = _load_app(monkeypatch)
+    client = TestClient(app)
+    resp = client.get("/")
+    assert resp.status_code == 200
+    assert "<html" in resp.text.lower()
+
+
+def test_submit_returns_transcript_id(monkeypatch):
+    app, fake, _api = _load_app(monkeypatch)
+    client = TestClient(app)
+    resp = client.post("/api/transcribe", files={"file": ("a.mp3", b"\x00\x01", "audio/mpeg")})
+    assert resp.status_code == 200
+    assert resp.json() == {"id": "t-123"}
+    fake.Transcriber.return_value.submit.assert_called_once()
+
+
+def test_transcribe_url_submits_given_url(monkeypatch):
+    app, fake, _api = _load_app(monkeypatch)
+    client = TestClient(app)
+    resp = client.post("/api/transcribe-url", json={"url": "https://example.com/a.mp3"})
+    assert resp.status_code == 200
+    assert resp.json() == {"id": "t-123"}
+    submitted = fake.Transcriber.return_value.submit.call_args[0][0]
+    assert submitted == "https://example.com/a.mp3"  # URL passed straight through, no upload
+
+
+def test_transcribe_url_defaults_to_sample(monkeypatch):
+    app, fake, _api = _load_app(monkeypatch)
+    client = TestClient(app)
+    resp = client.post("/api/transcribe-url", json={})  # no url -> the bundled sample
+    assert resp.status_code == 200
+    submitted = fake.Transcriber.return_value.submit.call_args[0][0]
+    assert "wildfires" in submitted
+
+
+def test_status_returns_completed_transcript(monkeypatch):
+    app, _aai, _api = _load_app(monkeypatch)
+    client = TestClient(app)
+    resp = client.get("/api/status/t-123")
+    assert resp.status_code == 200
+    body = resp.json()
+    assert body["status"] == "completed"
+    assert body["transcript"]["text"] == "hello world"
+
+
+def test_status_returns_processing_when_not_done(monkeypatch):
+    # A poll endpoint MUST report a non-terminal status without blocking. This guards
+    # against regressing to the blocking aai.Transcript.get_by_id() (which would only
+    # ever return completed/error, making this branch dead code).
+    app, _aai, fake_api = _load_app(monkeypatch)
+    fake_api.get_transcript.return_value = MagicMock(status="processing", error=None)
+    client = TestClient(app)
+    resp = client.get("/api/status/t-xyz")
+    assert resp.status_code == 200
+    assert resp.json() == {"status": "processing"}
+
+
+def test_status_returns_502_on_error(monkeypatch):
+    app, _aai, fake_api = _load_app(monkeypatch)
+    fake_api.get_transcript.return_value = MagicMock(status="error", error="bad audio")
+    client = TestClient(app)
+    resp = client.get("/api/status/t-bad")
+    assert resp.status_code == 502
+
+
+def test_submit_surfaces_sdk_exception_as_502_not_500(monkeypatch):
+    # A missing/invalid key makes the SDK raise; the endpoint must return a clean 502,
+    # not let the exception bubble into a 500 traceback.
+    app, fake, _api = _load_app(monkeypatch)
+    fake.Transcriber.return_value.submit.side_effect = ValueError("Please provide an API key")
+    client = TestClient(app)
+    resp = client.post("/api/transcribe-url", json={"url": "https://example.com/a.mp3"})
+    assert resp.status_code == 502
+
+
+def test_status_surfaces_sdk_exception_as_502_not_500(monkeypatch):
+    app, _aai, fake_api = _load_app(monkeypatch)
+    fake_api.get_transcript.side_effect = RuntimeError("network down")
+    client = TestClient(app)
+    resp = client.get("/api/status/t-x")
+    assert resp.status_code == 502
diff --git a/tests/test_init_templates.py b/tests/test_init_templates.py
new file mode 100644
index 00000000..9f8670c5
--- /dev/null
+++ b/tests/test_init_templates.py
@@ -0,0 +1,46 @@
+from pathlib import Path
+
+from aai_cli.init import templates
+
+_TEMPLATES_ROOT = Path("aai_cli/init/templates")
+
+
+def test_transcribe_is_registered():
+    assert "transcribe" in templates.TEMPLATES
+    assert "transcribe" in templates.TEMPLATE_ORDER
+
+
+def test_order_matches_registry():
+    # Every ordered id is registered and vice versa (no stray/missing entries).
+    assert set(templates.TEMPLATE_ORDER) == set(templates.TEMPLATES)
+    assert len(templates.TEMPLATE_ORDER) == len(templates.TEMPLATES)
+
+
+def test_every_registered_template_has_a_directory():
+    # The registry must never advertise a template whose files don't ship — that
+    # would crash `aai init <id>` with a FileNotFoundError. This guards the picker.
+    for tid in templates.TEMPLATES:
+        assert (_TEMPLATES_ROOT / tid / "api" / "index.py").exists(), (
+            f"template {tid!r} is registered but aai_cli/init/templates/{tid}/ is missing"
+        )
+
+
+def test_every_shipped_directory_is_registered():
+    # The other direction: a template dir that ships but isn't registered is invisible
+    # in the picker and unreachable via `aai init <id>`. Together with the test above
+    # this enforces registry == shipped directories.
+    for path in _TEMPLATES_ROOT.iterdir():
+        if path.is_dir() and not path.name.startswith("__"):
+            assert path.name in templates.TEMPLATES, (
+                f"aai_cli/init/templates/{path.name}/ ships but isn't registered in TEMPLATES"
+            )
+
+
+def test_title_for_known_and_unknown():
+    assert "Transcribe" in templates.title_for("transcribe")
+    assert templates.title_for("nope") == "nope"  # falls back to the raw id
+
+
+def test_is_template():
+    assert templates.is_template("transcribe") is True
+    assert templates.is_template("nope") is False
diff --git a/tests/test_smoke.py b/tests/test_smoke.py
index a55891b5..10213deb 100644
--- a/tests/test_smoke.py
+++ b/tests/test_smoke.py
@@ -51,6 +51,7 @@ def test_help_lists_commands_in_workflow_order():
         "whoami",
         "doctor",
         "samples",
+        "init",
         "claude",
         "version",
     ]
diff --git a/tests/test_steps.py b/tests/test_steps.py
new file mode 100644
index 00000000..915bc41b
--- /dev/null
+++ b/tests/test_steps.py
@@ -0,0 +1,21 @@
+from aai_cli import steps
+
+
+def test_render_steps_includes_name_status_detail():
+    data = [
+        {"name": "scaffold", "status": "created", "detail": "./my-app"},
+        {"name": "install", "status": "skipped", "detail": "--no-install"},
+    ]
+    out = steps.render_steps(data, heading="aai init:")
+    assert "scaffold" in out
+    assert "created" in out
+    assert "./my-app" in out
+    assert "install" in out
+    assert "skipped" in out
+
+
+def test_render_steps_uses_given_heading():
+    out = steps.render_steps(
+        [{"name": "scaffold", "status": "created", "detail": "x"}], heading="aai init:"
+    )
+    assert "aai init:" in out
diff --git a/uv.lock b/uv.lock
index 467b4b6e..da6fc03b 100644
--- a/uv.lock
+++ b/uv.lock
@@ -19,6 +19,7 @@ dependencies = [
     { name = "keyring" },
     { name = "openai" },
     { name = "platformdirs" },
+    { name = "questionary" },
     { name = "rich" },
     { name = "sounddevice" },
     { name = "tomli-w" },
@@ -29,18 +30,23 @@ dependencies = [
 
 [package.optional-dependencies]
 dev = [
+    { name = "fastapi" },
     { name = "hypothesis" },
     { name = "mypy" },
     { name = "pre-commit" },
     { name = "pytest" },
     { name = "pytest-cov" },
+    { name = "python-dotenv" },
+    { name = "python-multipart" },
     { name = "ruff" },
+    { name = "uvicorn" },
 ]
 
 [package.metadata]
 requires-dist = [
     { name = "assemblyai", specifier = ">=0.64.4" },
     { name = "audioop-lts", marker = "python_full_version >= '3.13'", specifier = ">=0.2" },
+    { name = "fastapi", marker = "extra == 'dev'", specifier = ">=0.115.0" },
     { name = "httpx", specifier = ">=0.28.1" },
     { name = "hypothesis", marker = "extra == 'dev'", specifier = ">=6.155.1" },
     { name = "keyring", specifier = ">=25.7.0" },
@@ -50,11 +56,15 @@ requires-dist = [
     { name = "pre-commit", marker = "extra == 'dev'", specifier = ">=4.6.0" },
     { name = "pytest", marker = "extra == 'dev'", specifier = ">=9.0.3" },
     { name = "pytest-cov", marker = "extra == 'dev'", specifier = ">=7.1.0" },
+    { name = "python-dotenv", marker = "extra == 'dev'", specifier = ">=1.0.0" },
+    { name = "python-multipart", marker = "extra == 'dev'", specifier = ">=0.0.9" },
+    { name = "questionary", specifier = ">=2.0.1" },
     { name = "rich", specifier = ">=15.0.0" },
     { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.15.15" },
     { name = "sounddevice", specifier = ">=0.5.5" },
     { name = "tomli-w", specifier = ">=1.2.0" },
     { name = "typer", specifier = ">=0.26.7" },
+    { name = "uvicorn", marker = "extra == 'dev'", specifier = ">=0.30.0" },
     { name = "websockets", specifier = ">=16.0" },
     { name = "yt-dlp", specifier = ">=2026.3.17" },
 ]
@@ -313,6 +323,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" },
 ]
 
+[[package]]
+name = "click"
+version = "8.4.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9b/98/518d8e5081007684232226f475082b30087d0f585e8457db087298259f49/click-8.4.1.tar.gz", hash = "sha256:918b5633eddf6b41c32d4f454bf0de810065c74e3f7dbf8ee5452f8be88d3e96", size = 353007, upload-time = "2026-05-22T04:08:37.769Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/0d/67e5b4109ea4a837e80daa87c2c696711955e40449a97e8926672534def2/click-8.4.1-py3-none-any.whl", hash = "sha256:482be17c6991b8c19c5429a1e995d9b0efdbb63172824c41f99965dc0ade8ec2", size = 116639, upload-time = "2026-05-22T04:08:35.26Z" },
+]
+
 [[package]]
 name = "colorama"
 version = "0.4.6"
@@ -519,6 +541,22 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" },
 ]
 
+[[package]]
+name = "fastapi"
+version = "0.136.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "pydantic" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/81/2d/ff8d91d7b564d464629a0fd50a4489c97fcb836ac230bf3a7269232a9b1f/fastapi-0.136.3.tar.gz", hash = "sha256:e487fae93ad408e6f47641ee4dfe389864fd7bec92e547ea8498fc13f43e83ab", size = 396410, upload-time = "2026-05-23T18:53:15.192Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/82/45359b62a067409bd929ae8a56b8ed13e5a8c8a61194b3c236920999ab83/fastapi-0.136.3-py3-none-any.whl", hash = "sha256:3d2a69bdf04b7e9f3afa292c3bc7a98816bbfafa10bc9b45f3f3700d2f761620", size = 117481, upload-time = "2026-05-23T18:53:16.924Z" },
+]
+
 [[package]]
 name = "filelock"
 version = "3.29.0"
@@ -1046,6 +1084,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/80/6e/4b28b62ecb6aae56769c34a8ff1d661473ec1e9519e2d5f8b2c150086b26/pre_commit-4.6.0-py2.py3-none-any.whl", hash = "sha256:e2cf246f7299edcabcf15f9b0571fdce06058527f0a06535068a86d38089f29b", size = 226472, upload-time = "2026-04-21T20:31:40.092Z" },
 ]
 
+[[package]]
+name = "prompt-toolkit"
+version = "3.0.52"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wcwidth" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" },
+]
+
 [[package]]
 name = "pycparser"
 version = "3.0"
@@ -1263,6 +1313,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },
 ]
 
+[[package]]
+name = "python-multipart"
+version = "0.0.29"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4e/fe/70bd71a6738b09a0bdf6480ca6436b167469ca4578b2a0efbe390b4b0e70/python_multipart-0.0.29.tar.gz", hash = "sha256:643e93849196645e2dbdd81a0f8829a23123ad7f797a84a364c6fb3563f18904", size = 45678, upload-time = "2026-05-17T17:29:47.654Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8f/cb/769cfc37177252872a45a71f3fbdde9d51b471a3f3c14bfe95dde3407386/python_multipart-0.0.29-py3-none-any.whl", hash = "sha256:2ddcc971cef266225f54f552d8fa10bcfbb1f14446caec199060daac59ff2d69", size = 29640, upload-time = "2026-05-17T17:29:45.69Z" },
+]
+
 [[package]]
 name = "pywin32-ctypes"
 version = "0.2.3"
@@ -1336,6 +1395,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
 ]
 
+[[package]]
+name = "questionary"
+version = "2.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "prompt-toolkit" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f6/45/eafb0bba0f9988f6a2520f9ca2df2c82ddfa8d67c95d6625452e97b204a5/questionary-2.1.1.tar.gz", hash = "sha256:3d7e980292bb0107abaa79c68dd3eee3c561b83a0f89ae482860b181c8bd412d", size = 25845, upload-time = "2025-08-28T19:00:20.851Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3c/26/1062c7ec1b053db9e499b4d2d5bc231743201b74051c973dadeac80a8f43/questionary-2.1.1-py3-none-any.whl", hash = "sha256:a51af13f345f1cdea62347589fbb6df3b290306ab8930713bfae4d475a7d4a59", size = 36753, upload-time = "2025-08-28T19:00:19.56Z" },
+]
+
 [[package]]
 name = "rich"
 version = "15.0.0"
@@ -1430,6 +1501,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/4e/39/a61d4b83a7746b70d23d9173be688c0c6bfc7173772344b7442c2c155497/sounddevice-0.5.5-py3-none-win_arm64.whl", hash = "sha256:3861901ddd8230d2e0e8ae62ac320cdd4c688d81df89da036dcb812f757bb3e6", size = 317115, upload-time = "2026-01-23T18:36:42.235Z" },
 ]
 
+[[package]]
+name = "starlette"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c5/bf/616a066c2760f6c2b1ae3437cc28149734d069fbb46511712beae118a68c/starlette-1.2.0.tar.gz", hash = "sha256:3c5a6b23fff42492914e93890bb80cbfea72dbf37de268eec06185d62a4ca553", size = 2668923, upload-time = "2026-05-28T11:42:50.568Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9f/85/492183764d5d01d4514be3730fdb8e228a80605783099551c51627578b5d/starlette-1.2.0-py3-none-any.whl", hash = "sha256:36e0c76ac59157e75dc4b3bdeafba97fb04eaf1878045f15dbef666a6f092ed7", size = 73213, upload-time = "2026-05-28T11:42:48.801Z" },
+]
+
 [[package]]
 name = "tomli"
 version = "2.4.1"
@@ -1541,6 +1625,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
 ]
 
+[[package]]
+name = "uvicorn"
+version = "0.48.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "h11" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e6/bf/f6544ba992ddb9a6077343a576f9844f7f8f06ab819aefd00206e9255f18/uvicorn-0.48.0.tar.gz", hash = "sha256:a5504207195d08c2511bf9125ede5ac4a4b71725d519e758d01dcf0bc2d31c37", size = 91074, upload-time = "2026-05-24T12:08:41.925Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/01/be/72532be3da7acc5fdfbccdb95215cd04f995a0886532a5b423f929cda4cc/uvicorn-0.48.0-py3-none-any.whl", hash = "sha256:48097851328b87ec36117d3d575234519eb58c2b22d79666e9bbc6c49a761dad", size = 71410, upload-time = "2026-05-24T12:08:40.258Z" },
+]
+
 [[package]]
 name = "virtualenv"
 version = "21.3.3"
@@ -1557,6 +1655,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f4/34/a9dbe051de88a63eb7408ea66630bac38e72f7f6077d4be58737106860d9/virtualenv-21.3.3-py3-none-any.whl", hash = "sha256:7d5987d8369e098e41406efb780a3d4ca79280097293899e351a6407ee153ab3", size = 7594554, upload-time = "2026-05-13T18:01:27.815Z" },
 ]
 
+[[package]]
+name = "wcwidth"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2c/ee/afaf0f85a9a18fe47a67f1e4422ed6cf1fe642f0ae0a2f81166231303c52/wcwidth-0.7.0.tar.gz", hash = "sha256:90e3a7ea092341c44b99562e75d09e4d5160fe7a3974c6fb842a101a95e7eed0", size = 182132, upload-time = "2026-05-02T16:04:12.653Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/41/52/e465037f5375f43533d1a80b6923955201596a99142ed524d77b571a1418/wcwidth-0.7.0-py3-none-any.whl", hash = "sha256:5d69154c429a82910e241c738cd0e2976fac8a2dd47a1a805f4afed1c0f136f2", size = 110825, upload-time = "2026-05-02T16:04:11.033Z" },
+]
+
 [[package]]
 name = "websockets"
 version = "16.0"