ags-cli 0.1.0__py3-none-any.whl

harness/api/v1/stream.py

@@ -0,0 +1,110 @@
+"""Server-Sent Events tail of a run's normalized event stream.
+
+The durable ``run_events`` ledger is the source of truth. The in-process bus buffers
+every event per run, so the SSE endpoint *subscribes* for low-latency live push
+(backlog + live tail), with a ledger catch-up and a final ledger sweep as the durable
+backstop. Race-free: a client that connects late still gets the buffered backlog, and
+an already-finished run is served from the ledger.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import uuid
+
+from fastapi import APIRouter
+from fastapi.responses import StreamingResponse
+from sqlalchemy import select
+
+from harness.deps import CurrentPrincipal, DbSession
+from harness.eventbus import get_event_bus
+from harness.models.enums import RunStatus
+from harness.models.run import Run
+from harness.models.run_event import RunEvent
+
+router = APIRouter(tags=["stream"])
+
+_TERMINAL = {
+    RunStatus.succeeded,
+    RunStatus.failed,
+    RunStatus.cancelled,
+    RunStatus.needs_approval,
+}
+_END = "event: end\ndata: {}\n\n"
+
+
+def _frame(e: RunEvent) -> str:
+    payload = {"type": e.type.value, "seq": e.seq, **(e.payload or {})}
+    return f"data: {json.dumps(payload, default=str)}\n\n"
+
+
+def _frame_dict(event: dict) -> str:
+    # Bus events are already in the wire shape ({type, seq, ...payload}).
+    return f"data: {json.dumps(event, default=str)}\n\n"
+
+
+@router.get("/stream/{run_id}")
+async def stream_run(
+    run_id: uuid.UUID,
+    db: DbSession,
+    _: CurrentPrincipal,
+    timeout_s: int = 600,
+    after_seq: int = -1,
+) -> StreamingResponse:
+    async def _new_events(seen: int) -> list[RunEvent]:
+        return list(
+            (
+                await db.execute(
+                    select(RunEvent)
+                    .where(RunEvent.run_id == run_id, RunEvent.seq > seen)
+                    .order_by(RunEvent.seq)
+                )
+            ).scalars()
+        )
+
+    async def _status() -> RunStatus | None:
+        return (
+            await db.execute(select(Run.status).where(Run.id == run_id))
+        ).scalar_one_or_none()
+
+    async def _push_source():
+        """Live push via the in-process bus, ledger as backstop.
+
+        Catch-up starts at ``after_seq`` so a reconnecting client skips already-seen
+        events and resumes exactly where it left off.
+        """
+        bus = get_event_bus()
+        seen = after_seq  # _new_events fetches seq > seen; after_seq=-1 → all events
+        try:
+            async with asyncio.timeout(timeout_s):
+                status = await _status()
+                if status is None:
+                    yield _END
+                    return
+                # Already finished → serve the full ledger and end (buffer may be evicted).
+                if status in _TERMINAL:
+                    for e in await _new_events(seen):
+                        seen = e.seq
+                        yield _frame(e)
+                    yield _END
+                    return
+                # In flight: catch up on anything already committed, then live-subscribe.
+                for e in await _new_events(seen):
+                    seen = e.seq
+                    yield _frame(e)
+                await db.rollback()
+                async for ev in bus.subscribe(str(run_id)):
+                    if ev.get("seq", -1) > seen:
+                        seen = ev["seq"]
+                        yield _frame_dict(ev)
+                # Bus signalled done — final ledger sweep for completeness.
+                await db.rollback()
+                for e in await _new_events(seen):
+                    seen = e.seq
+                    yield _frame(e)
+        except TimeoutError:
+            yield 'data: {"type":"status","status":"stream_timeout"}\n\n'
+        yield _END
+
+    return StreamingResponse(_push_source(), media_type="text/event-stream")

harness/api/v1/tasks.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import uuid
+
+from fastapi import APIRouter, HTTPException
+
+from harness.deps import CurrentPrincipal, DbSession
+from harness.schemas.task import TaskCreate, TaskOut
+from harness.services.tasks import create_task, get_task, list_tasks
+
+router = APIRouter(prefix="/tasks", tags=["tasks"])
+
+
+@router.post("", response_model=TaskOut, status_code=201)
+async def create(payload: TaskCreate, db: DbSession, principal: CurrentPrincipal) -> TaskOut:
+    task = await create_task(db, payload, actor=principal.subject)
+    return TaskOut.model_validate(task)
+
+
+@router.get("", response_model=list[TaskOut])
+async def index(db: DbSession, _: CurrentPrincipal, limit: int = 50) -> list[TaskOut]:
+    return [TaskOut.model_validate(t) for t in await list_tasks(db, limit=limit)]
+
+
+@router.get("/{task_id}", response_model=TaskOut)
+async def get(task_id: uuid.UUID, db: DbSession, _: CurrentPrincipal) -> TaskOut:
+    task = await get_task(db, task_id)
+    if task is None:
+        raise HTTPException(404, "task not found")
+    return TaskOut.model_validate(task)

harness/api/v1/usage.py

@@ -0,0 +1,58 @@
+"""AgentS-tracked usage: per-provider run/token/cost totals from the ledger.
+
+This is *AgentS's own* accounting (every run records a cost event with token
+counts and, where the provider reports it, a USD figure). It is NOT the provider's
+plan quota (5-hour / weekly limits) — those aren't exposed by the `claude`/`agy` CLIs
+in a scriptable way. See `ags quota` for how plan limits are surfaced."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+
+from fastapi import APIRouter
+from sqlalchemy import select
+
+from harness.deps import CurrentPrincipal, DbSession
+from harness.models.provider_config import ProviderConfig
+from harness.models.run import Run
+from harness.models.session import Session
+from harness.models.workspace import Workspace
+
+router = APIRouter(prefix="/usage", tags=["usage"])
+
+
+@router.get("")
+async def usage(db: DbSession, _: CurrentPrincipal, workspace: str | None = None) -> list[dict]:
+    """Per-provider totals across runs, optionally scoped to one workspace.
+
+    Aggregated in Python (cost is a JSON column) — fine for the volumes a single
+    instance sees, and dialect-agnostic across SQLite and Postgres."""
+    pc = {
+        row.id: (row.name, row.kind.value)
+        for row in (await db.execute(select(ProviderConfig))).scalars()
+    }
+
+    stmt = select(Run)
+    if workspace:
+        stmt = (
+            stmt.join(Session, Session.id == Run.session_id)
+            .join(Workspace, Workspace.id == Session.workspace_id)
+            .where(Workspace.slug == workspace)
+        )
+
+    agg: dict[str, dict] = defaultdict(
+        lambda: {"kind": "", "runs": 0, "prompt_tokens": 0,
+                 "completion_tokens": 0, "total_tokens": 0, "usd": 0.0}
+    )
+    for r in (await db.execute(stmt)).scalars():
+        name, kind = pc.get(r.provider_config_id) or (r.adapter_kind.value, r.adapter_kind.value)
+        a = agg[name]
+        a["kind"] = kind
+        a["runs"] += 1
+        c = r.cost or {}
+        a["prompt_tokens"] += int(c.get("prompt_tokens") or 0)
+        a["completion_tokens"] += int(c.get("completion_tokens") or 0)
+        a["total_tokens"] += int(c.get("total_tokens") or 0)
+        a["usd"] += float(c.get("usd") or 0.0)
+
+    return [{"provider": name, **vals} for name, vals in sorted(agg.items())]

