seren-probe 1.0.0__py3-none-any.whl

seren_probe/ProbeConfig.yml

@@ -0,0 +1,52 @@
+# ═══════════════════════════════════════════════════════════════════════
+#  ProbeConfig.yml - the shipped example topology
+# ═══════════════════════════════════════════════════════════════════════
+#  A fuller, multi-project topology: two "projects" (X and Y), each with a
+#  vector + a plain Loci and its own Memory and SCC, plus a pool of shared
+#  Memory stores and one auto-generated node. Everything not referenced by an
+#  explicit SCC falls into the auto-generated catch-all Corpus.
+#
+#  It exercises the whole compiler: flags, explicit + auto ports, node
+#  auto-generation, and the catch-all sweep - and compiles with zero warnings.
+#  For a minimal starting point to copy from, see ProbeConfig.template.yml.
+# ═══════════════════════════════════════════════════════════════════════
+
+ProbeConfig:
+  StartingPort: 7440
+
+  Loci:
+    LociCount: 5
+    LociConfigs:
+      - { Name: loci-vector-projectX, Port: 7441, Flags: [vector] }
+      - { Name: loci-plain-projectX,  Port: 7442 }
+      - { Name: loci-vector-projectY, Port: 7443, Flags: [vector] }
+      - { Name: loci-plain-projectY,  Port: 7444 }
+      # + 1 auto-generated Loci (no flags, auto port) to reach LociCount 5
+
+  Memory:
+    MemoryCount: 7
+    MemoryConfigs:
+      - { Name: memory-projectX, Port: 7445 }
+      - { Name: memory-projectY, Port: 7446 }
+      - { Name: memory-shared-a, Port: 7450 }
+      - { Name: memory-shared-b, Port: 7451 }
+      - { Name: memory-shared-c, Port: 7452 }
+      - { Name: memory-shared-d, Port: 7453 }
+      # + 1 auto-generated Memory to reach MemoryCount 7
+
+  Corpus:
+    CorpusCount: 3
+    CorpusConfigs:
+      - Name: corpus-projectX
+        Port: 7460
+        Stores:
+          - { Store: loci-vector-projectX }
+          - { Store: loci-plain-projectX }
+          - { Store: memory-projectX }
+      - Name: corpus-projectY
+        Port: 7461
+        Stores:
+          - { Store: loci-vector-projectY }
+          - { Store: memory-projectY }
+      # + 1 auto-generated catch-all Corpus fanning the 7 unreferenced stores:
+      #   loci-plain-projectY, the auto Loci, memory-shared-a..d, the auto Memory

seren_probe/README.md

