Publish expanded LumynaX product platform package

README.md

@@ -37,6 +37,9 @@ python quickstart.py
 ```bash
 python -m sovereigncode.cli evaluate --capsule examples/capsule.restricted-nz-code.json --request examples/request.allowed-local-edit.json
 python -m sovereigncode.cli plan-turn --capsule examples/capsule.restricted-nz-code.json --request examples/request.allowed-local-edit.json --route-request examples/request.code-restricted.json --registry configs/lumynax_model_registry.json
+python -m sovereigncode.cli policy-matrix --capsule examples/capsule.restricted-nz-code.json --request examples/request.allowed-local-edit.json
+python -m sovereigncode.cli tool-check --capsule examples/capsule.restricted-nz-code.json --request examples/request.allowed-local-edit.json --tool-name workspace_reader --action read_context
+python -m sovereigncode.cli opencode-config
 python -m sovereigncode.cli ui --smoke
 python -m sovereigncode.cli ui --port 8788 --open
 ```
@@ -97,6 +100,30 @@ py -3 -m tinyluminax.products.sovereigncode.cli plan-turn \
   --registry products/lumynax-marama-route/configs/lumynax_model_registry.json
 ```
 
+Run the policy/tool matrix:
+
+```bash
+py -3 -m tinyluminax.products.sovereigncode.cli policy-matrix \
+  --capsule products/abx-sovereigncode/examples/capsule.restricted-nz-code.json \
+  --request products/abx-sovereigncode/examples/request.allowed-local-edit.json
+```
+
+Check one tool before execution:
+
+```bash
+py -3 -m tinyluminax.products.sovereigncode.cli tool-check \
+  --capsule products/abx-sovereigncode/examples/capsule.restricted-nz-code.json \
+  --request products/abx-sovereigncode/examples/request.allowed-local-edit.json \
+  --tool-name workspace_reader \
+  --action read_context
+```
+
+Emit an OpenCode-compatible workspace config:
+
+```bash
+py -3 -m tinyluminax.products.sovereigncode.cli opencode-config
+```
+
 Denied training example:
 
 ```bash
@@ -128,6 +155,8 @@ py -3 -m tinyluminax.products.sovereigncode.cli ui --smoke
 | LumynaX Runtime Adapter | Routes model calls to local GGUF, local API, or approved LumynaX model endpoints. |
 | Audit Ledger | Stores decision records, prompt/output hashes, file diffs, and approval metadata. |
 | Operator Console | Shows the plan, policy decision, diff, tests, and approval gate before external effects. |
+| Policy Matrix | Evaluates common tool/action scenarios against the same Data Capsule. |
+| Provider Exporter | Emits OpenCode-compatible workspace config pointing through MaramaRoute. |
 
 ## New Zealand Launch Shape
 
@@ -151,6 +180,9 @@ py -3 -m tinyluminax.products.sovereigncode.cli ui --smoke
 | Personal profile capsule | `examples/capsule.personal-sovereignty-profile.json` |
 | Personal-memory request | `examples/request.personal-memory-read.json` |
 | Browser operator console | `python -m tinyluminax.products.sovereigncode.cli ui` |
+| Policy/tool matrix | `python -m tinyluminax.products.sovereigncode.cli policy-matrix` |
+| Tool gate check | `python -m tinyluminax.products.sovereigncode.cli tool-check` |
+| OpenCode workspace export | `python -m tinyluminax.products.sovereigncode.cli opencode-config` |
 | Product blueprint | `product_blueprint.md` |
 
 ## Source Grounding
@@ -159,7 +191,7 @@ The sovereignty model is inspired by the Data Capsule pattern described in the S
 
 ## Stage
 
-This is an executable platform scaffold, not the final commercial application. The policy engine, router integration, CLI package, and browser operator console are working now; the tool broker, terminal loop, and full autonomous agent loop are the next implementation stage.
+This is an executable platform scaffold, not the final commercial application. The policy engine, router integration, CLI package, policy matrix, tool gate checks, capsule summaries, OpenCode config export, operator checklist, and browser operator console are working now; the live tool broker, terminal loop, and full autonomous agent loop are the next implementation stage.
 
 
 # AbteeX SovereignCode Product Blueprint

SMOKE_TESTS.md

@@ -6,6 +6,8 @@ Run from the package root:
 pip install -e .
 python quickstart.py
 python -m sovereigncode.cli ui --smoke