harness/bootstrap.py

@@ -0,0 +1,216 @@
+"""Daemonless local-profile bootstrap: config + SQLite schema + seed.
+
+Self-contained (no dependency on the un-packaged ``scripts/`` dir) so it works from an
+installed ``ags`` (``uv tool install``). Invoked unconditionally on app startup
+(``harness/main.py``)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from sqlalchemy import select
+
+from harness.observability.logging import get_logger
+from harness.settings import HOME_DIR, get_settings
+
+log = get_logger("bootstrap")
+
+# Default config written to ~/.ags/config.yaml on first run when none exists,
+# so an installed CLI (outside the repo) has working workspaces + providers. Secrets
+# are referenced by env var only, never stored here.
+DEFAULT_CONFIG = """\
+version: 1
+
+defaults:
+  workspace: default
+  routing_policy: single
+
+workspaces:
+  - slug: default
+    name: Default Workspace
+    trust_policy: restricted
+    default_routing_policy: single
+
+# Only the two CLI-backed agents ship by default. Add an OpenAI-compatible
+# endpoint (OpenAI / Groq / OpenRouter / Ollama / vLLM …) later from the GUI's
+# Adapters page, or by adding a provider block here.
+providers:
+  - name: claude
+    kind: claude_code
+    enabled: true
+    model: claude-opus-4-8
+    secret_ref: env:ANTHROPIC_API_KEY
+    params: { bin: claude, permission_mode: plan, timeout_s: 600 }
+
+  - name: antigravity
+    kind: antigravity
+    enabled: true
+    model: gemini-1.5-pro
+    secret_ref: env:ANTIGRAVITY_API_KEY
+    params: { bin: agy, pty: true, timeout_s: 600 }
+
+routing:
+  policies:
+    - { name: single, mode: single, primary: claude }
+
+memory:
+  session_summary_every_n_events: 20
+  ttl: { session_volatile_hours: 72, workspace_durable_hours: null }
+  retrieval: { top_k: 8, recency_weight: 0.3, relevance_weight: 0.7 }
+
+# MCP servers agents may call (tools namespaced mcp__<name>__<tool>). Disabled by
+# default; add `command`/`args` (stdio) or `url` (http) and set enabled: true.
+mcp:
+  servers: []
+
+# Harness-managed skill library provisioned to spawned CLI agents (claude/agy).
+# The user's project .claude/skills/ load automatically regardless of this.
+skills:
+  managed_dir: ~/.ags/skills
+  inject_index: true
+  bind: { workspaces: [], providers: [claude, antigravity] }
+"""
+
+
+def ensure_config() -> Path:
+    """Write the default config to ~/.ags/config.yaml if no config exists yet.
+    Returns the resolved config path (may be a repo-local config.yaml if present)."""
+    settings = get_settings()
+    configured = Path(settings.config_file).expanduser()
+    if configured.exists():
+        return configured
+    home_cfg = HOME_DIR / "config.yaml"
+    if not home_cfg.exists():
+        HOME_DIR.mkdir(parents=True, exist_ok=True)
+        home_cfg.write_text(DEFAULT_CONFIG)
+        log.info("default_config_written", path=str(home_cfg))
+    return home_cfg
+
+
+async def _seed() -> None:
+    """Seed workspaces + provider configs from config.yaml. Idempotent."""
+    from sqlalchemy import delete
+
+    from harness.db import get_sessionmaker
+    from harness.models.enums import McpTransport, TrustPolicy, adapter_kind_from_config
+    from harness.models.mcp_server_config import McpServerConfig
+    from harness.models.provider_config import ProviderConfig
+    from harness.models.workspace import Workspace
+
+    config = get_settings().config()
+    providers = config.get("providers", [])
+    mcp_servers = (config.get("mcp") or {}).get("servers", [])
+    async with get_sessionmaker()() as db:
+        for ws in config.get("workspaces", []):
+            exists = (
+                await db.execute(select(Workspace).where(Workspace.slug == ws["slug"]))
+            ).scalar_one_or_none()
+            if exists is None:
+                db.add(Workspace(
+                    slug=ws["slug"], name=ws.get("name", ws["slug"]),
+                    trust_policy=TrustPolicy(ws.get("trust_policy", "restricted")),
+                    default_routing_policy=ws.get("default_routing_policy", "single"),
+                ))
+        for p in providers:
+            row = (
+                await db.execute(select(ProviderConfig).where(ProviderConfig.name == p["name"]))
+            ).scalar_one_or_none()
+            if row is None:
+                row = ProviderConfig(name=p["name"])
+                db.add(row)
+            # config.yaml is the declarative source of truth for providers — re-seed
+            # updates existing rows too, so editing the file + restarting applies. (A
+            # runtime `ags model set` is a transient override until the next restart.)
+            # Friendly aliases for the OpenAI-compatible kind so remote endpoints read
+            # naturally (`kind: openai`); normalized to the canonical enum, no DB change.
+            row.kind = adapter_kind_from_config(p["kind"])
+            row.base_url = p.get("base_url")
+            row.model = p.get("model")
+            row.secret_ref = p.get("secret_ref")
+            row.params = p.get("params", {})
+            row.capabilities = p.get("capabilities", {})
+            row.enabled = p.get("enabled", True)
+
+        # Reconcile deletions: providers are created ONLY by seeding from config.yaml,
+        # so a row no longer in the file should be removed (the config is authoritative).
+        # Guard: only prune when the file actually lists providers, so an empty/missing
+        # config can't wipe the table. Runs reference providers via SET NULL, so dropping
+        # one leaves historical runs intact.
+        if providers:
+            keep = [p["name"] for p in providers]
+            await db.execute(
+                delete(ProviderConfig).where(ProviderConfig.name.not_in(keep))
+            )
+
+        # MCP servers — same declarative-source-of-truth contract as providers:
+        # upsert from config.yaml, then prune rows the file no longer lists.
+        for m in mcp_servers:
+            row = (
+                await db.execute(
+                    select(McpServerConfig).where(McpServerConfig.name == m["name"])
+                )
+            ).scalar_one_or_none()
+            if row is None:
+                row = McpServerConfig(name=m["name"])
+                db.add(row)
+            row.transport = McpTransport(m.get("transport", "stdio"))
+            row.command = m.get("command")
+            row.args = m.get("args", [])
+            row.env = m.get("env", {})
+            row.url = m.get("url")
+            row.headers = m.get("headers", {})
+            row.secret_ref = m.get("secret_ref")
+            row.tool_allowlist = m.get("tool_allowlist", [])
+            row.bind = m.get("bind", {})
+            row.read_only = m.get("read_only", False)
+            row.enabled = m.get("enabled", True)
+        if mcp_servers:
+            keep_mcp = [m["name"] for m in mcp_servers]
+            await db.execute(
+                delete(McpServerConfig).where(McpServerConfig.name.not_in(keep_mcp))
+            )
+        await db.commit()
+
+
+# Alembic has been removed from app startup (harness/main.py no longer runs
+# migrations) and the alembic/ directory itself has been deleted. This function
+# is therefore the SOLE schema-migration mechanism for the SQLite DB: any future
+# schema change must add its own ALTER TABLE entry to `wanted` below.
+async def _reconcile_sqlite_columns(conn) -> None:
+    """Add columns that exist in the ORM but not in an older local DB (SQLite has
+    no bundled Alembic on wheel installs; create_all never ALTERs existing tables)."""
+    # (table, column, DDL type + default) — extend when new columns ship.
+    wanted = [
+        ("sessions", "native_sessions", "JSON NOT NULL DEFAULT '{}'"),
+        ("sessions", "settings", "JSON NOT NULL DEFAULT '{}'"),
+        ("runs", "context_meta", "JSON NOT NULL DEFAULT '{}'"),
+    ]
+    for table, col, ddl in wanted:
+        rows = (await conn.exec_driver_sql(f"PRAGMA table_info({table})")).fetchall()
+        names = {r[1] for r in rows}
+        if rows and col not in names:
+            await conn.exec_driver_sql(f"ALTER TABLE {table} ADD COLUMN {col} {ddl}")
+
+
+async def init_local() -> None:
+    """Idempotently prepare the local SQLite instance: config, schema, seed data.
+
+    Invoked by ``ags init`` and (defensively) on every app startup, so the very
+    first ``ags`` command works with zero manual setup."""
+    import harness.models  # noqa: F401  (register all tables on Base.metadata)
+    from harness.db import Base, get_engine
+
+    HOME_DIR.mkdir(parents=True, exist_ok=True)
+    ensure_config()
+    # Clear the settings config cache so a freshly written config is picked up.
+    get_settings()._config_cache = None
+
+    engine = get_engine()
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+        # Reconcile columns missing from an older local DB (create_all never ALTERs
+        # existing tables); only applies to SQLite.
+        if "sqlite" in str(engine.url):
+            await _reconcile_sqlite_columns(conn)
+    await _seed()
+    log.info("local_db_ready", database_url=get_settings().database_url)

harness/db.py

@@ -0,0 +1,164 @@
+"""Async SQLAlchemy engine/session and declarative base.
+
+A single ``AsyncSessionLocal`` factory is shared by the API (via DI) and the
+in-process worker. Models live in ``harness.models`` and register against
+``Base.metadata``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncIterator
+from contextlib import suppress
+from datetime import datetime
+from typing import Any
+
+from sqlalchemy import DateTime, MetaData, event, func
+from sqlalchemy.ext.asyncio import (
+    AsyncEngine,
+    AsyncSession,
+    async_sessionmaker,
+    create_async_engine,
+)
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+from harness.settings import get_settings
+
+try:
+    import sqlite_vec as _sqlite_vec  # type: ignore[import]
+except ImportError:
+    _sqlite_vec = None  # type: ignore[assignment]
+
+# Predictable, collision-free constraint names across tables (index/unique/check/
+# foreign-key/primary-key), independent of declaration order.
+NAMING_CONVENTION = {
+    "ix": "ix_%(column_0_label)s",
+    "uq": "uq_%(table_name)s_%(column_0_name)s",
+    "ck": "ck_%(table_name)s_%(constraint_name)s",
+    "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
+    "pk": "pk_%(table_name)s",
+}
+
+
+class Base(DeclarativeBase):
+    """Declarative base with shared metadata and timestamp mixin columns."""
+
+    metadata = MetaData(naming_convention=NAMING_CONVENTION)
+    type_annotation_map: dict[Any, Any] = {}
+
+
+class TimestampMixin:
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now(), nullable=False
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        server_default=func.now(),
+        onupdate=func.now(),
+        nullable=False,
+    )
+
+
+_engine: AsyncEngine | None = None
+_sessionmaker: async_sessionmaker[AsyncSession] | None = None
+
+
+def get_engine() -> AsyncEngine:
+    global _engine
+    if _engine is None:
+        settings = get_settings()
+        _engine = create_async_engine(
+            settings.database_url,
+            pool_pre_ping=True,
+            future=True,
+        )
+        _enable_sqlite_pragmas(_engine)
+    return _engine
+
+
+def _enable_sqlite_pragmas(engine: AsyncEngine) -> None:
+    """WAL + foreign keys + a busy timeout on every SQLite connection.
+
+    WAL lets the SSE reader poll the run_events ledger while the in-process executor
+    writes to it (concurrent reader + writer), and the busy timeout absorbs brief
+    write-lock contention instead of erroring with 'database is locked'."""
+
+    @event.listens_for(engine.sync_engine, "connect")
+    def _set_pragmas(dbapi_conn, _record):  # noqa: ANN001
+        cur = dbapi_conn.cursor()
+        cur.execute("PRAGMA journal_mode=WAL")
+        cur.execute("PRAGMA synchronous=NORMAL")
+        cur.execute("PRAGMA foreign_keys=ON")
+        cur.execute("PRAGMA busy_timeout=15000")
+        cur.close()
+        # Load sqlite-vec extension when available; failure is silent so the
+        # extension is purely optional — the brute-force path remains active.
+        # SQLAlchemy's aiosqlite adapter wraps the raw connection; we must
+        # use ``dbapi_conn.run_async`` to call the async aiosqlite methods.
+        if _sqlite_vec is not None:
+            try:
+                _path = _sqlite_vec.loadable_path()
+
+                async def _load_sqlite_vec(aiosqlite_conn) -> None:  # noqa: ANN001
+                    await aiosqlite_conn.enable_load_extension(True)
+                    await aiosqlite_conn.load_extension(_path)
+                    await aiosqlite_conn.enable_load_extension(False)
+
+                dbapi_conn.run_async(_load_sqlite_vec)
+            except Exception:  # noqa: BLE001
+                pass
+
+
+def get_sessionmaker() -> async_sessionmaker[AsyncSession]:
+    global _sessionmaker
+    if _sessionmaker is None:
+        _sessionmaker = async_sessionmaker(
+            get_engine(), expire_on_commit=False, class_=AsyncSession
+        )
+    return _sessionmaker
+
+
+# Strong refs to in-flight cleanup tasks: asyncio only holds weak refs to tasks, and
+# a GC'd cleanup task would recreate exactly the leak this exists to prevent.
+_cleanup_tasks: set[asyncio.Task] = set()
+
+
+async def _finish_session(session: AsyncSession, *, commit: bool) -> None:
+    """Commit (or roll back) and close, as one unit the request task can't interrupt."""
+    try:
+        if commit:
+            await session.commit()
+        else:
+            await session.rollback()
+    finally:
+        await session.close()
+
+
+async def get_db_session() -> AsyncIterator[AsyncSession]:
+    """FastAPI dependency yielding a transactional session.
+
+    Cleanup runs on its own shielded task. When a client disconnects mid-request
+    (SSE abort, GUI Stop), uvicorn cancels the request task and the CancelledError
+    can land inside an unshielded commit/rollback — interrupting the greenlet-driven
+    connection teardown and orphaning the aiosqlite connection mid-transaction with
+    its (thread-bound) sqlite3 handle open. That permanently wedges SQLite's single
+    write lock: every later write fails with 'database is locked' until restart.
+    SQLAlchemy shields ``AsyncSession.__aexit__`` close, but not commit/rollback —
+    so the whole finish sequence is moved off the request task here.
+    """
+    session = get_sessionmaker()()
+    commit = True
+    try:
+        yield session
+    except BaseException:
+        commit = False
+        raise
+    finally:
+        cleanup = asyncio.ensure_future(_finish_session(session, commit=commit))
+        _cleanup_tasks.add(cleanup)
+        cleanup.add_done_callback(_cleanup_tasks.discard)
+        with suppress(asyncio.CancelledError):
+            # If the request is already cancelled this await raises immediately,
+            # but the cleanup task keeps running on the loop and still releases
+            # the connection. Real commit/rollback errors propagate to the caller.
+            await asyncio.shield(cleanup)