@@ -0,0 +1,65 @@
+# `seren_probe/` - what lives where
+
+Nineteen files in a flat root is a lot to land in cold. This is the map. It's the
+same grouping a `core/` + `runtime/` split would give you - drawn, not moved, so
+nothing's import path changes while you find your feet.
+
+The boundary below isn't a suggestion: **`tests/test_layering.py` enforces it.**
+Nothing in the PURE layer may import `httpx`, and no module anywhere may name a
+live Seren port (7420–7424) in executable code. Both fail the build.
+
+---
+
+## 🧠 PURE - config, parsing, maths. Touches no network, no Docker, no store.
+
+| module | what it is |
+|---|---|
+| `topology.py` | **the compiler.** ProbeConfig → validated `CompiledTopology`. Owns `REGRADE_KNOBS` + `KNOBS_NEEDING_CAPABILITY`. It's the landmine guard: two corpora that secretly fan the same stores, a decoy wired into a measured SCC - all caught here, before Docker breathes. |
+| `topology_emit.py` | `CompiledTopology` → docker-compose + one `seren-corpus-callosum.yaml` per corpus, with correct-by-construction store wiring. |
+| `seed_dataset.py` | seed/question **loading + validation**, the seeder (`seed_from_plan`), and `rehydrate_ref_map` (rebuilds the answer key from a live store when a pod was adopted). |
+| `resolve.py` | decides which store gets which seed, and which questions get scored. |
+| `question_lint.py` | **can this question be answered at all?** Three tiers: expectation-in-corpus, lexical rail (`multihop`), no rail at all (`unbridged`). An unanswerable question looks *exactly* like a retrieval failure on the dashboard. |
+| `metrics.py` | HR / MRR / P@k / R@k / nDCG / IoU / P-Ω + docket coverage & density. |
+| `docket.py` | the with-edges vs without-edges SCC comparison. |
+| `knob_caps.py` | refuses to sweep a knob the SCC doesn't advertise. An ignored knob produces a flatline that reads as a ceiling. |
+| `lint_cli.py` | `python -m seren_probe.lint_cli` - non-zero exit gate for CI. |
+
+## 🌐 RUNTIME - everything that speaks to a running thing. `httpx` lives only here.
+
+| module | what it is |
+|---|---|
+| **`write_guard.py`** | **THE INTERLOCK. Read this first.** SerenProbe cannot write to a store it did not spin up. Fail-closed: no topology → nothing writable, anywhere. |
+| `live_eval.py` | `run_topology_evaluation` - evals every store in a topology as its own column. The main event. |
+| `live_import.py` | read-only copy of a real store's data into a container. |
+| `regrade_live.py` | the **live** SCC knob sweep - reconfigures the running container per combo. This is what the ⚙ Regrades button drives. |
+| `regrade.py` | the **capture/replay** sweep - freeze each store's candidate pool once, replay the real Federation in-process over the frozen trace. Read-only. Owns `DEFAULT_GRID`. |
+| `docker_env.py` | container lifecycle: compose up/down/ps, health-gating, pod adoption, topology-state persistence. |
+
+## ⚙️ SERVICE
+
+| module | what it is |
+|---|---|
+| `app.py` | the FastAPI app. Auth, request logging, viewer, route mounts, optional MCP. |
+| `config.py` | `seren-probe.yaml` → typed config. Defaults → yaml → env. |
+| `__main__.py` | `python -m seren_probe`. |
+| `routes/` | `eval.py` (run + regrade) · `docker.py` (start/stop/status/adopt) · `config.py` |
+| `viewer/ui/` | the dashboard: `body.html` · `tabs.html` · `scripts.js` · `styles.css` |
+| `mcp/` | optional MCP surface (`pip install seren-probe[mcp]`) |
+| `dockerfiles/` | the three store images the emitter builds from |
+
+---
+
+## The four rules this package learned the hard way
+
+1. **The summary lies; the rows tell the truth.** Every confident read of an
+   aggregate on 2026-07-13 was wrong, and wrong in the direction that made the
+   story tidier. Dump the tier. Read every row.
+2. **A knob swept in one direction is half a knob.** `loci_weight` was only ever
+   swept *down*, toward the other store. The entire win was above 1.0.
+3. **Ground truth must be re-resolvable from the live system.** A minted UUID held
+   in the seeding process's RAM is not ground truth, it's a receipt. `expect_key`
+   survived an adopted pod; `expect_ref` didn't, and reported a perfectly healthy
+   store as dead for a full day.
+4. **Interlocks catch what discipline doesn't.** Six live-store hazards and eleven
+   silent measurement bugs in one day. Discipline caught none of them. Every guard
+   we built caught one - including two the guards found *after* we'd stopped looking.

seren_probe/__init__.py

