Maestro native requests through QRMI#
Maestro Local now supports a versioned native request through the existing
Payload.MaestroLocal layout. Set job_type="request" and put the complete
schema-2 document in input. Legacy execute/estimate payloads still work. Rebuild
Maestro, maestro-local-server, and QRMI together to use the new path. Older servers
produce an explicit unsupported-API error during capability negotiation.
The server uses only Rust/C/C++; Python is an optional client interface.
Maestro Local is available on Unix (Linux/macOS). On other platforms, its resource
type and payload remain defined, but resource creation returns
UnsupportedResourceType / Python UnsupportedResourceTypeError.
Python client#
import json
import time
from qrmi import QuantumResource, ResourceType, TaskStatus
from qrmi.maestro import request_payload
resource = QuantumResource("MAESTRO_LOCAL", ResourceType.MaestroLocal)
print(json.loads(resource.target().value))
token = resource.acquire()
try:
document = {
"schema_version": 2,
"operation": "estimate",
"circuit": {
"num_qubits": 1,
"source": "OPENQASM 2.0;\nqreg q[1]; h q[0];",
},
"simulator": {"backend": "qcsim", "method": "density_matrix"},
"observables": ["X", "Z"],
"execution": {"seed": 123},
"noise": {
"evaluation": "exact",
"channels": [{"kind": "t1", "targets": [0], "gamma": 0.36}],
},
}
task = resource.task_start(request_payload(document))
deadline = time.monotonic() + 60
while True:
status = resource.task_status(task)
if status in (TaskStatus.Completed, TaskStatus.Failed):
break
if time.monotonic() >= deadline:
resource.task_stop(task)
raise TimeoutError("Maestro task exceeded 60 seconds")
time.sleep(0.1)
if status == TaskStatus.Failed:
raise RuntimeError(resource.task_logs(task))
result = json.loads(resource.task_result(task).value)
print(result["expectation_values"]) # [0.8, 0.36]
print(resource.task_logs(task))
finally:
resource.release(token)
target().value contains the complete public/native capability document.
task_logs() returns serialized JSON containing captured stdout/stderr, the native
error, and a failure message. Results retain native execution metadata, seeds, noise
approximations, timing, and distribution details. Result retrieval still consumes the
result; logs remain available until session cleanup. The logs’ seeds array
retains each resolved execution seed and, when present, noise_seed after
result retrieval. Each entry’s result_path is empty for a single request or
contains successive result indices for nested batches. Replay the corresponding
original request with those values as execution.seed and noise.seed.
Seed history is limited to 256 entries and four batch levels;
seeds_truncated indicates omitted results. It lasts until session cleanup or
server restart. Seeded samples replay only on the same native library build;
newer servers record that build as native_build ({version,
source_revision}) in the same logs, or null for MPI tasks and tasks that
never returned a result. Updated servers also retain
logs after successful cancellation, including final output drained during worker
shutdown. Observe failed status before
requesting a result; QRMI raises TaskNotReady for failed tasks. If execution and
cleanup both fail, error.code is cleanup_unconfirmed, with
cleanup_confirmed:false and a bounded causes array retaining earlier error
codes/messages. Causes may be nested; inspect them recursively for the original native
failure. An active cancellation still fails if cleanup cannot be confirmed. Submission
errors retain typed QRMI categories: unsupported capabilities map to
UnsupportedFunction / Python UnsupportedFunctionError; invalid configuration and
missing/expired sessions map to InvalidConfig / Python ConfigError. A missing
session calls for acquiring a new session, not choosing a new backend. Malformed
launch/rank input maps to InvalidInputError; a broken profile file or
missing/nonexecutable launcher, worker or Slurm cancellation tool maps to
ConfigError. Selecting an unknown profile maps to UnsupportedFunctionError.
These categories follow QuantumResource::task_start’s contract: every error
except the generic one (Rust QrmiErrorKind::Other, Python QrmiError, C
QRMI_RETURN_CODE_ERROR) means that no task was created. Only a well-formed
API v2 refusal from the server establishes that. After the request has been
sent, a lost connection, a missing task_id, a reply without the OK
prefix or with another API version, or any other unrecognized reply is the
generic error, whose message says that the task may have been created. Do not
resubmit blindly in the same session after such an error: releasing the
acquisition token deletes the session and cancels any task it still runs.
Cancelling a task and deleting a session are acknowledged only after the server
has stopped the task’s worker; an MPI launcher gets 20 seconds to clean up its
remote ranks and 5 more before it is reaped. QRMI therefore waits up to 60
seconds for these two replies, and 15 seconds for others. Cancellation removes
the task. When a missing task’s retained diagnostics end with a cancelled
event, because another client cancelled it or a cancellation acknowledgement was
lost, task_status reports Cancelled and task_stop succeeds, so task
runners stop polling. Any other missing task remains TaskNotFound: a missing
task alone proves neither cancellation nor failure, and diagnostics disappear
with the session or a daemon restart. Socket exchanges, including these waits,
run off the asynchronous executor.
For native submissions, unsupported-API errors come only from capability
negotiation, before any submission is sent.
Updated servers add session_id, task_id, context and events to the
same diagnostic JSON. Each event has timestamp_unix_ms and state; submitted
tasks normally progress through queued, started and completed,
failed or cancelled. A failed cancellation records cancellation_failed.
Queued cancellation skips started; cancellation before submission records
only cancelled. These are server lifecycle transitions, not native progress.
The event array defines order even if the wall clock changes. History retains
the first and latest seven events, with events_truncated indicating omissions.
Context records requested backend/method and MPI profile/ranks when supplied;
legacy tasks expose simulator/method IDs. It excludes circuit contents and
arbitrary options. Effective native backend selection remains in result metadata.
Captured stdout/stderr retains its first and last 32 KiB. For longer output,
logs_truncated is true, logs_omitted_bytes counts omitted raw bytes, and
logs contains a visible truncation marker between the retained pieces.
The streams are merged in capture order and decoded with UTF-8 replacement for
invalid bytes. Diagnostics live in server memory and disappear on session
deletion, expiry or daemon restart. ok:true means retrieval succeeded, not
that the task completed successfully. QRMI forwards all these additive fields;
older API-v2 servers may omit them and retain their previous cancellation/capture
behavior. Rebuild the local server to obtain the improved diagnostics.
The server advertises server.session_lease_seconds (default 3600). Poll a running
task or retrieve its logs comfortably within that interval. Native submit and logs also
renew the lease. Explicit keepalive is available on the standalone bundled Rust
socket client, not through QRMI’s QuantumResource interface or Python/C/Lua resource
bindings. QRMI does not start a background heartbeat. Cached terminal status and session
existence checks do not renew it; logs can renew it after result consumption. A client
that stops all task traffic can lose its session, and expiry cancels active work.
Rust, C, and Lua#
The existing payload fields and C ABI layout are unchanged:
let payload = Payload::MaestroLocal {
input: serde_json::to_string(&document)?,
job_type: "request".into(),
qubits: 0,
simulator_type: 0,
simulation_method: 0,
observables: String::new(),
config: "{}".into(),
};
C and Lua use the same existing Maestro payload construction with job_type set to
request, input set to serialized JSON, and unused legacy fields set to the
values above. In C, NULL observables and config select "" and {}, so
a zero-initialized payload needs only input and job_type; NULL input or
job_type is refused with QRMI_RETURN_CODE_INVALID_INPUT_ERROR before any
request is sent. Lua raises an error for a legacy qubits, simulator_type or
simulation_method outside 0..4294967295 rather than truncating it; request
mode ignores these fields. Backend/method selection is inside the document and uses symbolic names,
avoiding build-dependent legacy enum numbers. There is no new payload enum or Slurm
plugin ABI requirement for this feature. Rebuild QRMI itself; existing consumers must
still match the repository’s existing QRMI ABI version.
The bundled Rust socket client exposes maestro_local_api::maestro::request::Client
with capabilities, submit, logs, status, and keepalive.
submit_value and logs_value accept and return parsed serde_json::Value
documents. Both the native client and the legacy Session / Task API are
synchronous. QRMI moves their blocking exchanges off its asynchronous executor;
applications using the socket client directly should do the same and can also call
keepalive(session_id). Successful schema negotiation is shared across client clones
and retained by the QRMI resource. Transport, malformed-response and
incompatible-version failures invalidate it; failed submissions are never automatically
retried. Explicit capability queries always fetch the current catalog. This is not
feature-by-feature preflight validation: Maestro and the server validate every submitted
request. The resource captures one socket path at construction for native requests and
all legacy session/task operations, including acquisition, status, results and cleanup.
QRMI_MAESTRO_SOCKET chooses that socket; the default remains /run/maestro.sock.
Construct a new resource after changing the variable to use a different daemon.
Task runners and examples#
Both Rust and Python task runners accept a raw schema-2 request, { "request": ... },
or the existing payload wrapper with job_type:"request". They also retain the legacy
execute/estimate form and accept a configuration object or serialized string. An omitted
or null legacy config becomes {} in both runners. Job types are
case-insensitive. A { "request": ... } wrapper must contain only that field. Bare
native documents reject legacy envelope fields, and every Maestro form rejects fields
belonging to another backend. The explicitly selected job_type:"request"
compatibility envelope accepts object or serialized JSON input and permits the known
legacy fields (qubits, simulator IDs, observables, config) outside it; those
outer fields are ignored. All native configuration belongs inside input. The two
runners and schema apply these same rules to each form. Legacy jobs require positive
qubits and nonnegative simulator_type and simulation_method, all within
uint32 range. These forms are covered by qrmi_payload_v1_schema.json. Missing
required Python helper fields raise descriptive ValueErrors before task
submission. For schema-2 requests, put execution.shots only on execute or
checkpoint_batch; estimators and other queries reject it. execution.seed remains
supported. To validate a sampling request, retain its operation and use the native
validation entry point rather than changing it to validate.
Legacy execute and estimate also accept config.seed as a nonnegative
JSON integer up to 2**64 - 1. Repeating the seed reproduces sampling on the
same backend/runtime, including when each task runs in a fresh worker.
Legacy QASM containing // is rejected with InvalidInputError before a task
is created: flattening its newlines would turn subsequent gates into a comment.
Use job_type="request" with a schema-2 document to preserve commented QASM.
Both task runners exit nonzero when a task fails or is cancelled, or when its result
cannot be retrieved or written. On failure they write the error and the
task_logs() diagnostics, including failure_message, to stderr before stopping
the task. A failed log query is reported without replacing the original failure.
The ready-to-run documents in Maestro task runner examples include:
native-noise.json: exact amplitude damping and observable estimation on CPU.native-query.json: a batch of state and mixed-state queries.native-thermal-idle.json: exact thermal relaxation, elapsed idle time and detuning.native-correlated-noise.json: seeded OU phase noise and MPS options.native-checkpoint.json: restore an ideal prefix and execute noisy suffixes.native-incremental.json: repeated exact amplitude-damping Kraus steps.native-distributed-gpu.json: local distribution across two physical GPU ordinals.native-mpi-gpu.json: MPI distribution through an administrator-defined profile.
The GPU documents require the named resources and installed plugins. Set the backend acquisition token as for existing runner tasks:
export QRMI_JOB_QPU_RESOURCES=MAESTRO_LOCAL
export QRMI_JOB_QPU_TYPES=maestro-local
export MAESTRO_LOCAL_QRMI_JOB_ACQUISITION_TOKEN=<existing-session-id>
task_runner MAESTRO_LOCAL examples/task_runner/maestro_local/native-noise.json
Supported computation and limits#
Native operations include execution, expectation estimation, selected/full amplitudes
and probabilities, state probability, unitary overlap/mirror fidelity, coherent noisy
fidelity, mixed-state diagnostics/partial trace/maintenance, incremental evolution,
checkpoint suffix batches, and independent request batches. All share the native
configuration and declarative noise model. Incremental exact noise uses explicit Kraus
instructions; checkpoint noise applies to suffixes after an ideal prefix. Checkpoint
randomness is reproducible for the complete ordered request: changing/reordering earlier
suffixes may change later samples. Fidelity queries use ideal inverse preparation;
coherent noisy fidelity is not a physical mirror experiment with noise on both halves.
Runtime support can be narrower for a particular method. Operation-specific fields on
other operations are rejected. Native request validation and numerical execution each
run in isolated Rust workers calling Maestro’s C ABI; capability catalog queries remain
in the daemon. An outer launch object is server routing metadata. The server
validates it and removes it before native validation/execution. Direct Maestro C ABI and
maestro-request calls reject launch; use the server for profile selection, or
launch maestro-mpi-worker yourself with a computational document.
The native API defaults to fixed backend selection and rejects unavailable selections.
Fixed selection preserves reuse across shots with the corrected Maestro library:
eligible circuits evolve once per execution job and sample repeatedly. QRMI forwards
the selection and shot count unchanged; no client-side switch to automatic selection
is needed. Deploy the updated libmaestro.so on the local server and all configured
native/MPI workers, then restart the server. Updating QRMI alone does not update that
native runtime. The fixed-selection integration checks can include ordinary GPU MPS
and statevector execution by setting QRMI_TEST_GPU=1. The noisy-shot checks
also cover density matrix and MPO: reuse stays within each noise realization,
with independent relaxation-reset outcomes and readout flips on each shot.
Automatic ideal execute/estimate can use explicit candidate lists. Exact quantum
channels require density-matrix/MPO methods; pure-state sampled noise follows Maestro’s
existing helper approximations. Distributed GPU engines currently support statevectors.
Noise results identify approximations; an MPO result is not automatically free of
truncation error.
For thermal relaxation with T1 < T2 <= 2*T1, sampled execution uses effective
T2 = T1, matching Maestro’s Python policy. This includes thermal noise after
one-qubit/two-qubit gates and during delays. The result lists
thermal_T2_clamped_to_T1 in noise.approximations, and task_logs() retains
a warning naming the affected qubits. Exact density-matrix/MPO execution keeps the
calibrated T2. This requires a Maestro library containing the native thermal-policy
update.
Native readout rates follow the measured qubit and apply when each measurement writes its classical bit, including conditional measurements. Classical control sees the noisy result; skipped measurements do not apply noise. Quantum-noise insertion follows the shared Python helpers’ behavior on unconditional gates and delays.
An explicit execution.seed or simulator.options.seed controls measurement
and readout randomness. Otherwise, an explicit noise.seed also seeds the
simulator; when neither is supplied, each request receives a fresh random uint64
seed, returned in its result’s seed field. Pass that value as execution.seed
to replay the request. Zero remains a valid explicit seed. MPI ranks share one
generated seed through their communicator. noise.seed drives
circuit-noise injection independently and defaults to the simulator seed’s lower
32 bits. These changes require an updated Maestro library.
Counts use classical bit 0 first. Pauli strings and target-state strings use qubit 0
first. Integer amplitude/probability indices use qubit 0 as the least significant bit.
Complex entries are [real, imaginary].
Requests are bounded to 16 MiB and serialized results to 64 MiB; that native bound
covers the whole result document, and the server’s max_result_bytes adds headroom
for MPI metadata. QRMI accepts a reply of that size plus its OK framing. Use selected
basis_states and max_output_elements for state queries. Batches have at most 256
members and four nested levels. No interactive state persists across tasks. Composer
orchestration, decoder/Sinter execution, general pure-state Kraus trajectories, new
distributed mixed-state engines, and artifact storage remain outside this change.
Authoritative native field/option/channel details are in Maestro’s docs/native-request-api.md; server framing, leases and MPI profile configuration are in maestro-local-server’s docs/native-api-v2.md.
Tests#
cargo test --locked --lib maestro::
cargo test --locked -p maestro-local-api --lib
cargo test --locked --features build-binary --bin task_runner
python -m pytest python/tests/unit/quantum_resource/test_maestro_request.py \
python/tests/unit/quantum_resource/test_maestro_local.py \
python/tests/unit/quantum_resource/test_maestro_runner.py
Use the rebuilt Python extension. Set QRMI_TEST_LIBRARY to a matching QRMI shared
library to enable C ABI checks. For end-to-end tests, set QRMI_TEST_MAESTRO_SERVER
to a freshly built native daemon, select its matching Maestro library with
LD_LIBRARY_PATH, and run test_maestro_native_integration.py in that directory.
Tests start a private socket and daemon. Set QRMI_TEST_MAESTRO_REQUEST to the
matching maestro-request executable to validate all native example documents. CPU
examples are also executed through QRMI and checked numerically; hardware examples
require separate execution resources. For CPU MPI tests, QRMI_TEST_MPI_PROFILE names
a configured two-rank profile; set MAESTRO_MPI_PROFILES to its profile file for that
daemon. Set QRMI_TEST_DISTRIBUTED_GPU=1 with a working licensed plugin/runtime to
include ideal and noisy local GPU distribution through QRMI. No system service is
restarted. Set QRMI_TEST_MPI_GPU_PROFILE to a profile with working rank-local GPU
binding, the MPI GPU plugin/license and CUDA-aware MPI to run ideal and noisy
distributed_mpi_gpu cases. Those tests assert the actual backend and rank count; the
CPU MPI test alone does not verify GPU distribution. Set
QRMI_REQUIRE_MAESTRO_NATIVE=1 to make a missing daemon or maestro-request
fail these tests instead of skipping them. The Maestro local server’s CI does this
on CPU: it builds the server against its pinned Maestro and runs this suite from a
pinned QRMI commit, which needs no stored credentials. The live legacy suite in
python/tests/integration/quantum_resource/test_maestro_live.py requires
QRMI_TEST_MAESTRO_LIVE=1 and skips backend cases absent from the capability catalog.
Current tensor requests and option migration#
Native schema version 2 identifies the document format, not a Maestro release.
After an upgrade, inspect json.loads(resource.target().value) again. The
native.options catalog lists current names, types, applicability and, on newer
builds, enum choices, bounds and supported_configurations. Conditional
exceptions override general bounds (MPO accepts zero for unlimited bond
size); constraints narrow choices for particular backends. Validation remains
authoritative, including cross-field rules and output limits.
The following native JSON options have changed:
Previous option |
Current option |
|---|---|
|
|
|
|
|
Corresponding |
|
|
|
|
|
|
For boolean sampling migration, true becomes probabilities and false becomes
apply_measure. The former sampling strings mps_probabilities and
mps_apply_measure lose their prefix. Select the SVD solver whose former flag
was true; omit the selector if all flags were false. Do not send both old and new
keys. QCSim computes in double precision; precision/SVD selections apply only to
backends advertised by the catalog.
Newer Maestro libraries add the following options. Their ranges come from the
catalog entries; per-backend limits appear as constraints:
Option(s) |
Applies to |
Values and constraints |
|---|---|---|
|
QCSim and GPU Pauli propagation |
QCSim 0–1024; GPU 1–64 (default 1). |
|
QCSim and GPU Pauli propagation |
Nonnegative; GPU default 8192, zero disables caching |
|
GPU Pauli propagation |
Positive budget, default 90% of free GPU memory; a limit, not a reservation |
|
GPU Pauli propagation |
1–256, default 64; one disables fusion |
|
QCSim MPS/MPO |
|
|
QCSim and GPU MPS/MPO |
Experimental virtual-bond routing |
|
All |
Booleans, default true |
|
All |
Positive; the minimum must not exceed the maximum |
|
All |
In (0, 1] |
|
All |
Booleans, default false |
|
QCSim statevector/density matrix (policy also path integral) |
|
An option for another backend or method raises UnsupportedFunctionError and an
out-of-range value raises InvalidInputError, before task allocation.
Validation accepts GPU options without a GPU; run a small request on each deployed
GPU backend, with QRMI_TEST_GPU=1 for the opt-in numerical checks. Combined and
virtual-bond routing trade runtime against truncation at finite bond caps. Sampling
reduction changes a seeded run’s random streams. Maestro 0.3.10 made
coherent_depolarizing isotropic, so its results differ from earlier libraries;
QASM accepts qelib1.inc’s rzz, rxx and u0.
QRMI does not translate these options. Removed keys fail native validation before
allocation of a task ID. Legacy SET_OPTIONS uses a separate contract; keys
accepted there are not necessarily valid under native simulator.options.
The examples/task_runner/maestro_local directory contains complete native
requests suitable for either task runner or request_payload:
native-mps-operators.jsonevaluates ordered, read-only MPS operators and exercises routing and maintenance. Repeated targets retain their order: X then Y on qubit zero of the zero state returns[0, -1]because YX = -iZ.native-mpo-operators.jsonapplies an operator to an MPO and compares raw and normalized complex expectations and dense matrices.normalize: falsekeeps the scale of A rho A-dagger; these operators change the state.native-tensor-expectations.jsonevaluates repeated, asymmetric Pauli observables in a single estimate request.native-tensor-batch.jsonpreserves repeated observable order over successive evolution steps. Native batching shares prepared-state work; QRMI should not split these observables into independent jobs.native-tensor-bulk.jsonreads amplitudes in logical basis order and returnsexecution_metadata.gate_fusionalongside the numerical results.native-mpo-wide.jsonqueries a 65-qubit product state using a bitstring. Wide measurement results also retain string keys rather than integer conversion.native-adjoint.jsoncomputes adjoint Jacobians for two parameter rows, with a Pauli string, a weighted Pauli sum and a probability readout.native-mirror-observables.jsonmeasures MPS truncation per observable withmirror_fidelity; loweringmax_bond_dimensionto 1 makes values drop below 1.native-instructions.jsonuses instruction-arrayrzz,noiselessbasis changes, apauli_channeland per-measurementreadout_error.native-mixed-state.jsonbatchesfidelity_with_statevectorof a noisy Bell state anddensity_matrix_overlapof two MPO preparations.
Adjoint differentiation, observable mirror fidelity and these instruction fields
need a Maestro library listing them in native.operations, native.adjoint
and native.instructions; older libraries reject them before task allocation.
They use the existing request payload unchanged:
adjoint_expectation_values,adjoint_jacobianandadjoint_vjpdifferentiate a unitary circuit on the QCSim CPU statevector.observablesentries are Pauli strings,{"terms": [[coefficient, pauli], ...]}or{"probabilities": [qubits]};parameter_rowsreplaces the circuit’s angles row by row, andadjoint_vjptakescotangents[row][value]. Results reportnum_parameters,num_valuesandcircuit_parameters(the circuit’s own angles in parameter order) withexpectation_values,jacobian[row][value][parameter]orvjp[row][parameter]. They carry no seed.mirror_fidelitywithobservablesreturns their expectations on the executed mirror state instead offidelity. Unlike plain mirror fidelity, it also runs ondensity_matrixandmatrix_product_operator.Instruction arrays accept
rxx/rzz,"noiseless": trueon gates,readout_erroronmeasure(a probability or{p_meas1_prep0, p_meas0_prep1}; counts only, so operations that remove terminal measurements, including the adjoint operations, nestedother_circuit/step_circuitand thecheckpoint_batchprefix, refuse it withUnsupportedFunctionError; checkpoint suffix measurements apply it), andpauli_channelwith4**len(qubits)probabilities. Mixed-state methods apply the channel exactly; pure-state methods sample it per noise realization and need a trajectorynoiseblock, whosechannelsmay be omitted.density_matrix_overlapreturnsoverlap, the complexTr(rho sigma)ofcircuitandother_circuitprepared separately, andfidelity_with_statevectorreturnsfidelity,<psi|rho|psi> / Tr(rho)fortarget_statevector:2**num_qubits[real, imaginary]amplitudes in basis-integer order, normalized to within1e-6, for at most 20 qubits. They are the mixed-state counterparts ofinner_productandnoisy_fidelityand run only with fixedqcsimorgpuselection ondensity_matrixormatrix_product_operator; other methods refuse them withUnsupportedFunctionError. Circuits may contain resets and channels; anoisemodel must use exact evaluation with one realization. The catalog lists them innative.mixed_state_queries.
Pauli strings put qubit zero first; Qiskit Pauli labels require reversal when
constructing these native observables. Basis integers put qubit zero in the least
significant bit. Test asymmetric states/observables when converting conventions.
Complex results use [real, imaginary]. Full vectors and matrices still grow
exponentially: bounded GPU staging memory does not remove native output limits
or the 64 MiB native result bound.
Resource status and deployment discovery#
resource.status() uses the additive server API v2 status command on a
blocking executor. It creates no session and does not renew any session lease.
It reports Online when the runner is live, its state is usable and shutdown has
not begun; otherwise it reports Offline with a reason. healthy describes the
runner, busy means active or queued execution, and pending_job_count counts
waiting jobs, excluding the active job. These snapshots can change immediately.
Capacity remains unspecified: an execution worker is not an exclusive acquisition
slot. Runner health does not certify GPU availability, licensing or plugin
compatibility. The server must support the API v2 status command. Older servers
without it produce UnsupportedFunction / Python UnsupportedFunctionError;
upgrade the server to query resource status. Transport errors, malformed replies
and other server failures remain errors.
New catalogs include server.build and native.build with version and source
revision, plus native.diagnostics with supported backend/method pairs.
native.capability_scope: "validation" distinguishes parser support from
runtime readiness. Missing optional GPU exports can still make a validated job
fail. Older catalogs may omit these additive fields.
Rebuild and deploy compatible Maestro, GPU plugin and server artifacts together,
then restart the service to load them. Install both Maestro’s Interface.h and
InterfaceTypes.h. Build identifiers describe the build inputs (the native
revision is captured at CMake configuration); source archives may report
unknown, and modified tracked sources carry a -dirty suffix. They are
informational, not a feature-negotiation mechanism. QRMI forwards catalog and
result additions without a new payload type or C ABI change.