+python -m sovereigncode.cli policy-matrix --capsule examples/capsule.restricted-nz-code.json --request examples/request.allowed-local-edit.json
+python -m sovereigncode.cli tool-check --capsule examples/capsule.restricted-nz-code.json --request examples/request.allowed-local-edit.json --tool-name workspace_reader --action read_context
 python -m sovereigncode.cli evaluate --capsule examples/capsule.personal-sovereignty-profile.json --request examples/request.personal-memory-read.json
 ```
 

marama_route/__init__.py

@@ -6,6 +6,13 @@ from .gateway import (
     route_chat_payload,
     routing_request_from_chat_payload,
 )
+from .platform import (
+    build_opencode_provider_config,
+    build_registry_analytics,
+    catalog_models,
+    compare_models,
+    route_scenario_matrix,
+)
 from .registry import ModelEndpoint, RoutingRequest, load_model_registry
 from .router import RouteDecision, SovereignModelRouter
 from .ui import smoke_ui as smoke_ui
@@ -17,8 +24,13 @@ __all__ = [
     "SovereignModelRouter",
     "build_chat_route_response",
     "build_models_response",
+    "build_opencode_provider_config",
+    "build_registry_analytics",
+    "catalog_models",
+    "compare_models",
     "load_model_registry",
     "route_chat_payload",
+    "route_scenario_matrix",
     "routing_request_from_chat_payload",
     "smoke_ui",
 ]

marama_route/cli.py

@@ -7,6 +7,13 @@ from pathlib import Path
 from typing import Any
 
 from .gateway import build_models_response, route_chat_payload
+from .platform import (
+    build_opencode_provider_config,
+    build_registry_analytics,
+    catalog_models,
+    compare_models,
+    route_scenario_matrix,
+)
 from .registry import RoutingRequest, load_model_registry
 from .router import SovereignModelRouter
 
@@ -41,6 +48,55 @@ def _chat_dry_run(args: argparse.Namespace) -> int:
     return 0 if selected is not None else 2
 
 
+def _catalog(args: argparse.Namespace) -> int:
+    models = load_model_registry(args.registry)
+    result = catalog_models(
+        models,
+        {
+            "search": args.search,
+            "task_type": args.task,
+            "runtime": args.runtime,
+            "modality": args.modality,
+            "jurisdiction": args.jurisdiction,
+            "min_context_tokens": args.min_context_tokens,
+            "requires_json": args.requires_json,
+            "requires_tools": args.requires_tools,
+            "requires_local": args.requires_local,
+            "limit": args.limit,
+        },
+    )
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0
+
+
+def _compare(args: argparse.Namespace) -> int:
+    models = load_model_registry(args.registry)
+    model_ids = [item.strip() for value in args.model for item in value.split(",") if item.strip()]
+    request = _load_json_mapping(args.request) if args.request else None
+    result = compare_models(models, model_ids, request)
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0 if result["ok"] else 2
+
+
+def _matrix(args: argparse.Namespace) -> int:
+    models = load_model_registry(args.registry)
+    result = route_scenario_matrix(models)
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0 if result["ok"] or args.allow_blocked_exit_zero else 2
+
+
+def _analytics(args: argparse.Namespace) -> int:
+    print(json.dumps(build_registry_analytics(load_model_registry(args.registry)), indent=2, sort_keys=True))
+    return 0
+
+
+def _opencode_config(args: argparse.Namespace) -> int:
+    models = load_model_registry(args.registry)
+    result = build_opencode_provider_config(models, base_url=args.base_url)
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0
+
+
 def _ui(args: argparse.Namespace) -> int:
     from .ui import run_ui
 
@@ -79,6 +135,52 @@ def build_parser() -> argparse.ArgumentParser:
     chat.add_argument("--request", type=Path, required=True, help="OpenAI chat request JSON.")
     chat.set_defaults(handler=_chat_dry_run)
 
+    catalog = subparsers.add_parser(
+        "catalog",
+        help="Search and filter the MaramaRoute model catalog.",
+    )
+    catalog.add_argument("--registry", type=Path, required=True, help="MaramaRoute model registry JSON.")
+    catalog.add_argument("--search", default="")
+    catalog.add_argument("--task", default="")
+    catalog.add_argument("--runtime", default="")
+    catalog.add_argument("--modality", default="")
+    catalog.add_argument("--jurisdiction", default="NZ")
+    catalog.add_argument("--min-context-tokens", type=int, default=0)
+    catalog.add_argument("--requires-json", action=argparse.BooleanOptionalAction, default=False)
+    catalog.add_argument("--requires-tools", action=argparse.BooleanOptionalAction, default=False)
+    catalog.add_argument("--requires-local", action=argparse.BooleanOptionalAction, default=False)
+    catalog.add_argument("--limit", type=int, default=25)
+    catalog.set_defaults(handler=_catalog)
+
+    compare = subparsers.add_parser(
+        "compare",
+        help="Compare routed fit for selected model ids.",
+    )
+    compare.add_argument("--registry", type=Path, required=True, help="MaramaRoute model registry JSON.")
+    compare.add_argument("--model", action="append", required=True, help="Model id, repeatable or comma-separated.")
+    compare.add_argument("--request", type=Path, default=None, help="Optional routing request JSON.")
+    compare.set_defaults(handler=_compare)
+
+    matrix = subparsers.add_parser(
+        "matrix",
+        help="Run the built-in sovereign routing scenario matrix.",
+    )
+    matrix.add_argument("--registry", type=Path, required=True, help="MaramaRoute model registry JSON.")
+    matrix.add_argument("--allow-blocked-exit-zero", action=argparse.BooleanOptionalAction, default=False)
+    matrix.set_defaults(handler=_matrix)
+
+    analytics = subparsers.add_parser("analytics", help="Summarise registry coverage.")
+    analytics.add_argument("--registry", type=Path, required=True, help="MaramaRoute model registry JSON.")
+    analytics.set_defaults(handler=_analytics)
+
+    opencode = subparsers.add_parser(
+        "opencode-config",
+        help="Emit an OpenCode-compatible MaramaRoute provider config.",
+    )
+    opencode.add_argument("--registry", type=Path, required=True, help="MaramaRoute model registry JSON.")
+    opencode.add_argument("--base-url", default="http://127.0.0.1:8787/v1")
+    opencode.set_defaults(handler=_opencode_config)
+
     ui = subparsers.add_parser(
         "ui",
         help="Launch the local MaramaRoute browser platform.",

marama_route/platform.py

@@ -0,0 +1,359 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from collections import Counter
+from typing import Any
+
+from .gateway import build_models_response, route_chat_payload
+from .registry import ModelEndpoint, RoutingRequest
+from .router import SovereignModelRouter
+
+DEFAULT_ROUTE_SCENARIOS: tuple[dict[str, Any], ...] = (
+    {
+        "name": "Restricted NZ code",
+        "prompt": "Refactor a private New Zealand Python service and return a JSON diff plan.",
+        "task_type": "code",
+        "modalities": ["text"],
+        "jurisdiction": "NZ",
+        "data_sensitivity": "restricted",
+        "min_context_tokens": 4096,
+        "requires_local": True,
+        "requires_json": True,
+        "requires_tools": False,
+        "max_fallbacks": 3,
+    },
+    {
+        "name": "Personal memory",
+        "prompt": "Summarise local operator preferences without exposing raw personal notes.",
+        "task_type": "general",
+        "modalities": ["text"],
+        "jurisdiction": "NZ",
+        "data_sensitivity": "personal",
+        "min_context_tokens": 4096,
+        "requires_local": True,
+        "requires_json": False,
+        "requires_tools": False,
+        "max_fallbacks": 3,
+    },
+    {
+        "name": "Vision document",
+        "prompt": "Read a scanned table image and extract structured rows.",
+        "task_type": "multimodal",
+        "modalities": ["text", "image"],
+        "jurisdiction": "NZ",
+        "data_sensitivity": "internal",
+        "min_context_tokens": 4096,
+        "requires_local": False,
+        "requires_json": True,
+        "requires_tools": False,
+        "max_fallbacks": 3,
+    },
+    {
+        "name": "Reasoning brief",
+        "prompt": "Reason through a procurement risk register and produce a concise decision memo.",
+        "task_type": "reasoning",
+        "modalities": ["text"],
+        "jurisdiction": "NZ",
+        "data_sensitivity": "internal",
+        "min_context_tokens": 8192,
+        "requires_local": True,
+        "requires_json": False,
+        "requires_tools": False,
+        "max_fallbacks": 3,
+    },
+)
+
+
+def build_registry_analytics(models: tuple[ModelEndpoint, ...]) -> dict[str, Any]:
+    runtimes = Counter(model.runtime for model in models)
+    families = Counter(model.family for model in models)
+    modalities = Counter(modality for model in models for modality in model.modalities)
+    tiers = Counter(str(model.sovereignty_tier) for model in models)
+    resident_nz = sum(1 for model in models if "NZ" in model.residency)
+    json_ready = sum(1 for model in models if model.supports_json)
+    tool_ready = sum(1 for model in models if model.supports_tools)
+    local_runtimes = sum(1 for model in models if _is_local_runtime(model.runtime))
+    context_values = [model.context_tokens for model in models]
+    return {
+        "model_count": len(models),
+        "resident_nz": resident_nz,
+        "local_runtimes": local_runtimes,
+        "json_ready": json_ready,
+        "tool_ready": tool_ready,
+        "max_context_tokens": max(context_values) if context_values else 0,
+        "avg_context_tokens": round(sum(context_values) / len(context_values), 2) if context_values else 0,
+        "runtimes": dict(sorted(runtimes.items())),
+        "families": dict(sorted(families.items())),
+        "modalities": dict(sorted(modalities.items())),
+        "sovereignty_tiers": dict(sorted(tiers.items())),
+        "top_models": [model_summary(model) for model in _top_models(models, limit=8)],
+    }
+
+
+def catalog_models(
+    models: tuple[ModelEndpoint, ...],
+    filters: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    filters = filters or {}
+    search = str(filters.get("search") or "").strip().lower()
+    runtime = str(filters.get("runtime") or "").strip().lower()
+    family = str(filters.get("family") or "").strip().lower()
+    modality = str(filters.get("modality") or "").strip().lower()
+    task_type = str(filters.get("task_type") or "").strip().lower()
+    jurisdiction = str(filters.get("jurisdiction") or "").strip().upper()
+    min_context = int(filters.get("min_context_tokens") or 0)
+    limit = int(filters.get("limit") or 50)
+    requires_json = bool(filters.get("requires_json", False))
+    requires_tools = bool(filters.get("requires_tools", False))
+    requires_local = bool(filters.get("requires_local", False))
+
+    filtered: list[ModelEndpoint] = []
+    for model in models:
+        haystack = " ".join(
+            (
+                model.model_id,
+                model.repo_id,
+                model.family,
+                model.runtime,
+                " ".join(model.tags),
+            ),
+        ).lower()
+        if search and search not in haystack:
+            continue
+        if runtime and model.runtime.lower() != runtime:
+            continue
+        if family and model.family.lower() != family:
+            continue
+        if modality and modality not in {item.lower() for item in model.modalities}:
+            continue
+        if task_type and not _matches_task(model, task_type):
+            continue
+        if jurisdiction and jurisdiction not in model.residency:
+            continue
+        if min_context and model.context_tokens < min_context:
+            continue
+        if requires_json and not model.supports_json:
+            continue
+        if requires_tools and not model.supports_tools:
+            continue
+        if requires_local and not _is_local_runtime(model.runtime):
+            continue
+        filtered.append(model)
+
+    ranked = sorted(filtered, key=_catalog_sort_key, reverse=True)
+    return {
+        "ok": True,
+        "count": len(ranked),
+        "filters": filters,
+        "models": [model_summary(model) for model in ranked[:limit]],
+    }
+
+
+def compare_models(
+    models: tuple[ModelEndpoint, ...],
+    model_ids: list[str],
+    request_payload: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    index = {model.model_id: model for model in models}
+    selected = [index[model_id] for model_id in model_ids if model_id in index]
+    missing = [model_id for model_id in model_ids if model_id not in index]
+    request = RoutingRequest.from_payload(request_payload or DEFAULT_ROUTE_SCENARIOS[0])
+    route_scores = SovereignModelRouter(tuple(selected)).route(request).scores if selected else {}
+    rows = []
+    for model in selected:
+        row = model_summary(model)
+        row["route_score"] = route_scores.get(model.model_id)
+        row["operator_score"] = _operator_score(model)
+        rows.append(row)
+    winner = max(rows, key=lambda item: (item.get("route_score") or -1, item["operator_score"]), default=None)
+    return {
+        "ok": bool(rows),
+        "missing": missing,
+        "request": request.to_dict(),
+        "winner": winner,
+        "models": rows,
+    }
+
+
+def route_scenario_matrix(
+    models: tuple[ModelEndpoint, ...],
+    scenarios: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    router = SovereignModelRouter(models)
+    rows = []
+    for scenario in scenarios or [dict(item) for item in DEFAULT_ROUTE_SCENARIOS]:
+        request = RoutingRequest.from_payload(scenario)
+        decision = router.route(request)
+        selected = decision.selected_model
+        rows.append(
+            {
+                "name": scenario.get("name", request.task_type),
+                "ok": selected is not None,
+                "task_type": request.task_type,
+                "sensitivity": request.data_sensitivity,
+                "selected_model": selected.model_id if selected else None,
+                "runtime": selected.runtime if selected else None,
+                "fallback_count": len(decision.fallback_models),
+                "rejected_count": len(decision.rejected),
+                "reasons": list(decision.reasons),
+            },
+        )
+    return {"ok": all(row["ok"] for row in rows), "scenarios": rows}
+
+
+def build_opencode_provider_config(
+    models: tuple[ModelEndpoint, ...],
+    *,
+    base_url: str = "http://127.0.0.1:8787/v1",
+    provider_id: str = "abteex-marama",
+) -> dict[str, Any]:
+    route = SovereignModelRouter(models).route(RoutingRequest.from_payload(DEFAULT_ROUTE_SCENARIOS[0]))
+    default_model = route.selected_model or (_top_models(models, limit=1)[0] if models else None)
+    catalog = _top_models(models, limit=14)
+    model_entries = {
+        model.model_id: {
+            "name": model.model_id,
+            "context": model.context_tokens,
+            "modalities": list(model.modalities),
+            "residency": list(model.residency),
+            "runtime": model.runtime,
+        }
+        for model in catalog
+    }
+    return {
+        "$schema": "https://opencode.ai/config.json",
+        "provider": {
+            provider_id: {
+                "name": "AbteeX MaramaRoute",
+                "npm": "@ai-sdk/openai-compatible",
+                "options": {
+                    "baseURL": base_url,
+                    "apiKey": "${ABTEEX_MARAMA_API_KEY:-local-dev}",
+                },
+                "models": model_entries,
+            },
+        },
+        "model": f"{provider_id}/{default_model.model_id}" if default_model else "",
+        "small_model": f"{provider_id}/{catalog[-1].model_id}" if catalog else "",
+    }
+
+
+def route_receipt(payload: dict[str, Any], route_result: dict[str, Any]) -> dict[str, Any]:
+    selected = route_result.get("route_decision", {}).get("selected_model")
+    receipt_payload = {
+        "request": payload,
+        "selected_model_id": selected.get("model_id") if isinstance(selected, dict) else None,
+        "rejected_count": len(route_result.get("route_decision", {}).get("rejected", [])),
+    }
+    digest = hashlib.sha256(
+        json.dumps(receipt_payload, sort_keys=True, default=str).encode("utf-8"),
+    ).hexdigest()
+    return {
+        "receipt_id": f"marama-{digest[:16]}",
+        "request_hash": digest,
+        "selected_model": receipt_payload["selected_model_id"],
+        "prompt_retention": "not_stored_by_default",
+        "audit_fields": [
+            "request_hash",
+            "selected_model",
+            "fallback_models",
+            "rejected_count",
+            "residency",
+            "runtime",
+        ],
+    }
+
+
+def route_or_chat_payload(payload: dict[str, Any], models: tuple[ModelEndpoint, ...]) -> dict[str, Any]:
+    if "messages" in payload:
+        result = route_chat_payload(payload, models)
+        selected = result["route_decision"]["selected_model"]
+        result = {"ok": selected is not None, "mode": "openai_chat_dry_run", **result}
+    else:
+        request = RoutingRequest.from_payload(payload)
+        decision = SovereignModelRouter(models).route(request)
+        result = {
+            "ok": decision.selected_model is not None,
+            "mode": "route",
+            "routing_request": request.to_dict(),
+            "route_decision": decision.to_dict(),
+        }
+    result["receipt"] = route_receipt(payload, result)
+    return result
+
+
+def build_models_api(models: tuple[ModelEndpoint, ...]) -> dict[str, Any]:
+    response = build_models_response(models)
+    response["analytics"] = build_registry_analytics(models)
+    return response
+
+
+def model_summary(model: ModelEndpoint) -> dict[str, Any]:
+    return {
+        "model_id": model.model_id,
+        "repo_id": model.repo_id,
+        "family": model.family,
+        "runtime": model.runtime,
+        "modalities": list(model.modalities),
+        "context_tokens": model.context_tokens,
+        "residency": list(model.residency),
+        "license_id": model.license_id,
+        "active_params_b": model.active_params_b,
+        "total_params_b": model.total_params_b,
+        "quality_rank": model.quality_rank,
+        "cost_rank": model.cost_rank,
+        "sovereignty_tier": model.sovereignty_tier,
+        "supports_json": model.supports_json,
+        "supports_tools": model.supports_tools,
+        "tags": list(model.tags),
+        "operator_score": _operator_score(model),
+    }
+
+
+def scenario_presets() -> list[dict[str, Any]]:
+    return [dict(item) for item in DEFAULT_ROUTE_SCENARIOS]
+
+
+def _top_models(models: tuple[ModelEndpoint, ...], *, limit: int) -> list[ModelEndpoint]:
+    return sorted(models, key=_catalog_sort_key, reverse=True)[:limit]
+
+
+def _catalog_sort_key(model: ModelEndpoint) -> tuple[float, int, str]:
+    return (_operator_score(model), model.context_tokens, model.model_id)
+
+
+def _operator_score(model: ModelEndpoint) -> float:
+    score = 0.0
+    if "NZ" in model.residency:
+        score += 25
+    if _is_local_runtime(model.runtime):
+        score += 15
+    score += model.sovereignty_tier * 10
+    score += max(0, 10 - model.quality_rank) * 3
+    score -= model.cost_rank
+    if model.supports_json:
+        score += 5
+    if model.supports_tools:
+        score += 5
+    if model.context_tokens >= 32768:
+        score += 6
+    elif model.context_tokens >= 8192:
+        score += 3
+    return round(score, 2)
+
+
+def _matches_task(model: ModelEndpoint, task_type: str) -> bool:
+    tags = set(model.tags)
+    if task_type in tags or task_type in model.family.lower() or task_type in model.model_id.lower():
+        return True
+    if task_type == "code":
+        return "coder" in tags or "coder" in model.model_id.lower()
+    if task_type == "multimodal":
+        return "image" in model.modalities or "multimodal" in tags
+    return False
+
+
+def _is_local_runtime(runtime: str) -> bool:
+    value = runtime.lower()
+    return value in {"llama_cpp", "gguf", "transformers", "sentence_transformers"} or "local" in value

marama_route/ui.py

@@ -6,9 +6,17 @@ from typing import Any
 
 from ._ui_server import serve_dashboard
 
-from .gateway import build_models_response, route_chat_payload
-from .registry import RoutingRequest, load_model_registry
-from .router import SovereignModelRouter
+from .platform import (
+    build_models_api,
+    build_opencode_provider_config,
+    build_registry_analytics,
+    catalog_models,
+    compare_models,
+    route_or_chat_payload,
+    route_scenario_matrix,
+    scenario_presets,
+)
+from .registry import load_model_registry
 
 PRODUCT_NAME = "LumynaX MaramaRoute"
 PACKAGE_ROOT = Path(__file__).resolve().parent
@@ -49,24 +57,7 @@ def load_json_mapping(path: Path) -> dict[str, Any]:
 
 
 def route_dashboard_payload(payload: dict[str, Any], registry_path: Path) -> dict[str, Any]:
-    models = load_model_registry(registry_path)
-    if "messages" in payload:
-        result = route_chat_payload(payload, models)
-        selected = result["route_decision"]["selected_model"]
-        return {
-            "ok": selected is not None,
-            "mode": "openai_chat_dry_run",
-            **result,
-        }
-
-    request = RoutingRequest.from_payload(payload)
-    decision = SovereignModelRouter(models).route(request)
-    return {
-        "ok": decision.selected_model is not None,
-        "mode": "route",
-        "routing_request": request.to_dict(),
-        "route_decision": decision.to_dict(),
-    }
+    return route_or_chat_payload(payload, load_model_registry(registry_path))
 
 
 def build_dashboard_state(registry_path: Path) -> dict[str, Any]:
@@ -76,15 +67,19 @@ def build_dashboard_state(registry_path: Path) -> dict[str, Any]:
         if default_openai_chat_request_path().exists()
         else _fallback_chat_example()
     )
-    runtimes = sorted({model.runtime for model in models})
-    resident_nz = sum(1 for model in models if "NZ" in model.residency)
+    analytics = build_registry_analytics(models)
     return {
         "registry_path": str(registry_path),
         "model_count": len(models),
-        "resident_nz": resident_nz,
-        "runtimes": runtimes,
+        "resident_nz": analytics["resident_nz"],
+        "runtimes": sorted(analytics["runtimes"]),
         "example": example,
-        "models": build_models_response(models),
+        "models": build_models_api(models),
+        "analytics": analytics,
+        "catalog": catalog_models(models, {"limit": 14})["models"],
+        "scenarios": scenario_presets(),
+        "matrix": route_scenario_matrix(models),
+        "opencode_config": build_opencode_provider_config(models),
     }
 
 
@@ -98,7 +93,9 @@ def handle_api_request(
         state = build_dashboard_state(registry_path)
         return 200, {"ok": True, "product": PRODUCT_NAME, "model_count": state["model_count"]}
     if method == "GET" and path == "/api/models":
-        return 200, build_dashboard_state(registry_path)["models"]
+        return 200, build_models_api(load_model_registry(registry_path))
+    if method == "GET" and path == "/api/analytics":
+        return 200, {"ok": True, **build_registry_analytics(load_model_registry(registry_path))}
     if method == "GET" and path == "/api/state":
         return 200, {"ok": True, **build_dashboard_state(registry_path)}
     if method == "POST" and path == "/api/route" and payload is not None:
@@ -107,6 +104,26 @@ def handle_api_request(
         if not result["ok"]:
             status = 422
         return status, result
+    if method == "POST" and path == "/api/catalog" and payload is not None:
+        return 200, catalog_models(load_model_registry(registry_path), payload)
+    if method == "POST" and path == "/api/compare" and payload is not None:
+        model_ids = payload.get("model_ids") or payload.get("models") or []
+        if isinstance(model_ids, str):
+            model_ids = [item.strip() for item in model_ids.split(",") if item.strip()]
+        request_payload = payload.get("request") if isinstance(payload.get("request"), dict) else None
+        result = compare_models(load_model_registry(registry_path), list(model_ids), request_payload)
+        return (200 if result["ok"] else 422), result
+    if method == "POST" and path == "/api/matrix" and payload is not None:
+        scenarios = payload.get("scenarios") if isinstance(payload.get("scenarios"), list) else None
+        return 200, route_scenario_matrix(load_model_registry(registry_path), scenarios)
+    if method == "POST" and path == "/api/opencode-config" and payload is not None:
+        return 200, {
+            "ok": True,
+            "config": build_opencode_provider_config(
+                load_model_registry(registry_path),
+                base_url=str(payload.get("base_url") or "http://127.0.0.1:8787/v1"),
+            ),
+        }
     return 404, {"ok": False, "error": "not_found"}
 
 
@@ -116,11 +133,17 @@ def smoke_ui(registry_path: Path | None = None) -> dict[str, Any]:
     routed = route_dashboard_payload(state["example"], resolved_registry)
     if not routed["ok"]:
         raise RuntimeError("MaramaRoute UI smoke route did not select a model")
+    catalog = catalog_models(load_model_registry(resolved_registry), {"task_type": "code", "limit": 3})
+    matrix = route_scenario_matrix(load_model_registry(resolved_registry))
+    if not catalog["models"] or not matrix["ok"]:
+        raise RuntimeError("MaramaRoute expanded UI smoke checks failed")
     return {
         "ok": True,
         "product": PRODUCT_NAME,
         "model_count": state["model_count"],
         "selected_model": routed["route_decision"]["selected_model"]["model_id"],
+        "catalog_count": catalog["count"],
+        "scenario_count": len(matrix["scenarios"]),
     }
 
 
@@ -136,7 +159,7 @@ def run_ui(
     if smoke:
         print(json.dumps(smoke_ui(resolved_registry), indent=2, sort_keys=True))
         return 0
-    html = build_dashboard_html(build_dashboard_state(resolved_registry))
+    html = build_expanded_dashboard_html(build_dashboard_state(resolved_registry))
     return serve_dashboard(
         product_name=PRODUCT_NAME,
         html=html,
@@ -152,6 +175,334 @@ def run_ui(
     )
 
 
+def build_expanded_dashboard_html(state: dict[str, Any]) -> str:
+    initial = json.dumps(state, sort_keys=True).replace("</", "<\\/")
+    html = """<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>LumynaX MaramaRoute Console</title>
+  <style>
+    :root {
+      --paper: #fffefa;
+      --ink: #0a0a0b;
+      --muted: #726b62;
+      --rule: #ded6c8;
+      --amber: #e08a2c;
+      --amber-dark: #9a5416;
+      --green: #275f45;
+      --red: #8f2e24;
+      --panel: #f7f1e7;
+      --chalk: #fff7e8;
+      --mono: "Cascadia Code", "SFMono-Regular", Menlo, Consolas, monospace;
+      --serif: Georgia, "Iowan Old Style", "Palatino Linotype", serif;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      background:
+        linear-gradient(90deg, rgba(10,10,11,.035) 1px, transparent 1px) 0 0 / 44px 44px,
+        linear-gradient(0deg, rgba(10,10,11,.025) 1px, transparent 1px) 0 0 / 44px 44px,
+        var(--paper);
+      color: var(--ink);
+      font-family: var(--serif);
+    }
+    header {
+      display: grid;
+      grid-template-columns: minmax(260px, 1fr) minmax(320px, 48vw);
+      gap: 24px;
+      align-items: end;
+      padding: 22px 28px 16px;
+      border-bottom: 1px solid var(--rule);
+      background: rgba(255,254,250,.92);
+    }
+    h1 {
+      margin: 0;
+      font-size: clamp(34px, 5vw, 68px);
+      line-height: .88;
+      letter-spacing: 0;
+    }
+    .subtitle, label, button, input, select, .metric, .pill, th, td {
+      font-family: var(--mono);
+      font-size: 12px;
+      letter-spacing: 0;
+    }
+    .subtitle { margin-top: 10px; color: var(--muted); }
+    .metrics { display: grid; grid-template-columns: repeat(5, minmax(0, 1fr)); gap: 8px; }
+    .metric { border-left: 2px solid var(--amber); min-height: 60px; padding: 7px 8px; background: rgba(247,241,231,.72); }
+    .metric strong { display: block; font: 700 22px/1 var(--serif); color: var(--ink); overflow-wrap: anywhere; }
+    main { display: grid; grid-template-columns: minmax(340px, 440px) 1fr; min-height: calc(100vh - 118px); }
+    aside { border-right: 1px solid var(--rule); background: rgba(255,250,242,.95); padding: 18px; }
+    section { min-width: 0; }
+    .stack { display: grid; gap: 12px; }
+    .grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 12px; }
+    .wide { grid-column: 1 / -1; }
+    .panel, textarea, input, select, pre, table { border: 1px solid var(--rule); border-radius: 6px; background: var(--paper); color: var(--ink); }
+    .panel { padding: 14px; }
+    .panel h2 { margin: 0 0 10px; font-size: 18px; line-height: 1.1; }
+    textarea {
+      width: 100%;
+      min-height: 270px;
+      resize: vertical;
+      padding: 12px;
+      font: 12px/1.45 var(--mono);
+    }
+    input, select { width: 100%; min-height: 34px; padding: 0 10px; }
+    button {
+      appearance: none;
+      border: 1px solid var(--ink);
+      background: var(--ink);
+      color: var(--paper);
+      border-radius: 4px;
+      min-height: 34px;
+      padding: 0 12px;
+      cursor: pointer;
+      white-space: nowrap;
+    }
+    button.secondary { background: transparent; color: var(--ink); border-color: var(--rule); }
+    .toolbar { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; }
+    .content { padding: 18px; display: grid; gap: 12px; align-content: start; }
+    .status { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 10px; }
+    .status .panel { min-height: 92px; }
+    .k { font: 12px/1.25 var(--mono); color: var(--muted); display: block; }
+    .v { display: block; margin-top: 8px; font-size: 18px; line-height: 1.12; overflow-wrap: anywhere; }
+    .ok { color: var(--green); }
+    .bad { color: var(--red); }
+    pre { margin: 0; padding: 14px; max-height: 520px; overflow: auto; font: 12px/1.45 var(--mono); }
+    table { width: 100%; border-collapse: collapse; overflow: hidden; }
+    th, td { padding: 9px 10px; text-align: left; border-bottom: 1px solid var(--rule); vertical-align: top; }
+    th { color: var(--muted); background: var(--panel); }
+    tr:last-child td { border-bottom: 0; }
+    .pills { display: flex; flex-wrap: wrap; gap: 6px; }
+    .pill { display: inline-flex; border: 1px solid var(--rule); border-radius: 999px; min-height: 24px; align-items: center; padding: 0 9px; background: var(--chalk); }
+    .split { display: grid; grid-template-columns: minmax(0, 1fr) minmax(0, 1fr); gap: 12px; }
+    @media (max-width: 1120px) {
+      header, main, .split { grid-template-columns: 1fr; }
+      aside { border-right: 0; border-bottom: 1px solid var(--rule); }
+      .metrics, .status { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+    }
+    @media (max-width: 680px) {
+      header, aside, .content { padding: 14px; }
+      .grid, .metrics, .status { grid-template-columns: 1fr; }
+    }
+  </style>
+</head>
+<body>
+  <header>
+    <div>
+      <h1>LumynaX<br />MaramaRoute</h1>
+      <div class="subtitle">Sovereign router control surface for LumynaX model selection.</div>
+    </div>
+    <div class="metrics">
+      <div class="metric"><strong id="metricModels">0</strong>models</div>
+      <div class="metric"><strong id="metricNz">0</strong>NZ resident</div>
+      <div class="metric"><strong id="metricLocal">0</strong>local runtime</div>
+      <div class="metric"><strong id="metricJson">0</strong>JSON ready</div>
+      <div class="metric"><strong id="metricContext">0</strong>max ctx</div>
+    </div>
+  </header>
+  <main>
+    <aside class="stack">
+      <div class="toolbar">
+        <button id="routeBtn">Route</button>
+        <button class="secondary" id="matrixBtn">Matrix</button>
+        <button class="secondary" id="providerBtn">Provider</button>
+      </div>
+      <div>
+        <label for="preset">PRESET</label>
+        <select id="preset"></select>
+      </div>
+      <div>
+        <label for="request">REQUEST JSON</label>
+        <textarea id="request" spellcheck="false"></textarea>
+      </div>
+      <div class="panel stack">
+        <h2>Catalog</h2>
+        <div class="grid">
+          <div>
+            <label for="search">SEARCH</label>
+            <input id="search" value="qwen" />
+          </div>
+          <div>
+            <label for="task">TASK</label>
+            <select id="task">
+              <option value="">any</option>
+              <option value="code">code</option>
+              <option value="reasoning">reasoning</option>
+              <option value="multimodal">multimodal</option>
+              <option value="general">general</option>
+            </select>
+          </div>
+          <div>
+            <label for="runtime">RUNTIME</label>
+            <select id="runtime"></select>
+          </div>
+          <div>
+            <label for="context">MIN CONTEXT</label>
+            <input id="context" type="number" min="0" value="4096" />
+          </div>
+        </div>
+        <div class="toolbar">
+          <button class="secondary" id="catalogBtn">Filter</button>
+          <button class="secondary" id="compareBtn">Compare Top</button>
+        </div>
+      </div>
+    </aside>
+    <section class="content">
+      <div class="status">
+        <div class="panel"><span class="k">SELECTED</span><span class="v" id="selected">pending</span></div>
+        <div class="panel"><span class="k">MODE</span><span class="v" id="mode">ready</span></div>
+        <div class="panel"><span class="k">FALLBACKS</span><span class="v" id="fallbacks">0</span></div>
+        <div class="panel"><span class="k">RECEIPT</span><span class="v" id="receipt">none</span></div>
+      </div>
+      <div class="split">
+        <div class="panel">
+          <h2>Route Result</h2>
+          <pre id="output"></pre>
+        </div>
+        <div class="panel">
+          <h2>Scenario Matrix</h2>
+          <table>
+            <thead><tr><th>Scenario</th><th>Model</th><th>Rejected</th></tr></thead>
+            <tbody id="matrixRows"></tbody>
+          </table>
+        </div>
+      </div>
+      <div class="panel">
+        <h2>Model Catalog</h2>
+        <table>
+          <thead><tr><th>Model</th><th>Runtime</th><th>Fit</th><th>Caps</th></tr></thead>
+          <tbody id="catalogRows"></tbody>
+        </table>
+      </div>
+      <div class="panel">
+        <h2>Provider Config</h2>
+        <pre id="provider"></pre>
+      </div>
+    </section>
+  </main>
+  <script type="application/json" id="initial-state">__INITIAL__</script>
+  <script>
+    const state = JSON.parse(document.getElementById('initial-state').textContent);
+    const request = document.getElementById('request');
+    const preset = document.getElementById('preset');
+    const output = document.getElementById('output');
+    const provider = document.getElementById('provider');
+    const selected = document.getElementById('selected');
+    const mode = document.getElementById('mode');
+    const fallbacks = document.getElementById('fallbacks');
+    const receipt = document.getElementById('receipt');
+    const catalogRows = document.getElementById('catalogRows');
+    const matrixRows = document.getElementById('matrixRows');
+    const runtime = document.getElementById('runtime');
+
+    function writeJson(node, value) {
+      node.textContent = JSON.stringify(value, null, 2);
+    }
+    function safeJson(text) {
+      try { return [JSON.parse(text), null]; }
+      catch (error) { return [null, error.message]; }
+    }
+    function setMetric(id, value) { document.getElementById(id).textContent = value; }
+    setMetric('metricModels', state.analytics.model_count);
+    setMetric('metricNz', state.analytics.resident_nz);
+    setMetric('metricLocal', state.analytics.local_runtimes);
+    setMetric('metricJson', state.analytics.json_ready);
+    setMetric('metricContext', state.analytics.max_context_tokens);
+
+    runtime.innerHTML = '<option value="">any</option>' + Object.keys(state.analytics.runtimes).map(item => `<option value="${item}">${item}</option>`).join('');
+    preset.innerHTML = state.scenarios.map((item, index) => `<option value="${index}">${item.name}</option>`).join('');
+    preset.addEventListener('change', () => {
+      request.value = JSON.stringify(state.scenarios[Number(preset.value)], null, 2);
+    });
+    request.value = JSON.stringify(state.example, null, 2);
+    writeJson(output, {status: 'ready', registry: state.registry_path});
+    writeJson(provider, state.opencode_config);
+
+    function renderCatalog(rows) {
+      catalogRows.innerHTML = rows.map(row => {
+        const caps = [
+          row.residency.includes('NZ') ? 'NZ' : '',
+          row.supports_json ? 'JSON' : '',
+          row.supports_tools ? 'TOOLS' : '',
+          `${row.context_tokens} ctx`
+        ].filter(Boolean).map(item => `<span class="pill">${item}</span>`).join(' ');
+        return `<tr><td>${row.model_id}<br><span class="k">${row.repo_id}</span></td><td>${row.runtime}</td><td>${row.operator_score}</td><td><div class="pills">${caps}</div></td></tr>`;
+      }).join('');
+    }
+    function renderMatrix(rows) {
+      matrixRows.innerHTML = rows.map(row => `<tr><td>${row.name}<br><span class="k">${row.sensitivity}</span></td><td class="${row.ok ? 'ok' : 'bad'}">${row.selected_model || 'none'}</td><td>${row.rejected_count}</td></tr>`).join('');
+    }
+    function setResult(data) {
+      writeJson(output, data);
+      const decision = data.route_decision || {};
+      const model = decision.selected_model || {};
+      selected.textContent = model.model_id || 'none';
+      selected.className = model.model_id ? 'v ok' : 'v bad';
+      mode.textContent = data.mode || 'result';
+      fallbacks.textContent = decision.fallback_models ? decision.fallback_models.length : 0;
+      receipt.textContent = data.receipt ? data.receipt.receipt_id : 'none';
+    }
+    async function postJson(path, payload) {
+      const response = await fetch(path, {
+        method: 'POST',
+        headers: {'Content-Type': 'application/json'},
+        body: JSON.stringify(payload)
+      });
+      return response.json();
+    }
+    async function route() {
+      const [payload, error] = safeJson(request.value);
+      if (error) { setResult({ok: false, error}); return; }
+      setResult(await postJson('/api/route', payload));
+    }
+    async function loadCatalog() {
+      const filters = {
+        search: document.getElementById('search').value,
+        task_type: document.getElementById('task').value,
+        runtime: runtime.value,
+        min_context_tokens: Number(document.getElementById('context').value || 0),
+        jurisdiction: 'NZ',
+        limit: 18
+      };
+      const data = await postJson('/api/catalog', filters);
+      renderCatalog(data.models);
+      writeJson(output, data);
+    }
+    async function compareTop() {
+      const ids = Array.from(catalogRows.querySelectorAll('tr')).slice(0, 4).map(row => row.cells[0].childNodes[0].textContent);
+      const data = await postJson('/api/compare', {model_ids: ids});
+      writeJson(output, data);
+      if (data.winner) {
+        selected.textContent = data.winner.model_id;
+        selected.className = 'v ok';
+        mode.textContent = 'compare';
+      }
+    }
+    async function matrix() {
+      const data = await postJson('/api/matrix', {scenarios: state.scenarios});
+      renderMatrix(data.scenarios);
+      writeJson(output, data);
+    }
+    async function providerConfig() {
+      const data = await postJson('/api/opencode-config', {base_url: 'http://127.0.0.1:8787/v1'});
+      writeJson(provider, data.config);
+      writeJson(output, data);
+    }
+    document.getElementById('routeBtn').addEventListener('click', route);
+    document.getElementById('catalogBtn').addEventListener('click', loadCatalog);
+    document.getElementById('compareBtn').addEventListener('click', compareTop);
+    document.getElementById('matrixBtn').addEventListener('click', matrix);
+    document.getElementById('providerBtn').addEventListener('click', providerConfig);
+    renderCatalog(state.catalog);
+    renderMatrix(state.matrix.scenarios);
+  </script>
+</body>
+</html>"""
+    return html.replace("__INITIAL__", initial)
+
+
 def build_dashboard_html(state: dict[str, Any]) -> str:
     initial = json.dumps(state, sort_keys=True).replace("</", "<\\/")
     return f"""<!doctype html>

product_manifest.json

@@ -21,11 +21,18 @@
     "lumynax_runtime_adapter",
     "audit_ledger",
     "human_review_gate",
+    "policy_matrix",
+    "tool_gate_check",
+    "capsule_summary",
+    "opencode_workspace_export",
     "opencode_compatible_provider"
   ],
   "runtime_entrypoints": [
     "python -m tinyluminax.products.sovereigncode.cli evaluate",
     "python -m tinyluminax.products.sovereigncode.cli plan-turn",
+    "python -m tinyluminax.products.sovereigncode.cli policy-matrix",
+    "python -m tinyluminax.products.sovereigncode.cli tool-check",
+    "python -m tinyluminax.products.sovereigncode.cli opencode-config",
     "python -m tinyluminax.products.sovereigncode.cli ui"
   ],
   "integration_surfaces": [
@@ -34,6 +41,8 @@
     "OpenCode custom provider config",
     "local CLI policy evaluator",
     "governed coding-turn planner",
+    "policy matrix and tool gate checker",
+    "browser operator checklist",
     "browser operator console"
   ],
   "brand_system": {

quickstart.py

@@ -28,6 +28,24 @@ if __name__ == "__main__":
             "ui",
             "--smoke",
         ],
+        [
+            "policy-matrix",
+            "--capsule",
+            str(ROOT / "examples" / "capsule.restricted-nz-code.json"),
+            "--request",
+            str(ROOT / "examples" / "request.allowed-local-edit.json"),
+        ],
+        [
+            "tool-check",
+            "--capsule",
+            str(ROOT / "examples" / "capsule.restricted-nz-code.json"),
+            "--request",
+            str(ROOT / "examples" / "request.allowed-local-edit.json"),
+            "--tool-name",
+            "workspace_reader",
+            "--action",
+            "read_context",
+        ],
         [
             "plan-turn",
             "--capsule",

sovereigncode/__init__.py

@@ -2,6 +2,13 @@ from __future__ import annotations
 
 from .audit import AuditRecord, build_audit_record
 from .planner import SovereignCodingTurnPlan, ToolGrant, plan_coding_turn
+from .platform import (
+    build_capsule_summary,
+    build_opencode_workspace_config,
+    build_policy_matrix,
+    build_turn_brief,
+    check_tool_request,
+)
 from .policy import (
     DataCapsule,
     PolicyDecision,
@@ -19,6 +26,11 @@ __all__ = [
     "SovereigntyPolicyEngine",
     "ToolGrant",
     "build_audit_record",
+    "build_capsule_summary",
+    "build_opencode_workspace_config",
+    "build_policy_matrix",
+    "build_turn_brief",
+    "check_tool_request",
     "plan_coding_turn",
     "smoke_ui",
 ]

sovereigncode/cli.py

@@ -12,6 +12,13 @@ from marama_route import RoutingRequest, load_model_registry
 
 from .audit import build_audit_record
 from .planner import plan_coding_turn
+from .platform import (
+    build_capsule_summary,
+    build_opencode_workspace_config,
+    build_policy_matrix,
+    build_turn_brief,
+    check_tool_request,
+)
 from .policy import DataCapsule, SovereignRequest, SovereigntyPolicyEngine
 
 
@@ -43,10 +50,52 @@ def _plan_turn(args: argparse.Namespace) -> int:
     routing_request = RoutingRequest.from_payload(_load_mapping(args.route_request))
     models = load_model_registry(args.registry)
     plan = plan_coding_turn(capsule, request, routing_request, models)
-    print(json.dumps(plan.to_dict(), indent=2, sort_keys=True))
+    payload = plan.to_dict()
+    payload["turn_brief"] = build_turn_brief(payload)
+    print(json.dumps(payload, indent=2, sort_keys=True))
     return 0 if plan.allowed or args.allow_blocked_exit_zero else 2
 
 
+def _policy_matrix(args: argparse.Namespace) -> int:
+    result = build_policy_matrix(_load_mapping(args.capsule), _load_mapping(args.request))
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0 if result["blocked_count"] >= 0 else 2
+
+
+def _tool_check(args: argparse.Namespace) -> int:
+    tool_payload = {
+        "tool_name": args.tool_name,
+        "action": args.action,
+        "writes_files": args.writes_files,
+        "exports_data": args.exports_data,
+        "trains_model": args.trains_model,
+        "human_approved": args.human_approved,
+    }
+    result = check_tool_request(
+        _load_mapping(args.capsule),
+        _load_mapping(args.request),
+        tool_payload,
+    )
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0 if result["ok"] or args.allow_blocked_exit_zero else 2
+
+
+def _capsule_summary(args: argparse.Namespace) -> int:
+    print(json.dumps(build_capsule_summary(_load_mapping(args.capsule)), indent=2, sort_keys=True))
+    return 0
+
+
+def _opencode_config(args: argparse.Namespace) -> int:
+    print(
+        json.dumps(
+            build_opencode_workspace_config(base_url=args.base_url, model=args.model),
+            indent=2,
+            sort_keys=True,
+        ),
+    )
+    return 0
+
+
 def _ui(args: argparse.Namespace) -> int:
     from .ui import run_ui
 
@@ -106,6 +155,44 @@ def build_parser() -> argparse.ArgumentParser:
     )
     plan_turn.set_defaults(handler=_plan_turn)
 
+    matrix = subparsers.add_parser(
+        "policy-matrix",
+        help="Evaluate the built-in tool/action matrix against a capsule.",
+    )
+    matrix.add_argument("--capsule", type=Path, required=True, help="Data Capsule JSON/YAML file.")
+    matrix.add_argument("--request", type=Path, required=True, help="Base sovereign request JSON/YAML file.")
+    matrix.set_defaults(handler=_policy_matrix)
+
+    tool_check = subparsers.add_parser(
+        "tool-check",
+        help="Check one tool/action request before execution.",
+    )
+    tool_check.add_argument("--capsule", type=Path, required=True, help="Data Capsule JSON/YAML file.")
+    tool_check.add_argument("--request", type=Path, required=True, help="Base sovereign request JSON/YAML file.")
+    tool_check.add_argument("--tool-name", default="workspace_reader")
+    tool_check.add_argument("--action", default="read_context")
+    tool_check.add_argument("--writes-files", action=argparse.BooleanOptionalAction, default=False)
+    tool_check.add_argument("--exports-data", action=argparse.BooleanOptionalAction, default=False)
+    tool_check.add_argument("--trains-model", action=argparse.BooleanOptionalAction, default=False)
+    tool_check.add_argument("--human-approved", action=argparse.BooleanOptionalAction, default=False)
+    tool_check.add_argument("--allow-blocked-exit-zero", action=argparse.BooleanOptionalAction, default=False)
+    tool_check.set_defaults(handler=_tool_check)
+
+    capsule_summary = subparsers.add_parser(
+        "capsule-summary",
+        help="Summarise Data Capsule controls and risk flags.",
+    )
+    capsule_summary.add_argument("--capsule", type=Path, required=True, help="Data Capsule JSON/YAML file.")
+    capsule_summary.set_defaults(handler=_capsule_summary)
+
+    opencode = subparsers.add_parser(
+        "opencode-config",
+        help="Emit an OpenCode-compatible SovereignCode workspace config.",
+    )
+    opencode.add_argument("--base-url", default="http://127.0.0.1:8787/v1")
+    opencode.add_argument("--model", default="lumynax-infused-qwen3-coder-30b-a3b-gguf")
+    opencode.set_defaults(handler=_opencode_config)
+
     ui = subparsers.add_parser(
         "ui",
         help="Launch the local SovereignCode browser platform.",

sovereigncode/platform.py

@@ -0,0 +1,275 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .audit import build_audit_record
+from .policy import DataCapsule, SovereignRequest, SovereigntyPolicyEngine
+
+TOOL_SCENARIOS: tuple[dict[str, Any], ...] = (
+    {
+        "name": "Read workspace",
+        "action": "read_context",
+        "tool_name": "workspace_reader",
+        "writes_files": False,
+        "exports_data": False,
+        "trains_model": False,
+        "human_approved": False,
+    },
+    {
+        "name": "Write file",
+        "action": "write_file",
+        "tool_name": "file_editor",
+        "writes_files": True,
+        "exports_data": False,
+        "trains_model": False,
+        "human_approved": False,
+    },
+    {
+        "name": "Approved shell",
+        "action": "execute_shell",
+        "tool_name": "test_runner",
+        "writes_files": False,
+        "exports_data": False,
+        "trains_model": False,
+        "human_approved": True,
+    },
+    {
+        "name": "Network export",
+        "action": "network_export",
+        "tool_name": "external_api",
+        "writes_files": False,
+        "exports_data": True,
+        "trains_model": False,
+        "human_approved": True,
+    },
+    {
+        "name": "Model training",
+        "action": "train_model",
+        "tool_name": "trainer",
+        "writes_files": False,
+        "exports_data": False,
+        "trains_model": True,
+        "human_approved": True,
+    },
+    {
+        "name": "Publish commit",
+        "action": "commit",
+        "tool_name": "git",
+        "writes_files": False,
+        "exports_data": True,
+        "trains_model": False,
+        "human_approved": True,
+    },
+)
+
+
+def build_policy_matrix(
+    capsule_payload: dict[str, Any],
+    request_payload: dict[str, Any],
+    scenarios: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    capsule = DataCapsule.from_payload(capsule_payload)
+    engine = SovereigntyPolicyEngine()
+    rows = []
+    for scenario in scenarios or [dict(item) for item in TOOL_SCENARIOS]:
+        merged = dict(request_payload)
+        merged.update({key: value for key, value in scenario.items() if key != "name"})
+        request = SovereignRequest.from_payload(merged)
+        decision = engine.evaluate(capsule, request)
+        audit = build_audit_record(capsule, request, decision)
+        rows.append(
+            {
+                "name": scenario.get("name", request.action),
+                "allowed": decision.allowed,
+                "action": request.action,
+                "tool_name": request.tool_name,
+                "writes_files": request.writes_files,
+                "exports_data": request.exports_data,
+                "trains_model": request.trains_model,
+                "human_approved": request.human_approved,
+                "reason_count": len(decision.reasons),
+                "obligation_count": len(decision.obligations),
+                "reasons": list(decision.reasons),
+                "obligations": list(decision.obligations),
+                "audit_hash": audit.request_hash,
+            },
+        )
+    return {
+        "ok": True,
+        "capsule_id": capsule.capsule_id,
+        "rows": rows,
+        "allowed_count": sum(1 for row in rows if row["allowed"]),
+        "blocked_count": sum(1 for row in rows if not row["allowed"]),
+    }
+
+
+def check_tool_request(
+    capsule_payload: dict[str, Any],
+    request_payload: dict[str, Any],
+    tool_payload: dict[str, Any],
+) -> dict[str, Any]:
+    merged = dict(request_payload)
+    merged.update(tool_payload)
+    capsule = DataCapsule.from_payload(capsule_payload)
+    request = SovereignRequest.from_payload(merged)
+    decision = SovereigntyPolicyEngine().evaluate(capsule, request)
+    audit = build_audit_record(capsule, request, decision)
+    return {
+        "ok": decision.allowed,
+        "tool_name": request.tool_name,
+        "action": request.action,
+        "decision": decision.to_dict(),
+        "audit_record": audit.to_dict(),
+        "operator_gate": build_operator_gate(decision.to_dict(), request.to_dict()),
+    }
+
+
+def build_operator_gate(decision: dict[str, Any], request: dict[str, Any]) -> dict[str, Any]:
+    destructive = bool(
+        request.get("writes_files")
+        or request.get("exports_data")
+        or request.get("trains_model")
+        or request.get("action") in {"execute_shell", "publish", "commit", "network_export"}
+    )
+    return {
+        "requires_human_review": destructive or not decision.get("allowed", False),
+        "requires_visible_diff": bool(request.get("writes_files")),
+        "requires_export_manifest": bool(request.get("exports_data")),
+        "requires_training_consent": bool(request.get("trains_model")),
+        "next_gate": _next_gate(decision, request),
+    }
+
+
+def build_turn_brief(plan: dict[str, Any]) -> dict[str, Any]:
+    route = plan.get("route_decision") or {}
+    selected = route.get("selected_model") or {}
+    grants = plan.get("tool_grants") or []
+    blocked_grants = [grant for grant in grants if not grant.get("allowed")]
+    return {
+        "allowed": bool(plan.get("allowed")),
+        "selected_model": selected.get("model_id"),
+        "runtime": selected.get("runtime"),
+        "tool_grants": len(grants),
+        "blocked_tool_grants": len(blocked_grants),
+        "obligation_count": len(plan.get("obligations") or []),
+        "blocked_reasons": plan.get("blocked_reasons") or [],
+        "operator_checklist": build_operator_checklist(plan),
+    }
+
+
+def build_operator_checklist(plan: dict[str, Any]) -> list[dict[str, Any]]:
+    allowed = bool(plan.get("allowed"))
+    obligations = set(plan.get("obligations") or [])
+    route = plan.get("route_decision") or {}
+    selected = route.get("selected_model")
+    return [
+        {
+            "item": "policy_decision",
+            "status": "pass" if allowed else "blocked",
+            "detail": "Data Capsule policy permits the request" if allowed else "Policy blocked the request",
+        },
+        {
+            "item": "model_route",
+            "status": "pass" if selected else "blocked",
+            "detail": selected.get("model_id") if isinstance(selected, dict) else "No eligible model",
+        },
+        {
+            "item": "audit_record",
+            "status": "required",
+            "detail": "Immutable audit record must be persisted before external effects",
+        },
+        {
+            "item": "visible_diff",
+            "status": "required" if "show_diff_before_write_or_commit" in obligations else "not_required",
+            "detail": "Show file diff before writes or commits",
+        },
+        {
+            "item": "resident_runtime",
+            "status": "required" if "route_only_to_resident_runtime" in obligations else "not_required",
+            "detail": "Route high-impact data only to approved resident runtime",
+        },
+    ]
+
+
+def build_opencode_workspace_config(
+    *,
+    base_url: str = "http://127.0.0.1:8787/v1",
+    provider_id: str = "abteex-marama",
+    model: str = "lumynax-infused-qwen3-coder-30b-a3b-gguf",
+) -> dict[str, Any]:
+    return {
+        "$schema": "https://opencode.ai/config.json",
+        "provider": {
+            provider_id: {
+                "name": "AbteeX SovereignCode via MaramaRoute",
+                "npm": "@ai-sdk/openai-compatible",
+                "options": {
+                    "baseURL": base_url,
+                    "apiKey": "${ABTEEX_MARAMA_API_KEY:-local-dev}",
+                },
+                "models": {
+                    model: {
+                        "name": model,
+                        "attachment": False,
+                        "reasoning": True,
+                    },
+                },
+            },
+        },
+        "model": f"{provider_id}/{model}",
+        "sovereigncode": {
+            "capsule_file": "products/abx-sovereigncode/examples/capsule.restricted-nz-code.json",
+            "audit_ledger": ".sovereigncode/audit.jsonl",
+            "require_human_review_for": ["write_files", "execute_shell", "network_export", "commit"],
+        },
+    }
+
+
+def build_capsule_summary(capsule_payload: dict[str, Any]) -> dict[str, Any]:
+    capsule = DataCapsule.from_payload(capsule_payload)
+    return {
+        "capsule_id": capsule.capsule_id,
+        "jurisdiction": capsule.jurisdiction,
+        "sensitivity": capsule.sensitivity,
+        "resident_regions": list(capsule.resident_regions),
+        "allowed_purposes": list(capsule.allowed_purposes),
+        "denied_purposes": list(capsule.denied_purposes),
+        "retention_days": capsule.retention_days,
+        "export_allowed": capsule.export_allowed,
+        "training_allowed": capsule.training_allowed,
+        "personal_detail_level": capsule.personal_detail_level,
+        "risk_flags": _capsule_risk_flags(capsule),
+    }
+
+
+def tool_scenarios() -> list[dict[str, Any]]:
+    return [dict(item) for item in TOOL_SCENARIOS]
+
+
+def _capsule_risk_flags(capsule: DataCapsule) -> list[str]:
+    flags = []
+    if capsule.sensitivity in {"personal", "restricted", "health", "iwi", "taonga"}:
+        flags.append("high_impact_sensitivity")
+    if not capsule.export_allowed:
+        flags.append("export_blocked")
+    if not capsule.training_allowed:
+        flags.append("training_blocked")
+    if capsule.retention_days <= 14:
+        flags.append("short_retention")
+    if capsule.personal_detail_level not in {"none", "anonymous"}:
+        flags.append("personal_detail_controls")
+    return flags
+
+
+def _next_gate(decision: dict[str, Any], request: dict[str, Any]) -> str:
+    if not decision.get("allowed", False):
+        return "revise_request_or_capsule"
+    if request.get("writes_files"):
+        return "show_diff_before_write"
+    if request.get("exports_data"):
+        return "attach_export_manifest"
+    if request.get("trains_model"):
+        return "attach_training_consent"
+    if request.get("action") in {"execute_shell", "commit"}:
+        return "human_approval"
+    return "execute_with_audit"

sovereigncode/ui.py

@@ -16,6 +16,14 @@ except ModuleNotFoundError:  # standalone HF package
 
 from .audit import build_audit_record
 from .planner import plan_coding_turn
+from .platform import (
+    build_capsule_summary,
+    build_opencode_workspace_config,
+    build_policy_matrix,
+    build_turn_brief,
+    check_tool_request,
+    tool_scenarios,
+)
 from .policy import DataCapsule, SovereignRequest, SovereigntyPolicyEngine
 
 PRODUCT_NAME = "AbteeX SovereignCode"
@@ -153,12 +161,20 @@ def build_dashboard_state(
         else _fallback_personal_request()
     )
     models = load_model_registry(registry_path)
+    capsule = load_json_mapping(capsule_path)
+    request = load_json_mapping(request_path)
+    route_request = load_json_mapping(route_request_path)
     return {
-        "capsule": load_json_mapping(capsule_path),
-        "request": load_json_mapping(request_path),
-        "route_request": load_json_mapping(route_request_path),
+        "capsule": capsule,
+        "request": request,
+        "route_request": route_request,
         "personal_capsule": personal_capsule,
         "personal_request": personal_request,
+        "capsule_summary": build_capsule_summary(capsule),
+        "personal_capsule_summary": build_capsule_summary(personal_capsule),
+        "policy_matrix": build_policy_matrix(capsule, request),
+        "tool_scenarios": tool_scenarios(),
+        "opencode_config": build_opencode_workspace_config(),
         "registry_path": str(registry_path),
         "model_count": len(models),
     }
@@ -181,7 +197,27 @@ def handle_api_request(
         return 200, {"ok": True, **state}
     if method == "POST" and path in {"/api/evaluate", "/api/plan"} and payload is not None:
         result = evaluate_dashboard_payload(payload, registry_path)
+        if "plan" in result:
+            result["turn_brief"] = build_turn_brief(result["plan"])
         return (200 if result["ok"] else 422), result
+    if method == "POST" and path == "/api/policy-matrix" and payload is not None:
+        capsule = _mapping(payload.get("capsule")) or state["capsule"]
+        request = _mapping(payload.get("request")) or state["request"]
+        return 200, build_policy_matrix(capsule, request)
+    if method == "POST" and path == "/api/tool-check" and payload is not None:
+        capsule = _mapping(payload.get("capsule")) or state["capsule"]
+        request = _mapping(payload.get("request")) or state["request"]
+        tool = _mapping(payload.get("tool"))
+        result = check_tool_request(capsule, request, tool)
+        return (200 if result["ok"] else 422), result
+    if method == "POST" and path == "/api/opencode-config" and payload is not None:
+        return 200, {
+            "ok": True,
+            "config": build_opencode_workspace_config(
+                base_url=str(payload.get("base_url") or "http://127.0.0.1:8787/v1"),
+                model=str(payload.get("model") or "lumynax-infused-qwen3-coder-30b-a3b-gguf"),
+            ),
+        }
     return 404, {"ok": False, "error": "not_found"}
 
 
@@ -213,11 +249,17 @@ def smoke_ui(
     if not result["ok"]:
         raise RuntimeError("SovereignCode UI smoke plan was blocked")
     selected = result["plan"]["route_decision"]["selected_model"]["model_id"]
+    matrix = build_policy_matrix(state["capsule"], state["request"])
+    tool = check_tool_request(state["capsule"], state["request"], tool_scenarios()[0])
+    if matrix["blocked_count"] < 1 or not tool["ok"]:
+        raise RuntimeError("SovereignCode expanded UI smoke checks failed")
     return {
         "ok": True,
         "product": PRODUCT_NAME,
         "model_count": state["model_count"],
         "selected_model": selected,
+        "matrix_rows": len(matrix["rows"]),
+        "tool_check": tool["ok"],
     }
 
 
@@ -257,7 +299,7 @@ def run_ui(
         resolved_route,
         resolved_registry,
     )
-    html = build_dashboard_html(state)
+    html = build_expanded_dashboard_html(state)
     return serve_dashboard(
         product_name=PRODUCT_NAME,
         html=html,
@@ -274,6 +316,335 @@ def run_ui(
     )
 
 
+def build_expanded_dashboard_html(state: dict[str, Any]) -> str:
+    initial = json.dumps(state, sort_keys=True).replace("</", "<\\/")
+    html = """<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>AbteeX SovereignCode Console</title>
+  <style>
+    :root {
+      --paper: #fffefa;
+      --ink: #0a0a0b;
+      --muted: #726b62;
+      --rule: #ded6c8;
+      --amber: #e08a2c;
+      --amber-dark: #9a5416;
+      --green: #275f45;
+      --red: #8f2e24;
+      --panel: #f7f1e7;
+      --chalk: #fff7e8;
+      --mono: "Cascadia Code", "SFMono-Regular", Menlo, Consolas, monospace;
+      --serif: Georgia, "Iowan Old Style", "Palatino Linotype", serif;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      background:
+        linear-gradient(90deg, rgba(10,10,11,.035) 1px, transparent 1px) 0 0 / 42px 42px,
+        linear-gradient(0deg, rgba(10,10,11,.025) 1px, transparent 1px) 0 0 / 42px 42px,
+        var(--paper);
+      color: var(--ink);
+      font-family: var(--serif);
+    }
+    header {
+      display: grid;
+      grid-template-columns: minmax(260px, 1fr) minmax(320px, 48vw);
+      gap: 24px;
+      align-items: end;
+      padding: 22px 28px 16px;
+      border-bottom: 1px solid var(--rule);
+      background: rgba(255,254,250,.92);
+    }
+    h1 {
+      margin: 0;
+      font-size: clamp(34px, 5vw, 68px);
+      line-height: .88;
+      letter-spacing: 0;
+    }
+    .subtitle, label, button, select, .metric, .k, th, td {
+      font-family: var(--mono);
+      font-size: 12px;
+      letter-spacing: 0;
+    }
+    .subtitle { margin-top: 10px; color: var(--muted); }
+    .metrics { display: grid; grid-template-columns: repeat(5, minmax(0, 1fr)); gap: 8px; }
+    .metric { border-left: 2px solid var(--amber); min-height: 60px; padding: 7px 8px; background: rgba(247,241,231,.72); }
+    .metric strong { display: block; font: 700 22px/1 var(--serif); color: var(--ink); overflow-wrap: anywhere; }
+    main { display: grid; grid-template-columns: minmax(360px, 480px) 1fr; min-height: calc(100vh - 118px); }
+    aside { border-right: 1px solid var(--rule); background: rgba(255,250,242,.95); padding: 18px; }
+    .content { padding: 18px; display: grid; gap: 12px; align-content: start; min-width: 0; }
+    .stack { display: grid; gap: 12px; }
+    .grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 12px; }
+    .split { display: grid; grid-template-columns: minmax(0, 1fr) minmax(0, 1fr); gap: 12px; }
+    .panel, textarea, pre, table, select { border: 1px solid var(--rule); border-radius: 6px; background: var(--paper); color: var(--ink); }
+    .panel { padding: 14px; min-width: 0; }
+    .panel h2 { margin: 0 0 10px; font-size: 18px; line-height: 1.1; }
+    textarea {
+      width: 100%;
+      min-height: 150px;
+      resize: vertical;
+      padding: 12px;
+      font: 12px/1.45 var(--mono);
+    }
+    #routeRequest { min-height: 118px; }
+    select { width: 100%; min-height: 34px; padding: 0 10px; }
+    button {
+      appearance: none;
+      border: 1px solid var(--ink);
+      background: var(--ink);
+      color: var(--paper);
+      border-radius: 4px;
+      min-height: 34px;
+      padding: 0 12px;
+      cursor: pointer;
+      white-space: nowrap;
+    }
+    button.secondary { background: transparent; color: var(--ink); border-color: var(--rule); }
+    .toolbar { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; }
+    .status { display: grid; grid-template-columns: repeat(5, minmax(0, 1fr)); gap: 10px; }
+    .status .panel { min-height: 92px; }
+    .k { color: var(--muted); display: block; line-height: 1.25; }
+    .v { display: block; margin-top: 8px; font-size: 18px; line-height: 1.12; overflow-wrap: anywhere; }
+    .ok { color: var(--green); }
+    .bad { color: var(--red); }
+    pre { margin: 0; padding: 14px; max-height: 520px; overflow: auto; font: 12px/1.45 var(--mono); }
+    table { width: 100%; border-collapse: collapse; overflow: hidden; }
+    th, td { padding: 9px 10px; text-align: left; border-bottom: 1px solid var(--rule); vertical-align: top; }
+    th { color: var(--muted); background: var(--panel); }
+    tr:last-child td { border-bottom: 0; }
+    .pill { display: inline-flex; border: 1px solid var(--rule); border-radius: 999px; min-height: 24px; align-items: center; padding: 0 9px; margin: 0 5px 5px 0; background: var(--chalk); font: 12px/1 var(--mono); }
+    @media (max-width: 1180px) {
+      header, main, .split { grid-template-columns: 1fr; }
+      aside { border-right: 0; border-bottom: 1px solid var(--rule); }
+      .metrics, .status { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+    }
+    @media (max-width: 680px) {
+      header, aside, .content { padding: 14px; }
+      .grid, .metrics, .status { grid-template-columns: 1fr; }
+    }
+  </style>
+</head>
+<body>
+  <header>
+    <div>
+      <h1>AbteeX<br />SovereignCode</h1>
+      <div class="subtitle">Policy decision point, route plan, tool gates, audit receipt.</div>
+    </div>
+    <div class="metrics">
+      <div class="metric"><strong id="metricModels">0</strong>models</div>
+      <div class="metric"><strong id="metricRegion">NZ</strong>region</div>
+      <div class="metric"><strong id="metricSensitivity">-</strong>sensitivity</div>
+      <div class="metric"><strong id="metricRetention">0</strong>retention</div>
+      <div class="metric"><strong id="metricBlocked">0</strong>blocked tools</div>
+    </div>
+  </header>
+  <main>
+    <aside class="stack">
+      <div class="toolbar">
+        <button id="planBtn">Plan Turn</button>
+        <button class="secondary" id="evaluateBtn">Evaluate</button>
+        <button class="secondary" id="matrixBtn">Matrix</button>
+        <button class="secondary" id="providerBtn">Provider</button>
+      </div>
+      <div class="toolbar">
+        <button class="secondary" id="restrictedBtn">Restricted</button>
+        <button class="secondary" id="personalBtn">Personal</button>
+      </div>
+      <div>
+        <label for="toolScenario">TOOL GATE</label>
+        <select id="toolScenario"></select>
+      </div>
+      <div>
+        <label for="capsule">DATA CAPSULE</label>
+        <textarea id="capsule" spellcheck="false"></textarea>
+      </div>
+      <div>
+        <label for="request">SOVEREIGN REQUEST</label>
+        <textarea id="request" spellcheck="false"></textarea>
+      </div>
+      <div>
+        <label for="routeRequest">ROUTE REQUEST</label>
+        <textarea id="routeRequest" spellcheck="false"></textarea>
+      </div>
+    </aside>
+    <section class="content">
+      <div class="status">
+        <div class="panel"><span class="k">DECISION</span><span class="v" id="decision">pending</span></div>
+        <div class="panel"><span class="k">MODEL</span><span class="v" id="selected">pending</span></div>
+        <div class="panel"><span class="k">GRANTS</span><span class="v" id="grants">0</span></div>
+        <div class="panel"><span class="k">OBLIGATIONS</span><span class="v" id="obligations">0</span></div>
+        <div class="panel"><span class="k">NEXT GATE</span><span class="v" id="nextGate">ready</span></div>
+      </div>
+      <div class="split">
+        <div class="panel">
+          <h2>Turn Result</h2>
+          <pre id="output"></pre>
+        </div>
+        <div class="panel">
+          <h2>Operator Checklist</h2>
+          <table>
+            <thead><tr><th>Gate</th><th>Status</th><th>Detail</th></tr></thead>
+            <tbody id="checkRows"></tbody>
+          </table>
+        </div>
+      </div>
+      <div class="split">
+        <div class="panel">
+          <h2>Policy Matrix</h2>
+          <table>
+            <thead><tr><th>Tool</th><th>Decision</th><th>Reasons</th></tr></thead>
+            <tbody id="matrixRows"></tbody>
+          </table>
+        </div>
+        <div class="panel">
+          <h2>Capsule Summary</h2>
+          <div id="capsuleSummary"></div>
+        </div>
+      </div>
+      <div class="panel">
+        <h2>Provider Config</h2>
+        <pre id="provider"></pre>
+      </div>
+    </section>
+  </main>
+  <script type="application/json" id="initial-state">__INITIAL__</script>
+  <script>
+    const state = JSON.parse(document.getElementById('initial-state').textContent);
+    const capsule = document.getElementById('capsule');
+    const request = document.getElementById('request');
+    const routeRequest = document.getElementById('routeRequest');
+    const output = document.getElementById('output');
+    const provider = document.getElementById('provider');
+    const decision = document.getElementById('decision');
+    const selected = document.getElementById('selected');
+    const grants = document.getElementById('grants');
+    const obligations = document.getElementById('obligations');
+    const nextGate = document.getElementById('nextGate');
+    const matrixRows = document.getElementById('matrixRows');
+    const checkRows = document.getElementById('checkRows');
+    const capsuleSummary = document.getElementById('capsuleSummary');
+    const toolScenario = document.getElementById('toolScenario');
+
+    function writeJson(node, value) { node.textContent = JSON.stringify(value, null, 2); }
+    function safeJson(text) {
+      try { return [JSON.parse(text), null]; }
+      catch (error) { return [null, error.message]; }
+    }
+    function setMetric(id, value) { document.getElementById(id).textContent = value; }
+    setMetric('metricModels', state.model_count);
+    setMetric('metricRegion', state.capsule_summary.jurisdiction);
+    setMetric('metricSensitivity', state.capsule_summary.sensitivity);
+    setMetric('metricRetention', state.capsule_summary.retention_days);
+    setMetric('metricBlocked', state.policy_matrix.blocked_count);
+    toolScenario.innerHTML = state.tool_scenarios.map((item, index) => `<option value="${index}">${item.name}</option>`).join('');
+
+    function loadRestricted() {
+      capsule.value = JSON.stringify(state.capsule, null, 2);
+      request.value = JSON.stringify(state.request, null, 2);
+      routeRequest.value = JSON.stringify(state.route_request, null, 2);
+      renderCapsuleSummary(state.capsule_summary);
+    }
+    function loadPersonal() {
+      capsule.value = JSON.stringify(state.personal_capsule, null, 2);
+      request.value = JSON.stringify(state.personal_request, null, 2);
+      routeRequest.value = JSON.stringify(state.route_request, null, 2);
+      renderCapsuleSummary(state.personal_capsule_summary);
+    }
+    function readPayload(includeRoute) {
+      const payload = {capsule: JSON.parse(capsule.value), request: JSON.parse(request.value)};
+      if (includeRoute) payload.route_request = JSON.parse(routeRequest.value);
+      return payload;
+    }
+    function renderMatrix(matrix) {
+      matrixRows.innerHTML = matrix.rows.map(row => `<tr><td>${row.name}<br><span class="k">${row.tool_name}</span></td><td class="${row.allowed ? 'ok' : 'bad'}">${row.allowed ? 'allow' : 'block'}</td><td>${row.reason_count}</td></tr>`).join('');
+      setMetric('metricBlocked', matrix.blocked_count);
+    }
+    function renderChecklist(rows) {
+      checkRows.innerHTML = rows.map(row => `<tr><td>${row.item}</td><td>${row.status}</td><td>${row.detail}</td></tr>`).join('');
+    }
+    function renderCapsuleSummary(summary) {
+      capsuleSummary.innerHTML = `
+        <div class="pill">${summary.capsule_id}</div>
+        <div class="pill">${summary.jurisdiction}</div>
+        <div class="pill">${summary.sensitivity}</div>
+        <div class="pill">${summary.retention_days} days</div>
+        ${(summary.risk_flags || []).map(item => `<div class="pill">${item}</div>`).join('')}
+      `;
+    }
+    function setResult(data) {
+      writeJson(output, data);
+      const plan = data.plan || {};
+      const brief = data.turn_brief || {};
+      const route = plan.route_decision || {};
+      const model = route.selected_model || {};
+      const allowed = data.ok === true;
+      decision.textContent = allowed ? 'allowed' : 'blocked';
+      decision.className = allowed ? 'v ok' : 'v bad';
+      selected.textContent = model.model_id || brief.selected_model || 'none';
+      selected.className = selected.textContent !== 'none' ? 'v ok' : 'v bad';
+      grants.textContent = plan.tool_grants ? plan.tool_grants.length : (brief.tool_grants || 0);
+      obligations.textContent = plan.obligations ? plan.obligations.length : (brief.obligation_count || 0);
+      if (brief.operator_checklist) renderChecklist(brief.operator_checklist);
+      nextGate.textContent = data.operator_gate ? data.operator_gate.next_gate : (allowed ? 'execute_with_audit' : 'revise_request');
+    }
+    async function postJson(path, payload) {
+      const response = await fetch(path, {
+        method: 'POST',
+        headers: {'Content-Type': 'application/json'},
+        body: JSON.stringify(payload)
+      });
+      return response.json();
+    }
+    async function submit(includeRoute) {
+      let payload;
+      try {
+        payload = readPayload(includeRoute);
+      } catch (error) {
+        setResult({ok: false, error: error.message});
+        return;
+      }
+      setResult(await postJson(includeRoute ? '/api/plan' : '/api/evaluate', payload));
+    }
+    async function matrix() {
+      const [cap, capErr] = safeJson(capsule.value);
+      const [req, reqErr] = safeJson(request.value);
+      if (capErr || reqErr) { setResult({ok: false, error: capErr || reqErr}); return; }
+      const data = await postJson('/api/policy-matrix', {capsule: cap, request: req});
+      renderMatrix(data);
+      writeJson(output, data);
+    }
+    async function toolCheck() {
+      const [cap, capErr] = safeJson(capsule.value);
+      const [req, reqErr] = safeJson(request.value);
+      if (capErr || reqErr) { setResult({ok: false, error: capErr || reqErr}); return; }
+      const tool = state.tool_scenarios[Number(toolScenario.value)];
+      setResult(await postJson('/api/tool-check', {capsule: cap, request: req, tool}));
+    }
+    async function providerConfig() {
+      const data = await postJson('/api/opencode-config', {base_url: 'http://127.0.0.1:8787/v1'});
+      writeJson(provider, data.config);
+      writeJson(output, data);
+    }
+    document.getElementById('planBtn').addEventListener('click', () => submit(true));
+    document.getElementById('evaluateBtn').addEventListener('click', () => submit(false));
+    document.getElementById('matrixBtn').addEventListener('click', matrix);
+    document.getElementById('providerBtn').addEventListener('click', providerConfig);
+    document.getElementById('restrictedBtn').addEventListener('click', loadRestricted);
+    document.getElementById('personalBtn').addEventListener('click', loadPersonal);
+    toolScenario.addEventListener('change', toolCheck);
+    loadRestricted();
+    renderMatrix(state.policy_matrix);
+    writeJson(provider, state.opencode_config);
+    writeJson(output, {status: 'ready', registry: state.registry_path});
+  </script>
+</body>
+</html>"""
+    return html.replace("__INITIAL__", initial)
+
+
 def build_dashboard_html(state: dict[str, Any]) -> str:
     initial = json.dumps(state, sort_keys=True).replace("</", "<\\/")
     return f"""<!doctype html>