inTandem 0.1.0__tar.gz

intandem-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+.venv/
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+dist/
+build/
+*.egg-info/

intandem-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jack Mumo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

intandem-0.1.0/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.5
+Name: inTandem
+Version: 0.1.0
+Summary: Let a cheaper model write the code while your best model plans and reviews it
+Project-URL: Homepage, https://github.com/mumoj/inTandem
+Project-URL: Documentation, https://github.com/mumoj/inTandem/blob/main/docs/usage.md
+Project-URL: Issues, https://github.com/mumoj/inTandem/issues
+Author: Jack Mumo
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-agents,claude-code,codex,mcp,opencode
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: fastapi>=0.115
+Requires-Dist: httpx-sse>=0.4
+Requires-Dist: httpx>=0.28
+Requires-Dist: mcp>=1.20
+Requires-Dist: pydantic-settings>=2.6
+Requires-Dist: pydantic>=2.9
+Requires-Dist: typer>=0.15
+Requires-Dist: uvicorn>=0.32
+Description-Content-Type: text/markdown
+
+# inTandem
+
+**Let a cheaper model write the code while your best model plans and reviews it.**
+
+Your planner (Claude Code or Codex) writes a spec. inTandem hands it to a cheaper model running
+in [OpenCode](https://opencode.ai), watches the work, and tells the planner exactly why it stopped.
+It checks what the implementer did instead of taking its word, and you can step in from a browser
+or your phone.
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/mumoj/inTandem/main/docs/overview.svg" width="900"
+       alt="A planner sends a spec to inTandem, which prompts a cheaper model in OpenCode. It edits your repo, and inTandem returns a verified result. You can allow or deny requests from a dashboard or phone.">
+</p>
+
+## Why use it
+
+- **Spend less.** Your most capable model only plans and reviews, and any model OpenCode supports does the typing.
+- **Trust the result.** A result only counts if it's fresh, and you review the real diff.
+- **Protect what matters.** Mark files as off limits. inTandem blocks edits and catches any that slip through.
+- **Never get stuck.** You get an alert when the implementer needs you, stalls or goes quiet.
+- **Work in parallel.** Run several implementers at once, each on its own branch.
+
+## Install
+
+You need Python 3.12+, [uv](https://docs.astral.sh/uv/) and OpenCode 1.x.
+
+```bash
+npm i -g opencode-ai@1          # OpenCode 2 isn't supported yet
+opencode auth login             # connect a model provider
+uv tool install intandem        # puts `inTandem` on your PATH
+```
+
+## Connect your planner
+
+Register inTandem once:
+
+```bash
+claude mcp add inTandem --scope user -- inTandem mcp      # Claude Code
+codex mcp add inTandem -- inTandem mcp                    # Codex
+```
+
+There's nothing else to start. inTandem runs when your planner connects and stops when it exits.
+
+## Run your first task
+
+Ask your planner to delegate something:
+
+> Have a cheaper model write the tests for citations.py through inTandem.
+
+It writes the spec, waits for the work and reviews the result. Its first reply includes a
+**dashboard link**, where you can watch live and approve or deny requests.
+
+To set a default model or protect files for every task, add them when you register:
+
+```bash
+claude mcp add inTandem --scope user \
+  -e INTANDEM_MODEL=openrouter/qwen/qwen3-coder \
+  -e 'INTANDEM_PROTECTED=["instruction.md"]' \
+  -- inTandem mcp
+```
+
+## Step in from a terminal
+
+The same controls work from the command line, including over SSH from your phone:
+
+```bash
+inTandem status      # what it's doing right now
+inTandem pending     # what it's waiting on
+inTandem allow       # or: inTandem deny --message "leave that file alone"
+inTandem cost        # what it has spent
+```
+
+## Learn more
+
+| | |
+| --- | --- |
+| [Usage guide](https://github.com/mumoj/inTandem/blob/main/docs/usage.md) | Parallel implementers, the CLI, exit codes, alerts and configuration |
+| [How it works](https://github.com/mumoj/inTandem/blob/main/docs/architecture.md) | Architecture, what it enforces and design notes |
+| [Development](https://github.com/mumoj/inTandem/blob/main/docs/development.md) | Running the tests and releasing |
+| [Planner skill](https://github.com/mumoj/inTandem/blob/main/skills/intandem-planner/SKILL.md) | The planner loop as an Agent Skill |

intandem-0.1.0/README.md

@@ -0,0 +1,80 @@
+# inTandem
+
+**Let a cheaper model write the code while your best model plans and reviews it.**
+
+Your planner (Claude Code or Codex) writes a spec. inTandem hands it to a cheaper model running
+in [OpenCode](https://opencode.ai), watches the work, and tells the planner exactly why it stopped.
+It checks what the implementer did instead of taking its word, and you can step in from a browser
+or your phone.
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/mumoj/inTandem/main/docs/overview.svg" width="900"
+       alt="A planner sends a spec to inTandem, which prompts a cheaper model in OpenCode. It edits your repo, and inTandem returns a verified result. You can allow or deny requests from a dashboard or phone.">
+</p>
+
+## Why use it
+
+- **Spend less.** Your most capable model only plans and reviews, and any model OpenCode supports does the typing.
+- **Trust the result.** A result only counts if it's fresh, and you review the real diff.
+- **Protect what matters.** Mark files as off limits. inTandem blocks edits and catches any that slip through.
+- **Never get stuck.** You get an alert when the implementer needs you, stalls or goes quiet.
+- **Work in parallel.** Run several implementers at once, each on its own branch.
+
+## Install
+
+You need Python 3.12+, [uv](https://docs.astral.sh/uv/) and OpenCode 1.x.
+
+```bash
+npm i -g opencode-ai@1          # OpenCode 2 isn't supported yet
+opencode auth login             # connect a model provider
+uv tool install intandem        # puts `inTandem` on your PATH
+```
+
+## Connect your planner
+
+Register inTandem once:
+
+```bash
+claude mcp add inTandem --scope user -- inTandem mcp      # Claude Code
+codex mcp add inTandem -- inTandem mcp                    # Codex
+```
+
+There's nothing else to start. inTandem runs when your planner connects and stops when it exits.
+
+## Run your first task
+
+Ask your planner to delegate something:
+
+> Have a cheaper model write the tests for citations.py through inTandem.
+
+It writes the spec, waits for the work and reviews the result. Its first reply includes a
+**dashboard link**, where you can watch live and approve or deny requests.
+
+To set a default model or protect files for every task, add them when you register:
+
+```bash
+claude mcp add inTandem --scope user \
+  -e INTANDEM_MODEL=openrouter/qwen/qwen3-coder \
+  -e 'INTANDEM_PROTECTED=["instruction.md"]' \
+  -- inTandem mcp
+```
+
+## Step in from a terminal
+
+The same controls work from the command line, including over SSH from your phone:
+
+```bash
+inTandem status      # what it's doing right now
+inTandem pending     # what it's waiting on
+inTandem allow       # or: inTandem deny --message "leave that file alone"
+inTandem cost        # what it has spent
+```
+
+## Learn more
+
+| | |
+| --- | --- |
+| [Usage guide](https://github.com/mumoj/inTandem/blob/main/docs/usage.md) | Parallel implementers, the CLI, exit codes, alerts and configuration |
+| [How it works](https://github.com/mumoj/inTandem/blob/main/docs/architecture.md) | Architecture, what it enforces and design notes |
+| [Development](https://github.com/mumoj/inTandem/blob/main/docs/development.md) | Running the tests and releasing |
+| [Planner skill](https://github.com/mumoj/inTandem/blob/main/skills/intandem-planner/SKILL.md) | The planner loop as an Agent Skill |

intandem-0.1.0/pyproject.toml

@@ -0,0 +1,101 @@
+[project]
+name = "inTandem"
+version = "0.1.0"
+description = "Let a cheaper model write the code while your best model plans and reviews it"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+authors = [{ name = "Jack Mumo" }]
+keywords = ["ai-agents", "claude-code", "codex", "mcp", "opencode"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development",
+    "Typing :: Typed",
+]
+dependencies = [
+    "fastapi>=0.115",
+    "httpx>=0.28",
+    "httpx-sse>=0.4",
+    "mcp>=1.20",
+    "pydantic>=2.9",
+    "pydantic-settings>=2.6",
+    "typer>=0.15",
+    "uvicorn>=0.32",
+]
+
+[project.scripts]
+inTandem = "intandem.cli:app"
+
+[project.urls]
+Homepage = "https://github.com/mumoj/inTandem"
+Documentation = "https://github.com/mumoj/inTandem/blob/main/docs/usage.md"
+Issues = "https://github.com/mumoj/inTandem/issues"
+
+[dependency-groups]
+dev = [
+    "pyright>=1.1.390",
+    "pytest>=8.3",
+    "pytest-asyncio>=0.25",
+    "respx>=0.22",
+    "ruff>=0.8",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/intandem"]
+
+# Only what a source build needs: stray files in the checkout must never ship.
+[tool.hatch.build.targets.sdist]
+only-include = ["src", "LICENSE", "README.md", "pyproject.toml"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = [
+    "E", "W", "F",   # pycodestyle, pyflakes
+    "I",             # import order
+    "UP",            # modern syntax
+    "B",             # likely bugs
+    "SIM",           # simpler forms
+    "C4",            # comprehensions
+    "RUF",           # ruff's own checks
+    "ASYNC",         # blocking calls inside async code
+    "PTH",           # pathlib over os.path
+    "PT",            # pytest style
+    "N",             # naming
+]
+
+[tool.ruff.lint.per-file-ignores]
+# Typer reads option metadata from default values, which is exactly what B008 flags.
+"src/intandem/cli/*.py" = ["B008"]
+
+[tool.pyright]
+include = ["src", "tests"]
+pythonVersion = "3.12"
+typeCheckingMode = "strict"
+venvPath = "."
+venv = ".venv"
+# Tests poke at private state on purpose and lean on fixtures pyright cannot see through.
+executionEnvironments = [
+    { root = "tests", extraPaths = [".", "src"], reportPrivateUsage = false, reportUnknownMemberType = false, reportUnknownArgumentType = false, reportUnknownVariableType = false, reportMissingParameterType = false, reportUnknownParameterType = false, reportUnknownLambdaType = false },
+    { root = "src" },
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+markers = [
+    "e2e: drives a real `opencode serve` with a scripted model (needs OpenCode 1.x)",
+]
+addopts = "-ra"

intandem-0.1.0/src/intandem/__init__.py

@@ -0,0 +1,3 @@
+"""Supervise a headless OpenCode implementer for a frontier-model planner."""
+
+__version__ = "0.1.0"

intandem-0.1.0/src/intandem/__main__.py

@@ -0,0 +1,3 @@
+from intandem.cli import app
+
+app(prog_name="inTandem")

intandem-0.1.0/src/intandem/bridge/__init__.py

@@ -0,0 +1,6 @@
+"""The authenticated control API over the supervisor."""
+
+from intandem.bridge.app import create_app
+from intandem.bridge.manifest import Manifest
+
+__all__ = ["Manifest", "create_app"]

intandem-0.1.0/src/intandem/bridge/app.py

@@ -0,0 +1,318 @@
+"""The control bridge: a narrow, authenticated HTTP API over the supervisor.
+
+The planner and the human on a phone use the same endpoints, through the same
+``inTandem`` client. Anything the planner can do, the human can do too, and every
+call from either lands in the same journal.
+
+It binds to loopback and deliberately does not proxy OpenCode. A dozen named
+operations keep the trial's networking private and make every intervention an
+explicit, auditable call.
+
+``/ui`` is the one unauthenticated route: a static page holding no data. It
+reads the token from its URL fragment, which browsers never send to a server,
+and calls the same authenticated endpoints as everyone else.
+"""
+
+from __future__ import annotations
+
+import hmac
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from importlib.resources import files
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, FastAPI, HTTPException, Query, Request, Response, status
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from starlette.datastructures import Headers
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+from intandem import __version__
+from intandem.bridge.schemas import (
+    AnswerIn,
+    DiffOut,
+    DirectiveIn,
+    DirectiveOut,
+    JournalOut,
+    MessageOut,
+    MessagesOut,
+    Ok,
+    OpenCodeOut,
+    OverviewOut,
+    PermissionIn,
+    PromptIn,
+    ResultOut,
+    RetractIn,
+    SpecIn,
+    SpecOut,
+    WaitOut,
+)
+from intandem.opencode.client import NotFoundError, OpenCodeError
+from intandem.supervisor.state import SpecRecord
+from intandem.supervisor.supervisor import (
+    CostReport,
+    Pending,
+    StatusReport,
+    Supervisor,
+    SupervisorError,
+)
+
+MAX_BODY_BYTES = 64 * 1024
+
+_bearer = HTTPBearer(auto_error=False, description="The token from the manifest.")
+
+
+def get_supervisor(request: Request) -> Supervisor:
+    supervisor: Supervisor | None = getattr(request.app.state, "supervisor", None)
+    if supervisor is None:
+        raise HTTPException(status.HTTP_503_SERVICE_UNAVAILABLE, "supervisor is starting")
+    return supervisor
+
+
+def require_token(
+    request: Request,
+    credentials: Annotated[HTTPAuthorizationCredentials | None, Depends(_bearer)],
+) -> None:
+    expected: str = request.app.state.token
+    given = credentials.credentials if credentials else ""
+    # Constant-time comparison: the token is the only thing guarding the bridge.
+    if not hmac.compare_digest(given.encode(), expected.encode()):
+        raise HTTPException(
+            status.HTTP_401_UNAUTHORIZED,
+            "missing or wrong bearer token",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+
+SupervisorDep = Annotated[Supervisor, Depends(get_supervisor)]
+
+
+class BodyLimit:
+    """Refuse oversized bodies before anything parses them.
+
+    Plain ASGI rather than ``BaseHTTPMiddleware``, which wraps every request in
+    an extra task and buffers what passes through it.
+    """
+
+    def __init__(self, app: ASGIApp) -> None:
+        self.app = app
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] == "http":
+            length = Headers(scope=scope).get("content-length")
+            if length is not None and (not length.isdigit() or int(length) > MAX_BODY_BYTES):
+                response = JSONResponse(
+                    {"detail": f"request body over {MAX_BODY_BYTES} bytes"},
+                    status_code=status.HTTP_413_CONTENT_TOO_LARGE,
+                )
+                await response(scope, receive, send)
+                return
+        await self.app(scope, receive, send)
+
+
+def _spec_out(supervisor: Supervisor, record: SpecRecord) -> SpecOut:
+    return SpecOut(
+        spec_id=record.spec_id,
+        session_id=record.session_id,
+        status=record.status,
+        result_path=str(supervisor.result_path(record)),
+    )
+
+
+router = APIRouter(dependencies=[Depends(require_token)])
+
+
+@router.get("/status")
+async def read_status(supervisor: SupervisorDep) -> StatusReport:
+    return supervisor.status()
+
+
+@router.get("/overview")
+async def read_overview(supervisor: SupervisorDep) -> OverviewOut:
+    attention = supervisor.attention()
+    return OverviewOut(
+        status=supervisor.status(),
+        attention=attention.reason if attention else None,
+        attention_detail=attention.detail if attention else "",
+        pending=await supervisor.pending(),
+    )
+
+
+@router.get("/journal")
+def read_journal(  # a plain def: FastAPI runs it in its threadpool, off the event loop
+    supervisor: SupervisorDep,
+    after: Annotated[int | None, Query(ge=0)] = None,
+    limit: Annotated[int, Query(gt=0, le=1000)] = 200,
+) -> JournalOut:
+    entries, offset = supervisor.journal.read_from(after, limit)
+    return JournalOut(entries=entries, next=offset)
+
+
+@router.get("/opencode")
+async def read_opencode(request: Request) -> OpenCodeOut:
+    """OpenCode's own web UI for this task, for watching the session live."""
+    login: OpenCodeLogin | None = request.app.state.opencode
+    return OpenCodeOut(url=login.url if login else None, password=login.password if login else None)
+
+
+@router.get("/wait")
+async def wait(
+    supervisor: SupervisorDep,
+    seconds: Annotated[float, Query(alias="timeout", gt=0, le=3600)] = 600,
+) -> WaitOut:
+    """Block until the implementer needs the planner, or ``timeout`` seconds pass."""
+    attention = await supervisor.wait(seconds)
+    return WaitOut(reason=attention.reason, detail=attention.detail, status=supervisor.status())
+
+
+@router.get("/messages")
+async def read_messages(
+    supervisor: SupervisorDep, limit: Annotated[int, Query(gt=0, le=500)] = 20
+) -> MessagesOut:
+    messages = await supervisor.messages(limit)
+    record = supervisor.state.current
+    assert record is not None  # messages() already required one
+    return MessagesOut(session_id=record.session_id, messages=[MessageOut.of(m) for m in messages])
+
+
+@router.get("/pending")
+async def read_pending(supervisor: SupervisorDep) -> Pending:
+    return await supervisor.pending()
+
+
+@router.get("/result")
+async def read_result(supervisor: SupervisorDep) -> ResultOut:
+    record = supervisor.state.current
+    path = str(supervisor.result_path(record)) if record else None
+    return ResultOut(path=path, result=supervisor.result())
+
+
+@router.get("/diff")
+async def read_diff(supervisor: SupervisorDep) -> DiffOut:
+    return DiffOut(files=await supervisor.diff())
+
+
+@router.get("/cost")
+async def read_cost(supervisor: SupervisorDep) -> CostReport:
+    return await supervisor.cost()
+
+
+@router.post("/spec")
+async def submit_spec(body: SpecIn, supervisor: SupervisorDep) -> SpecOut:
+    """Start a spec in a fresh session. Idempotent for the same id and text."""
+    record = await supervisor.submit_spec(
+        body.spec_id, body.text, model=body.model, agent=body.agent
+    )
+    return _spec_out(supervisor, record)
+
+
+@router.post("/directive")
+async def send_directive(body: DirectiveIn, supervisor: SupervisorDep) -> DirectiveOut:
+    directive = await supervisor.directive(body.spec_id, body.directive_id, body.action, body.text)
+    return DirectiveOut(
+        spec_id=body.spec_id,
+        directive_id=directive.directive_id,
+        action=directive.action,
+        retracted=directive.retracted,
+    )
+
+
+@router.post("/retract")
+async def retract(body: RetractIn, supervisor: SupervisorDep) -> DirectiveOut:
+    directive = await supervisor.retract(body.spec_id, body.directive_id)
+    return DirectiveOut(
+        spec_id=body.spec_id,
+        directive_id=directive.directive_id,
+        action=directive.action,
+        retracted=directive.retracted,
+    )
+
+
+@router.post("/prompt", status_code=status.HTTP_202_ACCEPTED)
+async def prompt(body: PromptIn, supervisor: SupervisorDep) -> SpecOut:
+    record = await supervisor.say(body.text)
+    return _spec_out(supervisor, record)
+
+
+@router.post("/permission")
+async def reply_permission(body: PermissionIn, supervisor: SupervisorDep) -> Ok:
+    await supervisor.reply_permission(body.id, body.reply, body.message)
+    return Ok(detail=f"{body.id} {body.reply}")
+
+
+@router.post("/answer")
+async def answer(body: AnswerIn, supervisor: SupervisorDep) -> Ok:
+    await supervisor.answer(body.id, None if body.reject else body.answers)
+    return Ok(detail=f"{body.id} {'rejected' if body.reject else 'answered'}")
+
+
+@router.post("/abort")
+async def abort(supervisor: SupervisorDep) -> Ok:
+    record = await supervisor.abort()
+    return Ok(detail=f"aborted the turn on {record.spec_id}; the session stays open")
+
+
+@router.post("/finish")
+async def finish(request: Request) -> Ok:
+    """Stop the supervisor. Evidence is captured on the way out."""
+    on_finish: Callable[[], None] = request.app.state.on_finish
+    on_finish()
+    return Ok(detail="stopping")
+
+
+@dataclass(frozen=True, slots=True)
+class OpenCodeLogin:
+    url: str
+    password: str
+
+
+def dashboard_headers() -> dict[str, str]:
+    """For a page that holds no data and talks only to the server that sent it."""
+    return {
+        "Cache-Control": "no-store",
+        "Referrer-Policy": "no-referrer",
+        "X-Frame-Options": "DENY",
+        "Content-Security-Policy": (
+            "default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; "
+            "connect-src 'self'; img-src data:; base-uri 'none'; form-action 'none'"
+        ),
+    }
+
+
+def _dashboard() -> HTMLResponse:
+    page = files("intandem.bridge").joinpath("dashboard.html").read_text(encoding="utf-8")
+    return HTMLResponse(page, headers=dashboard_headers())
+
+
+def _error(status_code: int) -> Callable[[Request, Exception], Awaitable[Response]]:
+    async def handler(_request: Request, exc: Exception) -> Response:
+        return JSONResponse({"detail": str(exc)}, status_code=status_code)
+
+    return handler
+
+
+def create_app(
+    *,
+    supervisor: Supervisor | None = None,
+    token: str,
+    on_finish: Callable[[], None] = lambda: None,
+    opencode: OpenCodeLogin | None = None,
+) -> FastAPI:
+    app = FastAPI(
+        title="inTandem bridge",
+        version=__version__,
+        description="Drive a supervised OpenCode implementer. Every call needs the bearer token.",
+    )
+    app.state.supervisor = supervisor
+    app.state.token = token
+    app.state.on_finish = on_finish
+    app.state.opencode = opencode
+    app.add_middleware(BodyLimit)
+    app.add_exception_handler(SupervisorError, _error(status.HTTP_409_CONFLICT))
+    # Starlette walks the exception's MRO, so NotFoundError gets its own status even
+    # though it is also an OpenCodeError.
+    app.add_exception_handler(OpenCodeError, _error(status.HTTP_502_BAD_GATEWAY))
+    app.add_exception_handler(NotFoundError, _error(status.HTTP_404_NOT_FOUND))
+    app.include_router(router)
+    app.add_api_route("/ui", _dashboard, methods=["GET"], include_in_schema=False)
+    return app