@@ -0,0 +1,48 @@
+"""
+seren_probe - RAG evaluation toolkit for Seren's memory architecture.
+
+Evaluates retrieval quality across:
+  - SerenLoci (SQLite factstore: exact/lexical/vector)
+  - SerenMemory (3-tier Chroma DB: short/near/long)
+  - SerenCorpusCallosum (federated RRF merge of both)
+
+Standard metrics: Hit Rate, MRR, Precision@k, Recall@k, NDCG@k.
+"""
+from __future__ import annotations
+
+# Version flows from the git tag via setuptools-scm (written to _version.py at
+# build time, read here). Fallback only fires in a bare source checkout that was
+# never built. Mirrors the family so every seren_* exposes __version__ alike.
+try:
+    from ._version import version as __version__
+except Exception:  # noqa: BLE001 - source checkout without a build
+    __version__ = "0.0.0+unknown"
+    
+# NOT exported anymore: EvalDataset / EvalQuery / seed_synthetic_dataset (dataset.py)
+# and LociEvaluator / MemoryEvaluator / CorpusCallosumEvaluator (evaluators.py).
+#
+# dataset.py is the SYNTHETIC corpus generator. Importing it here meant it loaded on
+# every `import seren_probe` -- so the fake data was in the import graph of every
+# code path that so much as touched an eval, sitting next to a module whose defaults
+# named the operator's real stores. That combination is how synthetic content ends up
+# inside a live SerenMemory, and it did.
+#
+# The in-process legacy suite (dataset / evaluators / runner) is in _attic/. Nothing
+# in the topology path needs it: seeding is config-driven via seed_dataset.py, and
+# evaluation goes through live_eval.run_topology_evaluation, which only ever addresses
+# containers SerenProbe spun up itself.
+
+__all__ = [
+    "__version__",
+    "EvalMetrics",
+    "SerenProbeConfig",
+    "load_config",
+    "DockerEnv",
+    "DockerEnvState",
+    "launch_and_eval",
+    "build_image",
+    "start_container",
+    "wait_for_healthy",
+    "stop_container",
+    "container_status",
+]

seren_probe/__main__.py

