feat: mount discovered module UI in a minimal Ekklesia browser host

Phase 6C pass 2. Every link in the module UI chain existed except the one
that closes it: a module could be authored, built, validated, published at a
browser URL, and loaded by a generic loader — and nothing in Ekklesia did any
of it. There was no browser application at all.

Two pieces were missing. A browser could not discover what to mount, and it
must not work that out for itself.

GET /api/v1/module-ui is the inventory: per publishable module, its id and
version, the server-produced artifact URL, the server-produced root of the
module's own API, and the subset of that module's declared permissions the
caller holds. Five fields, each because building a ModuleUiHostContext needs
it — no filesystem paths, and no name/icon/folder/order, because navigation
metadata is a design that does not exist yet. Its module set is the ADR 0025
publication registry rather than a rescan, so the inventory and the artifact
route cannot disagree. It requires a new Core permission, core.modules.ui.read
(baseline authenticated), because it is precisely the enumeration the anonymous
artifact route deliberately withholds.

Both URLs are server-produced. moduleUiArtifactUrl already existed;
moduleApiBaseUrl is now exported and moduleRoutePath builds on it, so each URL
shape has exactly one author. Without it the shell would hardcode
/api/v1/modules/<id> — the prefix ADR 0022 forbids a module UI from spelling,
reappearing in the host instead.

surfaces/shell (@ekklesia/shell) is the repository's first surface: a small
React application built to static files by its own esbuild script. It resolves
the principal, fetches the inventory, builds the host context entirely from
server-derived data, and hands the artifact URL to @ekklesia/module-ui-host.
One frame per selection — keyed by module identity — defeats the stale-load
race; the host owns the container, the loading state, and every failure, so a
broken module costs its own panel rather than the shell.