harness/deps.py

@@ -0,0 +1,58 @@
+"""FastAPI dependency-injection providers."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from typing import Annotated
+
+from fastapi import Depends, Header, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from harness.db import get_db_session
+from harness.eventbus import get_event_bus
+from harness.eventbus.inprocess_bus import InProcessEventBus
+from harness.security.auth import AuthProvider, Principal, get_auth_provider
+from harness.settings import Settings, get_settings
+
+
+async def db_session() -> AsyncIterator[AsyncSession]:
+    async for s in get_db_session():
+        yield s
+
+
+def settings_dep() -> Settings:
+    return get_settings()
+
+
+def auth_dep() -> AuthProvider:
+    return get_auth_provider()
+
+
+def event_bus_dep() -> InProcessEventBus:
+    return get_event_bus()
+
+
+DbSession = Annotated[AsyncSession, Depends(db_session)]
+SettingsDep = Annotated[Settings, Depends(settings_dep)]
+AuthDep = Annotated[AuthProvider, Depends(auth_dep)]
+EventBusDep = Annotated[InProcessEventBus, Depends(event_bus_dep)]
+
+
+async def current_principal(
+    auth: AuthDep,
+    authorization: Annotated[str | None, Header()] = None,
+) -> Principal:
+    """Optional bearer-token auth. In dev the local provider is permissive about
+    missing tokens to keep the CLI frictionless; enable enforcement in prod by
+    requiring a token here."""
+    settings = get_settings()
+    if authorization and authorization.lower().startswith("bearer "):
+        principal = auth.verify_token(authorization.split(" ", 1)[1])
+        if principal:
+            return principal
+    if settings.env == "prod":
+        raise HTTPException(status.HTTP_401_UNAUTHORIZED, "authentication required")
+    return Principal(subject="dev", roles=["admin", "user"])
+
+
+CurrentPrincipal = Annotated[Principal, Depends(current_principal)]

harness/eventbus/__init__.py

@@ -0,0 +1,20 @@
+"""Event bus factory.
+
+In-process buffered bus: single process; the SSE endpoint subscribes for low-latency
+live streaming, with the ledger as the durable backstop."""
+
+from __future__ import annotations
+
+__all__ = ["get_event_bus"]
+
+_bus = None
+
+
+def get_event_bus():
+    """Cached event bus singleton."""
+    global _bus
+    if _bus is None:
+        from harness.eventbus.inprocess_bus import InProcessEventBus
+
+        _bus = InProcessEventBus()
+    return _bus