@@ -0,0 +1,65 @@
+"""
+Entry point: python -m seren_probe [--config path]   (also the `seren-probe` script)
+
+Boots the FastAPI app with uvicorn using the resolved config.
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+
+import uvicorn
+
+from .app import create_app
+from .config import load_config
+
+
+def _force_utf8_stdio() -> None:
+    """Make stdout/stderr UTF-8 regardless of OS locale."""
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(encoding="utf-8")
+        except (AttributeError, ValueError):
+            pass
+
+
+def _maybe_inject_truststore(cfg, log=print) -> None:
+    """If tls.trust_system_store is on, route Python TLS through the OS trust
+    store via `truststore`. MUST run before any SSLContext is created."""
+    if not cfg.tls.trust_system_store:
+        return
+    try:
+        import truststore
+    except ImportError:
+        log("[seren-probe] tls.trust_system_store is ON but 'truststore' isn't "
+            "installed. Install the corp extra: pip install 'seren-probe[corp]' "
+            "(continuing with certifi defaults).")
+        return
+    truststore.inject_into_ssl()
+    log("[seren-probe] TLS: using OS trust store (truststore injected)")
+
+
+def main() -> None:
+    _force_utf8_stdio()
+    parser = argparse.ArgumentParser(
+        prog="seren-probe",
+        description="SerenProbe - RAG evaluation toolkit. Operator dashboard.")
+    parser.add_argument(
+        "--config", "-c", default=None,
+        help="Path to seren-probe.yaml (default: ./seren-probe.yaml or "
+             "$SEREN_PROBE_CONFIG, falling back to built-in defaults).")
+    args = parser.parse_args()
+
+    cfg = load_config(args.config)
+    _maybe_inject_truststore(cfg)
+    app = create_app(cfg)
+
+    print(f"[seren-probe] listening on {cfg.server.host}:{cfg.server.port}")
+    print(f"[seren-probe] auth: "
+          f"{'enabled' if cfg.server.bearer_token else 'DISABLED (no token)'}")
+
+    uvicorn.run(app, host=cfg.server.host, port=cfg.server.port, log_level="info")
+
+
+if __name__ == "__main__":
+    main()

seren_probe/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '1.0.0'
+__version_tuple__ = version_tuple = (1, 0, 0)
+
+__commit_id__ = commit_id = 'gf7f16db10'

seren_probe/app.py

@@ -0,0 +1,167 @@
+"""
+seren_probe.app
+════════════════════════════════════════════════════════════════════════
+
+The FastAPI application for the SerenProbe RAG evaluation suite. Wires the
+operator dashboard with endpoints for running evaluations and live configuration.
+
+ENDPOINTS:
+    GET  /                     - service info + version
+    GET  /health               - liveness
+    GET  /viewer               - the SerenProbe operator dashboard
+    GET  /eval/results         - latest full eval results
+    POST /eval/run             - run full evaluation against live stores
+    GET  /eval/config          - current viewer config
+    POST /eval/config          - update viewer configuration
+    POST /docker/start         - build + start Docker test environment
+    POST /docker/stop          - stop + remove Docker environment
+    GET  /docker/status        - current Docker environment status
+    POST /docker/run-eval      - one-shot: spin up, eval, tear down
+    GET  /docker/config        - list deployment configs + Docker availability
+    POST /docker/config/save   - save a new Dockerfile/compose config
+    POST /docker/config/activate - set the active deployment config
+    POST /docker/validate      - validate Docker install + config syntax
+    MCP  /mcp                  - MCP tools (when [mcp] extras installed)
+
+Deliberately parallel to SerenLoci / SerenMemory: same auth posture, same
+conditional-MCP-mount shape, same public-paths set.
+"""
+from __future__ import annotations
+
+import logging
+import time
+from contextlib import asynccontextmanager, AsyncExitStack
+from pathlib import Path
+
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse
+
+from .config import SerenProbeConfig, load_config
+from .routes import eval as eval_routes
+from .routes import config as config_routes
+from .routes import docker as docker_routes
+
+from seren_meninges import get_version
+from seren_meninges.auth import bearer_auth_middleware
+from seren_meninges.viewer import render_from_dir
+from seren_sinew.request_log import RequestLoggingMiddleware
+
+from . import __version__ as _fallback_version
+APP_VERSION = get_version("seren-probe", fallback=_fallback_version)
+
+logger = logging.getLogger(__name__)
+
+
+def create_app(config: SerenProbeConfig | None = None) -> FastAPI:
+    cfg = config or load_config()
+    bearer = cfg.server.resolve_bearer()
+
+    # Shared mutable state that MCP tools also read/write.
+    _mcp_state_ref: dict = {}
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI):
+        # -- Startup --
+        app.state.config = cfg
+        app.state.eval_results = {}
+        app.state.docker_state = {}
+        app.state.docker_config_active = "default"
+        app.state.docker_config_path = None
+        app.state.store_config = {
+            "memory_url": cfg.stores.memory_url,
+            "loci_nv_url": cfg.stores.loci_nv_url,
+            "loci_v_url": cfg.stores.loci_v_url,
+            "scc_nv_url": cfg.stores.scc_nv_url,
+            "scc_v_url": cfg.stores.scc_v_url,
+            "capture_path": cfg.stores.capture_path,
+        }
+        # MCP state ref - a dict the MCP tools mutate, same references as the
+        # route handlers read. Both see the same values.
+        app.state._mcp_state_ref = _mcp_state_ref
+        _mcp_state_ref["eval_results"] = app.state.eval_results
+
+        print(f"[seren-probe] viewer ready on {cfg.server.host}:{cfg.server.port}")
+        print(f"[seren-probe] stores: memory={cfg.stores.memory_url} "
+              f"loci-nv={cfg.stores.loci_nv_url} loci-v={cfg.stores.loci_v_url} "
+              f"scc-nv={cfg.stores.scc_nv_url} scc-v={cfg.stores.scc_v_url}")
+
+        # -- Optional MCP server --
+        try:
+            from .mcp.server import mount_mcp_routes
+            mcp_server = mount_mcp_routes(app)
+        except ImportError as exc:
+            mcp_server = None
+            print(f"[seren-probe] MCP surface not available; HTTP-only mode ({exc})")
+        except Exception as exc:  # noqa: BLE001
+            mcp_server = None
+            print(f"[seren-probe] MCP mount failed: {exc!r} - continuing without MCP")
+
+        # Enter the MCP session manager's task group if mounted.
+        async with AsyncExitStack() as _mcp_stack:
+            session_manager = getattr(mcp_server, "session_manager", None)
+            if session_manager is not None:
+                await _mcp_stack.enter_async_context(session_manager.run())
+                print("[seren-probe] MCP session manager running")
+            yield
+
+        # -- Shutdown: tear down any running Docker container --
+        docker_state = app.state.docker_state
+        if docker_state and docker_state.get("container_id"):
+            try:
+                from .runtime.docker_env import stop_container as _stop
+                _stop(docker_state)
+            except Exception as e:
+                logger.warning("Docker teardown on shutdown: %s", e)
+
+        print("[seren-probe] shut down")
+
+    app = FastAPI(
+        title="SerenProbe",
+        description="RAG evaluation toolkit for Seren's memory architecture.",
+        version=APP_VERSION,
+        lifespan=lifespan,
+    )
+
+    # -- Bearer auth --
+    app.add_middleware(bearer_auth_middleware(bearer))
+
+    # -- Request logging --
+    app.add_middleware(
+        RequestLoggingMiddleware,
+        service_name="seren-probe",
+        env_prefix="SEREN_PROBE",
+    )
+
+    viewer_dir = Path(__file__).resolve().parent / "viewer" / "ui"
+
+    # -- Info routes --
+    @app.get("/")
+    async def root():
+        return {
+            "service": "SerenProbe",
+            "version": APP_VERSION,
+            "stores": 5,
+        }
+
+    @app.get("/health")
+    async def health():
+        return {"ok": True, "ts": time.time(), "version": APP_VERSION}
+
+    # -- The operator dashboard viewer --
+    @app.get("/viewer")
+    async def viewer():
+        html = render_from_dir(
+            viewer_dir,
+            title="SerenProbe",
+            brand="Seren<b>Probe</b> · RAG Evaluation Suite",
+            subtitle=f"v{APP_VERSION} · probe retrieval quality",
+            accent="#8fffb4",
+        )
+        return HTMLResponse(html)
+
+    # -- Route subpackage mounts --
+    app.include_router(eval_routes.router)
+    app.include_router(config_routes.router)
+    app.include_router(docker_routes.router)
+
+    return app

seren_probe/config.py

@@ -0,0 +1,134 @@
+"""
+seren_probe.config
+════════════════════════════════════════════════════════════════════════
+
+Typed configuration for the SerenProbe evaluation viewer. Same pattern as
+the family: dataclass-based (like SCC), adopting the shared ServerConfig
+and TlsConfig from SerenMeninges so the whole family shares one definition.
+
+Resolution order (later wins):
+    1. Defaults (this file)
+    2. seren-probe.yaml (path from --config or ./seren-probe.yaml)
+    3. Environment variables (SEREN_PROBE_*)
+"""
+from __future__ import annotations
+
+import logging
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Optional
+
+import yaml
+
+# Shared server/tls config blocks from Meninges - ONE definition for the family.
+from seren_meninges import ServerConfig, TlsConfig
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class StoreUrlsConfig:
+    """URLs for live stores the operator may point the viewer at.
+
+    THE DEFAULTS ARE DELIBERATELY EMPTY. They used to be:
+
+        memory_url  = "http://127.0.0.1:7420"   <- the operator's REAL SerenMemory
+        loci_v_url  = "http://127.0.0.1:7421"   <- the operator's REAL SerenLoci
+        loci_nv_url = "http://127.0.0.1:7422"
+        scc_nv_url  = "http://127.0.0.1:7423"
+        scc_v_url   = "http://127.0.0.1:7424"
+
+    A tool whose job is to MANUFACTURE SYNTHETIC DATA shipped with the addresses of
+    the operator's live brain preloaded into its config. Those defaults fed
+    app.state.store_config, which fed the legacy /eval/run fallback, which SEEDED
+    those stores if it found them empty. Exactly one thing stood between that and a
+    contaminated memory store: the store happening to be non-empty.
+
+    An address you have to TYPE is a decision. An address that arrives as a default
+    is an accident waiting for a tired Tuesday.
+
+    Nothing in the topology path reads these anymore (eval and regrade only ever
+    address containers SerenProbe spun up itself, and write_guard refuses anything
+    else at the transport). They survive only as an operator-settable field on
+    /eval/config. tests/test_layering.py enforces that no module in this package
+    contains a live-store port literal -- do not put them back.
+    """
+    memory_url: str = ""
+    loci_nv_url: str = ""
+    loci_v_url: str = ""
+    scc_nv_url: str = ""
+    scc_v_url: str = ""
+    capture_path: str = ""
+
+    @classmethod
+    def from_dict(cls, d: Optional[dict[str, Any]]) -> "StoreUrlsConfig":
+        d = d or {}
+        return cls(
+            memory_url=str(d.get("memory_url", "")),
+            loci_nv_url=str(d.get("loci_nv_url", "")),
+            loci_v_url=str(d.get("loci_v_url", "")),
+            scc_nv_url=str(d.get("scc_nv_url", "")),
+            scc_v_url=str(d.get("scc_v_url", "")),
+            capture_path=str(d.get("capture_path", "")),
+        )
+
+
+@dataclass
+class SerenProbeConfig:
+    """The whole service: server + tls + store URLs."""
+    server: ServerConfig = field(default_factory=lambda: ServerConfig(port=7430))
+    tls: TlsConfig = field(default_factory=TlsConfig)
+    stores: StoreUrlsConfig = field(default_factory=StoreUrlsConfig)
+
+
+def _apply_env_overrides(cfg: SerenProbeConfig) -> SerenProbeConfig:
+    """SEREN_PROBE_* env wins last, same precedence as the family's SEREN_<X>_*."""
+    env = os.environ
+    if v := env.get("SEREN_PROBE_HOST"):
+        cfg.server.host = v
+    if v := env.get("SEREN_PROBE_PORT"):
+        cfg.server.port = int(v)
+    if v := env.get("SEREN_PROBE_BEARER_TOKEN"):
+        cfg.server.bearer_token = v
+    if v := env.get("SEREN_PROBE_BEARER_TOKEN_ENV"):
+        cfg.server.bearer_token_env = v
+    if v := env.get("SEREN_PROBE_BEARER_TOKEN_KEYRING"):
+        cfg.server.bearer_token_keyring = v
+    if v := env.get("SEREN_PROBE_TRUST_SYSTEM_STORE"):
+        cfg.tls.trust_system_store = v.lower() in ("1", "true", "yes", "on")
+    if v := env.get("SEREN_PROBE_MEMORY_URL"):
+        cfg.stores.memory_url = v
+    if v := env.get("SEREN_PROBE_LOCI_NV_URL"):
+        cfg.stores.loci_nv_url = v
+    if v := env.get("SEREN_PROBE_LOCI_V_URL"):
+        cfg.stores.loci_v_url = v
+    if v := env.get("SEREN_PROBE_SCC_NV_URL"):
+        cfg.stores.scc_nv_url = v
+    if v := env.get("SEREN_PROBE_SCC_V_URL"):
+        cfg.stores.scc_v_url = v
+    if v := env.get("SEREN_PROBE_CAPTURE_PATH"):
+        cfg.stores.capture_path = v
+    return cfg
+
+
+def load_config(path: Optional[str] = None) -> SerenProbeConfig:
+    """Defaults -> yaml -> env (later wins). A missing file is fine - defaults
+    + env is a valid zero-config run. YAML is imported lazily so the core
+    import path stays light."""
+    data: dict[str, Any] = {}
+    candidate = path or os.environ.get("SEREN_PROBE_CONFIG") or "seren-probe.yaml"
+    cfg_path = Path(os.path.expanduser(candidate))
+    if cfg_path.is_file():
+        try:
+            with open(cfg_path) as f:
+                data = yaml.safe_load(f) or {}
+        except Exception:  # noqa: BLE001 - unreadable degrades to defaults
+            data = {}
+
+    server = ServerConfig.from_dict(data.get("server"), default_port=7430)
+    tls = TlsConfig.from_dict(data.get("tls"))
+    stores = StoreUrlsConfig.from_dict(data.get("stores"))
+
+    cfg = SerenProbeConfig(server=server, tls=tls, stores=stores)
+    return _apply_env_overrides(cfg)

seren_probe/core/__init__.py

@@ -0,0 +1,15 @@
+"""
+seren_probe.core -- the pure layer.
+
+Everything in here is enforced by tests/test_layering.py to be free of httpx,
+Docker, and any live-store port literal. It compiles config, parses seeds,
+computes metrics, and emits compose files. It never touches the network.
+
+The folder exists for navigation. The boundary exists because a test says so.
+"""
+from __future__ import annotations
+
+# Re-export every module so `from seren_probe.core.foo import bar` works and,
+# via the package __init__ shim, `from seren_probe.foo import bar` keeps
+# working unchanged.
+from . import topology, topology_emit, seed_dataset, resolve, metrics, docket, knob_caps, lint_cli