The shell statically imports no module, and both levels are checked: no source
import may name a module, and the emitted bundle must contain exactly one
dynamic import (the loader's) with no module id, no /api/v1/modules, no eval,
and no blob URL. Permission hints come from Core's own evaluator and stay
presentation-only — the end-to-end test has a UI holding no grant call its API
anyway and still receive 403.

Surfaces may now depend only on browser-safe shared roles; @ekklesia/contracts
is deliberately excluded, since its barrel pulls Drizzle's types and Node's
globals into the browser — the hole ADR 0024 closed one layer down.

Not the Dashboard: no navigation, grouping, icons, ordering, design system, or
routing. The selector is a list of module ids.

Co-Authored-By: Claude Opus 5 <[email protected]>

docs/development/api.md

@@ -76,6 +76,7 @@ No real values are shown here — configure per environment and never commit the
 | `GET /api/v1/principal` | Ekklesia | Returns the minimal `EkklesiaPrincipal` contract as JSON. `Cache-Control: no-store`. |
 | `GET\|POST /api/v1/grants*` | Ekklesia | Explicit authorization grant management, gated by `core.authorization.grants.manage`. Listing is bounded keyset pagination; creation is unscoped-only and conflicts (`409`) on an equivalent effective grant; revocation clears every unrevoked equivalent. See [Authorization](authorization.md#explicit-grant-http-api). |
 | `/api/v1/modules/<module-id>/*` | Installed modules | Every route an installed module registered during its `register` hook, gated by that route's own declared permission. See [Module HTTP routes](#module-http-routes). |
+| `GET /api/v1/module-ui` | Ekklesia | The browser host's module UI inventory: which module UIs may be mounted, where to fetch each, where each module's API lives, and the viewer's granted permissions for it. Requires `core.modules.ui.read` (baseline `authenticated`). See [Module UI inventory](#module-ui-inventory). |
 | `GET /api/v1/module-ui/<module-id>/<version>` | Ekklesia | Publishes an installed module's validated `entrypoints.ui` artifact at a browser-loadable URL. No authentication; only the declared artifact, never another file. See [Module UI asset publication](#module-ui-asset-publication). |
 
 Better Auth's handler is unreachable outside `/api/auth/*`; every other unmatched path returns a
@@ -451,6 +452,60 @@ are mounted under `/api/v1/modules/<module-id>`, in the module runtime's publish
   registry: installing, removing, or editing a module's routes takes effect only on the next API
   restart. Removing a module makes its former routes return the ordinary `404 {"code":"NOT_FOUND"}`.
 
+## Module UI inventory
+
+```text
+GET /api/v1/module-ui
+```
+
+The one query a browser host makes before it can mount anything
+([ADR 0026](../architecture/decisions/0026-minimal-ekklesia-module-ui-host.md)). It is the collection
+root of the same resource the artifact route below serves: one prefix, two representations.
+
+```json
+{
+  "modules": [
+    {
+      "id": "example",
+      "version": "0.1.0",
+      "ui": { "url": "/api/v1/module-ui/example/0.1.0" },
+      "api": { "baseUrl": "/api/v1/modules/example" },
+      "permissions": ["example.records.read"]
+    }
+  ]
+}
+```
+
+- **Five fields, each because a `ModuleUiHostContext` needs it.** No filesystem path, package root,
+  package name, server/schema/migrations entrypoint, capability, dependency, or storage bucket. And
+  no `name`, `icon`, `description`, `category`, `folder`, or `order`: those are navigation metadata,
+  and [ADR 0021](../architecture/decisions/0021-modules-as-hostable-products.md) keeps Dashboard
+  grouping an administrator's presentation configuration rather than a module declaration.
+- **Both URLs are server-produced.** `ui.url` comes from `moduleUiArtifactUrl` and `api.baseUrl` from
+  `moduleApiBaseUrl`, so each URL shape is constructed in exactly one place in the repository. A
+  browser never rebuilds `/api/v1/module-ui/<id>/<version>` or `/api/v1/modules/<id>`, which is what
+  lets either change without touching host or module code.
+- **The module set is the publication registry**, not a rescan: modules that survived discovery and
+  declare `entrypoints.ui`, captured after the module runtime started. A module with no UI is absent.
+  Order is the registry's own deterministic discovery order.
+- **Authenticated, unlike the artifact route.** Requires `core.modules.ui.read`, baseline
+  `authenticated` — any signed-in user, and nobody else. The artifact bytes are anonymous because
+  fetching them confers no authority, but that route is deliberately not an enumeration oracle, and
+  this endpoint *is* that enumeration. `authenticated` rather than `restricted` because a shell that
+  rendered nothing until an operator granted every user a permission would be unusable.
+- **`permissions` is the subset of that module's own declared permissions the caller holds**,
+  evaluated server-side by Core's one authorization evaluator — so baselines, the platform-owner
+  bypass, grant expiry, and deny-by-default behave exactly as on a real request. Granted ids only,
+  scoped to the module: no module learns the viewer's authorization state anywhere else in the
+  platform. **These are presentation hints, never authority**; every module route stays enforced by
+  `requirePermission` regardless of what a browser was told.
+- **Failures.** Anonymous or unpermitted callers get `403 {"code":"AUTHORIZATION_DENIED"}` from the
+  shared middleware. An authorization-evaluation outage is `503
+  {"code":"AUTHORIZATION_EVALUATION_FAILED"}` rather than an empty hint set, because a hint that
+  silently read "denied" during an outage would blank the UI and look like a permissions problem.
+- **Per-principal**, so `Cache-Control: no-store` and `Vary: Origin, Cookie`, exactly like
+  `/api/v1/principal`. `GET` only; no other method is routed.
+
 ## Module UI asset publication
 
 A module may declare `entrypoints.ui`, a compiled browser ESM artifact

docs/development/security.md

@@ -126,6 +126,32 @@ may be published or mounted. A module UI that mounts has gained no privilege it
 — its server half already runs in the API process with the API's database authority — and server APIs
 remain the sole authority for authorization regardless of what a browser loaded.
 
+### The browser host mounts module UI; it grants nothing
+
+Ekklesia's shell (`surfaces/shell`) discovers installed module UIs through
+`GET /api/v1/module-ui` and mounts them with the generic loader
+([ADR 0026](../architecture/decisions/0026-minimal-ekklesia-module-ui-host.md)). Three properties are
+security-relevant.
+
+**The inventory is authenticated, deliberately.** Module UI *bytes* are anonymous because fetching
+compiled code confers no authority, and that route is carefully not an enumeration oracle. The
+inventory is that enumeration — it lists which module products an installation runs — so it requires
+`core.modules.ui.read` (baseline `authenticated`): any signed-in user, and nobody else. It carries no
+filesystem path, package root, or entrypoint.
+
+**Permission hints are computed by the server and remain hints.** For each listed module the API
+evaluates that module's *own* declared permissions against the caller using Core's one authorization
+evaluator, and returns only the granted ids — never a default of `true`, never inferred from a
+client-side role, and never another module's or Core's authorization state. Every module route stays
+enforced by `requirePermission` regardless; the test suite proves it by having a UI that was told
+"denied" call its API anyway and still receive `403`.
+
+**The host executes trusted module code in its own page and does not pretend otherwise.** The loader
+performs a same-origin dynamic `import()` — no `eval`, no `new Function`, no `blob:` URL — and the
+shell owns the container, the loading state, and every error, so a failing module costs its own panel
+rather than the shell. None of that is containment: once imported, a module UI is ordinary same-realm
+JavaScript, exactly as described above.
+
 ### Client-side permission checks are not a security boundary
 
 A host may tell a module UI what permissions it believes the viewer holds