Arxyne Solver

Return the KPI spec for a solver.

Return a product's latest KPIs, its targets, and the gate verdict. This is what the CLI prints with ``arxyne results``, as data. An agent reads it to answer "what is the drag now, and did it pass?" without guessing. The values and the verdict come from the same producers the CLI uses (``product.current``, ``product.targets``, ``run_gates``), so an agent and a person read one answer. Returns ``{"product", "kpis": [{"kpi", "name", "units", "value", "target", "benchmark"}], "gates": {"summary", "all_passed", "gates": [{"kpi", "status", "value", "target_min", "target_nominal", "target_max"}]}}``. ``value`` is null for a KPI with no saved result yet. Each gate ``status`` is the CLI's recorded verdict (PASS, FAIL, WARN, INCONCLUSIVE, NOT RUN, SKIPPED), never a value computed here.

Return the design-intent targets a run is gated against. ``get_kpi_spec`` says which KPIs exist and each one's direction. This says what each KPI must reach for one product. Read it before a run to explain a gate verdict, and after one so ``kpi_converged`` (which only says whether a KPI settled) is not mistaken for a target result. The targets are read with the same producer the gate evaluator uses, so what this returns is exactly what a run is judged against. Returns ``{"product", "targets": [{"kpi", "name", "units", "direction", "kind", "min", "nominal", "max", "value"}]}``. ``kind`` is ``"range"`` when the target carries min/max bounds, else ``"single"``. A ``"range"`` target gates by its bounds; a ``"single"`` target gates by its direction (minimize: value <= target). An empty ``targets`` list means none are set.

Return the declared inputs for a solver — the ``case_yaml`` contract. ``simulate`` takes ``case_yaml``, a flat ``key: value`` document. This tool returns the keys that document may hold, each with ``type``, ``default``, ``path``, ``min``/``max`` and ``description``. Inputs are declared per product, so pass ``product`` for that product's exact set; omit it for the union across the solver's products.

Apply a peer's exported twin state to this product's twin. MERGED, never replaces. THE import path (the twin/USDA channel). A host converges to hold what its peers hold: each peer's daemon EXPORTS its own twin, and the host APPLIES it here. The session RELAY carries live CLI calls and is a different channel - an import is not a relay and does not use one. One writer (this server) applies everything, so the CLI stays the only twin writer. ``bundle`` is ``{"layers": {name: usda_text}, "history": [raw_line, ...]}``: * each layer text is written under ``layers/imported/<name>.usda`` and added as a WEAKEST sublayer - OpenUSD composes strongest-first, so a value this host already holds wins and a value only the peer holds is gained. Nothing the host held is lost; the twin is only ADDED TO (import_layer_weaker). * each history line is appended, deduped by run pin / timestamp, so two peers running the same product + solver both survive as two runs (import_history_entries). Refuses when the product's twin does not exist: import requires a twin to import INTO (the same rule as a results write - the caller creates the twin first if the name is held).

List the products here: what a ``simulate`` can target, and what can yet be created. Returns ``{"products": [{"product", "description", "solvers", "held"}]}``. ``held`` is true when this machine already has the product's twin (so ``simulate`` can run it now); false when a solver image declares the product but it has not been scaffolded yet. ``solvers`` lists the aliases that can serve it.

List what can run here: every domain, its solvers, and what each can do. A caller that has never used the CLI starts here. Returns ``{"domains": [{"domain", "status", "kpis", "default_solver", "solvers": [...]}]}``. Each solver carries ``alias``, ``name``, ``kind``, ``gpu``, ``differentiable``, ``tier``, ``version``, ``image``, ``products`` and ``availability`` (``"available"`` everywhere the image is readable on this box, else ``"not present"``).

Register an external solver from a Docker image. 🚨 SINGLE REGISTRATION PATH. All solver registration routes through this MCP tool — CLI, onboarding, everything.

Save simulation results to the product's USD twin (prototype or benchmark layer). Args: save_target: "prototype" (default, results layer), "benchmark", or "design_intent" (targets only) parameters: ``{param_name: {value, default, path, override}}`` — overridden params get recorded in resultsHistory as ``override_<name>=<value>`` entries. only_missing_targets: with save_target="design_intent", skip KPIs that already have a target in that layer (idempotent population — existing targets are never overwritten). converged: False → the run's KPIs are not written to the prototype ``arxyne:current:*`` attrs (P1 — unconverged runs must not overwrite the last good result). The run is still fully traced in resultsHistory + the per-run record. tag_baseline: when True (and save_target="prototype"), append a baseline-promotion entry to the prototype layer. All USD writes happen here in the MCP server — the CLI never touches USD directly.

Dispatch a simulation for any domain. Single entry point. Args: case_yaml: the flat input contract, built by the platform. geometry: optional ``{input_key: {filename, content_b64}}`` — geometry supplied as BYTES rather than as a path, so the caller need not share a filesystem with the MCP server and the MCP server need not share one with the container. Staged under ``/case/geometry/`` and referenced from case.yaml by its in-case path.

Remove a user-added solver from the registry. Built-in solvers cannot be removed.