Transaction-Science/open-standards
Watch
1
0
Fork
You've already forked open-standards
 0
Code Issues Pull requests Projects Releases 15 Packages Wiki Activity Actions 10

wai-quantum 0.7.0, the rest: a durable job service, error correction and mitigation, views in agent hosts, and the docs and course #523

Closed
dcharlot wants to merge 38 commits from wai/quantum-wave5 into main
pull from: wai/quantum-wave5
merge into: Transaction-Science:main
Conversation 0 Commits 38 Files changed 413 +87981 -12801
dcharlot commented 2026-10-28 05:35:10 -04:00
Owner
Copy link

The rest of wai-quantum 0.7.0, so the release ships complete. #521 (merged) carried the stack through the version contract; this adds the four remaining parts, each held to the contract: an output schema on every new tool, a JSON Schema for every new document, basis for the gate set, and results stamped with their engine and schema.

  • A durable job service (0.2.0):
    • a content-addressed store that survives restarts; a job that was running comes back interrupted;
    • sets of programs and sweeps over inputs, each item sealed and one receipt over their Merkle root;
    • dry runs;
    • status as server-sent events, and RateLimit headers;
    • rotating receipt keys at /.well-known/wai-quantum-receipt-keys;
    • package-energy counters on Linux, read live and labelled;
    • provenance mapped to the survey categories, compilation included;
    • an OCI image, a self-host guide, and a scheduler interface (wai-quantum task).
  • Error correction and mitigation:
    • colour codes decoded by restriction to matching, correcting every error below half the distance;
    • correlated matching, and a sliding-window decoder with its buffer requirement stated;
    • distance certificates;
    • the error-correction circuit and model text round-tripped;
    • mitigation in jobs (ZNE, PEA/PEC, CDR, virtual distillation, readout), each with its stated assumptions and error bar;
    • Pauli twirling and dynamical decoupling as checked compile passes;
    • qec_* tools on both servers, a Studio pane, the CLI and Python.
  • Views in agent hosts:
    • six ui:// views on both servers (the circuit, a result with its verdict, a receipt checked in the view, a critique, an estimate frontier, a device map), from the Studio's components;
    • opt-in local correctness records, whose failures export as an eval corpus;
    • wai-quantum eval run for local models, which ranks nothing;
    • the answer view layer as a draft extension, with its measured cost and a local model's results in its spec; it is not the path agents are told to use.
  • Docs and a course:
    • every runnable block in 70 pages is run in CI and held to its output;
    • a 21-lesson circuits course (wai-quantum learn, and the Studio's Course pane), each exercise checked by the engine's verdict;
    • the CLI's words, the Studio's interface, the course and the main READMEs in Simplified Chinese, marked machine-assisted for review.

Pins: wai-web quantum_engine:: 26 native and 18 wasm32; wai-quantum-qpu 34 / 8 / 12. The refusal codes are renumbered so none collide: J007 sets, J008 mitigation, J009 QEC, J033 an API key, J100–J112 the answer layer. All of it sits under the 0.7.0 changelog heading.

Tests:

  • Every job of every touched workflow, replayed on the Linux and macOS build hosts:
    • repository checks, the editors job, the CLI (with WASI byte equality), the contract's API, schema and policy steps;
    • QEC, the service, energy, the verdict (native and wasip2), views, qpu clients, Python, estimates, the reader (native and wasip2), docs, course and locales;
    • the engine's full suite (1,098), wai-rs receipts, the conformance corpora;
    • the Studio twice, the desktop app, view hosts, the keychain, and the editors on macOS.
  • After rebasing onto main: engine lib 1,061; CLI 69 + 15 and smoke; service 38; wai-web 26; the editors job and the repository checks.

🤖 Generated with Claude Code

Closed: Replaced by #524: the same work rebased onto main after #522

The rest of wai-quantum 0.7.0, so the release ships complete. #521 (merged) carried the stack through the version contract; this adds the four remaining parts, each held to the contract: an output schema on every new tool, a JSON Schema for every new document, `basis` for the gate set, and results stamped with their engine and schema. - **A durable job service (0.2.0):** - a content-addressed store that survives restarts; a job that was running comes back `interrupted`; - sets of programs and sweeps over inputs, each item sealed and one receipt over their Merkle root; - dry runs; - status as server-sent events, and RateLimit headers; - rotating receipt keys at `/.well-known/wai-quantum-receipt-keys`; - package-energy counters on Linux, read live and labelled; - provenance mapped to the survey categories, compilation included; - an OCI image, a self-host guide, and a scheduler interface (`wai-quantum task`). - **Error correction and mitigation:** - colour codes decoded by restriction to matching, correcting every error below half the distance; - correlated matching, and a sliding-window decoder with its buffer requirement stated; - distance certificates; - the error-correction circuit and model text round-tripped; - mitigation in jobs (ZNE, PEA/PEC, CDR, virtual distillation, readout), each with its stated assumptions and error bar; - Pauli twirling and dynamical decoupling as checked compile passes; - `qec_*` tools on both servers, a Studio pane, the CLI and Python. - **Views in agent hosts:** - six `ui://` views on both servers (the circuit, a result with its verdict, a receipt checked in the view, a critique, an estimate frontier, a device map), from the Studio's components; - opt-in local correctness records, whose failures export as an eval corpus; - `wai-quantum eval run` for local models, which ranks nothing; - the answer view layer as a **draft** extension, with its measured cost and a local model's results in its spec; it is not the path agents are told to use. - **Docs and a course:** - every runnable block in 70 pages is run in CI and held to its output; - a 21-lesson circuits course (`wai-quantum learn`, and the Studio's Course pane), each exercise checked by the engine's verdict; - the CLI's words, the Studio's interface, the course and the main READMEs in Simplified Chinese, marked machine-assisted for review. Pins: wai-web `quantum_engine::` 26 native and 18 wasm32; wai-quantum-qpu 34 / 8 / 12. The refusal codes are renumbered so none collide: J007 sets, J008 mitigation, J009 QEC, J033 an API key, J100–J112 the answer layer. All of it sits under the 0.7.0 changelog heading. Tests: - Every job of every touched workflow, replayed on the Linux and macOS build hosts: - repository checks, the editors job, the CLI (with WASI byte equality), the contract's API, schema and policy steps; - QEC, the service, energy, the verdict (native and wasip2), views, qpu clients, Python, estimates, the reader (native and wasip2), docs, course and locales; - the engine's full suite (1,098), wai-rs receipts, the conformance corpora; - the Studio twice, the desktop app, view hosts, the keychain, and the editors on macOS. - After rebasing onto main: engine lib 1,061; CLI 69 + 15 and smoke; service 38; wai-web 26; the editors job and the repository checks. 🤖 Generated with [Claude Code](https://claude.com/claude-code) --- **Closed:** Replaced by #524: the same work rebased onto main after #522 
engine::energy reads the power-capping interface's package zones: every
package or none, each wrap corrected, opened only when the count is live
(each package advancing in 80% of fifteen 20 ms intervals). A figure from
them is the packages' energy over the job's window with no attribution to
the job, the jobs beside it named, and its uncertainty covers the two
whole-microjoule reads and the update edges measured here. A counter that
does not read says why (no interface, or no privilege), never zero.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
engine::sets expands a request with a list of programs, or one program over
a grid of its integer and real-valued inputs, into plain jobs; plans,
runs and seals them, each item with its own receipt and the set's receipt
over a head that holds the root of every item's leaf under the crate's
Merkle domains, with each item's path. The reader binds float and angle
inputs (qasm::bind); the one-job reader refuses a set (J007); J033 is the
code for a host that takes only its API keys; the planner states nominal
rates for time estimates.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Programs, requests, results and receipts are kept content-addressed by
BLAKE3 digest in a store behind a trait (files written whole, fsynced and
renamed, under a lock; or memory), each job's record written at every change
of status before it is answered. On start the service reloads them: finished
jobs as they were, their receipts verifying; a running one interrupted with
the reason; queued ones queued again. Retention stays configurable, a day by
default. A client is kept as a keyed hash, never its address.

A set or sweep runs as one job with a result and receipt per item and one
receipt over their Merkle root. dry_run returns the plan, estimated time and
energy with their basis, the bounds and whether it would be taken. Status
comes as server-sent events or a held poll; every answer carries the
RateLimit-Policy and RateLimit fields. The receipt key set is published at
/.well-known/wai-quantum-receipt-keys, and rotate-key retires a key with a
transition both keys sign. Optional API keys, off by default, for private
deployments. On Linux each job is metered from the processor packages'
counters where they read. A test kills the service mid-job and restarts it.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
CI's instances keep their job store in the runner's scratch directory.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
engine::run::run_with_provenance adds provenance beside a result: the
circuit (the program's BLAKE3 digest, qubits, gates), the computer (method,
accuracy class, a device target's hash), the compilation (each pass the
compile ran with its check's verdict, the certificate's digest, the gate
set, the budget and the distance), the execution (shots, seed, plan) and the
software (engine and host). run is unchanged, so every pinned result gives
the bytes it gave. The service's worker seals it into each new result and
each set item.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
submit takes --program (more programs, one set) and --sweep NAME=V1,V2
(every combination of an input's values), as run and plan do here; --dry-run
asks the service for its plan and whether it would take the job, running
nothing (and is never sent to a service older than dry runs); and a job's
status is followed to its end from the service's event stream, or by held
polls. task is the service as a resource a batch scheduler hands its jobs:
target, acquire and release a lease, start, status, wait, result (its
receipt checked first) and stop. verify checks a set whole. The agent docs
list the service's new tools.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
deploy/Containerfile builds the service in two stages, each base pinned by
digest, from the locked dependencies with paths remapped and the timestamp
fixed, and runs it as an unprivileged user with its store and keys on one
volume; deploy/check-image.sh builds it, runs it, holds it to the smoke
checks, restarts it to see it keep its jobs, and removes everything, pushing
nothing. docs/self-host.md covers running it, its configuration, the store,
the receipt keys and their rotation, API keys, energy and a reverse proxy;
docs/provenance.md maps every field to the categories provenance surveys
use; docs/scheduler.md describes the task interface by function. CI runs the
engine's set, provenance and package-energy tests by name, and on the
hardware runner the live package counter and a fully metered smoke. The
READMEs and the changelog say what changed.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
The smoke's set, sweep and dry-run checks now make four submissions, so the
whole script stays within 30 in a window on a host that also checks its GPU.
A dry run's energy estimate that rounds to no microjoule says so instead of
giving zero.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Co-Authored-By: Claude Opus 5.5 <[email protected]>
The durable service's documents join the version contract. A set's result
(wai.quantum.set/1) and a result's provenance (wai.quantum.provenance/1) are
engine schemas; the service's receipt key set (wai.quantum.receipt-keys/1,
with its signed transitions) and the command line's scheduler lease
(wai.quantum.lease/1) are their hosts'. The job request names programs, sweep
and dry_run, a job's result may be a set's, an energy figure may be the
processor packages', and a job names its store digests.

A set's head now names the engine and its schema, inside what its receipt
seals, as every other result does. A result's provenance names the gate set
its compile wrote as basis (it read the compile summary's old target field,
which the rename left empty).

run_quantum_set and dry_run_quantum_job answer to output schemas, each with
its verdict whether refused or not, and run_quantum_circuit asked as a dry
run answers as one. The strict tests call both and hold every answer, the
job's set form and the key set after a rotation to their schemas; the
contract workflow requires the new tests by name, and check_schemas.py reads
the new files and holds a set's run to its schema.

The service's store stays at ~/.local/share/wai-quantum-service/store by
default; the Python check and its tests start the service with a store in
their own scratch, as the service workflow's legs already do.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
The 6.6.6 colour code of odd distance d, built on a triangular lattice with
its three boundaries; its faces matched on the three restricted lattices and
lifted at each colour, both logical classes kept, the lightest taken, and
completed below half the distance by an exact search: every error of weight
up to (d-1)/2 is corrected for d = 3, 5, 7 (and 9 in a release build), and
matching alone is measured beside it. Distance certificates for any CSS code:
connected supports grown check by check, symmetries checked before use, a
witness of the distance and the bound below it, re-checkable to the node.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
A reader and writer for the circuit text and the detector error model text
that keep every instruction's tag, its arguments as written and every kind of
target (records, Pauli targets, inverted results, sweep bits, products),
blocks as blocks. The frame simulator now reads through it: tags reach the
mechanisms their noise makes, observables take Pauli targets in sampling and
in the model, detectors keep their coordinates. A model is written with its
coordinates, tags and each decomposed mechanism's parts, and read back to the
same model, blocks unrolled and detector shifts applied. A conformance set of
circuits and models the crate writes and of hand-written ones, each held to
its counts, its model and a byte-for-byte round trip, with the refusals.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Exact matching now gives the edges its paths take. Correlated matching
matches once, lowers the other parts of every decomposed fault the first
matching used, matches again, and keeps the second answer only when the
model's own mechanisms cover it more cheaply. Ground truth for both, with
every edge at one probability: the graph's distance found by search is d, and
every set of edges below half of it is corrected (every pair at d = 5). Fault
sets are counted as well: of the 95,703 sets of one or two faults at d = 5,
exact matching misses 103 pairs and correlated matching 73; on 20,000 shots
at p = 0.006, 469 against 431 failures at d = 3 and 440 against 338 at d = 5.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
A stream pushed one round at a time: windows of commit plus buffer rounds,
each matched exactly on the mechanisms that touch no committed round (cut at
the window's top), the edges that start in the commit region applied and the
rest decided again by the next window. Each window's graph is built once. The
buffer must cover the longest mechanism; a stream states its time per round,
and measure times every window on this machine against it, the prediction the
same bits everywhere. A window over everything is the batch decoder, shot for
shot; with a buffer of (d+1)/2 rounds every edge set below half the distance
is corrected (each pair at d = 5), while a one-round buffer misses 286 of
166,176; on the same shots, 65 failures against the batch's 64.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
A job's "mitigate" runs its program under its own noise, Pauli-twirled, each
circuit's density matrix exact and then sampled with its shots. zne folds the
whole program (checked equal without noise) and extrapolates; pea learns each
gate's noise as a sparse Pauli-Lindblad model by simulated cycle benchmarking
and amplifies the learned rates; pec inverts the learned channels as
quasi-probabilities and samples them, beside the value it converges to; cdr
fits near-Clifford training circuits; vd takes two copies; readout inverts
the counts' flips. Each result names its method, gives raw and mitigated
values with standard errors, states its bias and variance assumptions and
counts its circuits and shots, sealed with the job. The density matrix runs
a list of gates and Kraus channels, negative weights allowed. Refusals carry
J007; J008 is reserved for error-correction requests.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
"twirl" frames each two-qubit Clifford gate with a seeded Pauli and its image
through the gate; "dd" places an xx or xy4 sequence in each window where a
qubit idles long enough. Each is checked to be the program without noise by
the equivalence ladder, on every distinct framed gate or sequence (a tableau
each) and on the whole circuit where the ladder decides, and every frame
through cx, cz and swap is held to dense matrices.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
engine::qec reads a code by name (surface, toric, steane, color, the
bivariate-bicycle presets and gross) with a layout to draw it, its distance
certified (and a given certificate checked: its witnesses and the search run
again); decodes at code capacity with each decoder the code admits (union-find,
exact matching, Relay-BP, the colour decoder, an exact search) and at circuit
level from the memory experiment, a circuit or a model, by exact, correlated or
union-find matching, BP-OSD or a sliding window; and measures failure rates
over distances and rates, with the code model fitted at circuit level. Each
answer is sealed by the host as a job is. Refusals carry J008. Relay-BP is
now callable on a syndrome given.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
wai-quantum qec code, decode and threshold beside lab (lab qec unchanged),
each answer signed with the user's key; run --mitigate; compile --twirl and
--dd. Both MCP servers serve qec_code, qec_decode and qec_threshold in one
wording from the engine, and a job's mitigate and a compile's twirl and dd in
their schemas. The service answers POST /v1/qec/code, /decode and /threshold
sealed with its key, within bounds that send a long certification or a large
threshold to the command line (J031), and lists them in its OpenAPI document.
The agent docs regenerated; both smoke scripts check the new calls.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
The Studio's Error correction pane, closed until opened: a code drawn on its
lattice (a colour code's faces in their colours), qubits flipped by clicking,
their syndrome lit, the decoder's correction marked and the residual judged,
the certificate's distance and its witness, and logical failure rates plotted
one line per distance; every answer sealed and its seal checked in the page.
A run can be mitigated under its noise, the result showing raw and mitigated
values with their errors and the method's assumptions. The page engine's qec
call (wasm32) and the desktop app's command seal with the page's or the user's
key; the service engine posts to /v1/qec. Engine-in-a-page test pins: 23
native, 16 wasm32.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
qec_code, qec_decode and qec_threshold call the engine's error correction
in-process, each answer sealed in a job's form, and run() takes mitigate=.
The tests decode every error of weight up to two on the distance-5 colour
code to a trivial residual, check a certificate and a forged one, and hold
each answer to the command line's.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
docs/qec.md gives each code, the distance certificate and what it settles,
each decoder's guarantee, the window's latency budget, the circuit and model
texts, and each mitigation method's bias and variance; the compiler page adds
the twirl and decoupling passes. The crate's README points its research
commands at `lab qec`, which the new `qec` verbs sit beside.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
wai-quantum-qec.yml runs the codes, decoders, texts, mitigation and the
error-correction call in release on linux, requires each new test by name,
holds the texts to their conformance vectors, and checks every feature set
the hosts build without warnings; the catalog no longer warns when built
without mitigation.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Error correction and mitigation join the version contract. An error-correction
answer (wai.quantum.qec/1: a code, a decode or a threshold), a code's distance
certificate (wai.quantum.distance/1) and a job's mitigation
(wai.quantum.mitigation/1) are engine schemas; every answer engine::qec::call
gives names the engine and its schema, inside what a host seals. The job
request names mitigate, and a compile's options and certificate twirl and dd.
qec_code, qec_decode and qec_threshold answer to output schemas on both
servers; the strict tests call each, a mitigated run and a compile with both
passes, the engine's test holds every decoder's answer and each mitigation
method to its schema, the contract workflow requires it by name, and
check_schemas.py holds the command line's answers too.

Refusal codes: the set branch and this one had each taken J007. A set that
does not read keeps J007; mitigation's refusals are J008 and error
correction's J009, in the table, its page, the tests, the docs and the
changelog.

The basis rename reaches the new passes: compile::Options carries twirl and
dd beside basis, and the command line's compile, both servers' compile
options and their tests name the gate set basis.

The service smoke test made 32 submissions with both branches' checks, past
the 30 a client may make in a window (it is also run against production after
a deploy). It now makes 28 (29 on a host with a GPU, whose single-precision
run is held to the exact values instead of a second run): the code-capacity
decode against its error, the changed estimate, the counts document and the
classical shortcuts are left to the MCP servers' tests, which hold each.

The agent docs are regenerated.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Both MCP servers serve six ui:// views (a circuit, a result with its
verdict, a receipt, a critique, an estimate's frontier, a device target's
map) through the protocol's extension for interactive views, version
2026-01-26, to a host that says it draws them: each tool names its view in
_meta.ui.resourceUri, the view's data (the engine's layout and the circuit
in words, a target's map) rides in the result's _meta, and the service's
poll_quantum_job, which a view calls while a job runs, is kept from the
model. The service keeps no session, so the client's word travels in the
session id it is given at initialize. Every host gets each such answer in
plain words.

The views are one self-contained page (736 KB, held under 1 MiB) built from
the Studio's components, carrying the engine (wai-quantum-views) as
WebAssembly and translated to JavaScript. Under the extension's default
content-security policy the browser refuses WebAssembly, so the JavaScript
form checks the receipt there; a scripted host in a headless browser draws
every view from both servers under both policies and holds the check, a
changed result, the size and no outside request. The page rebuilds to the
same bytes in the CI image.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
engine::answer reads wai.quantum.answer/1: view statements over an
OpenQASM 3 program (Histogram, Verdict, Equivalence, Bloch, Estimate,
Receipt and the rest, fourteen in all), each view's numbers bound to an
engine call written with @ (@Sample, @Check, @Seal, eleven in all), so a
model's answer shows numbers the engine computed. One statement a line,
the program in a named qasm fence, root first, forward references, and a
later declaration standing as the edit. The reader streams: a snapshot
says what is ready, pending or dropped, and the finished answer is the
whole text's at every split (tested at every split point). Every problem
has a stable code: a program's keep the reader's Q codes, a statement's
are the new J100 to J112, each dropped, defaulted or warned, and only the
dropped ones are errors a model is sent back. eval carries the calls out
on the engine (a run's time left out), seals what @Seal names in a job's
form, and checks a stored answer's receipt marker by running it again.

The conformance set (quantum-conformance/answers/, 20 cases, every code)
passes natively, under wasm32-wasip2 and in the browser, where the stored
case written natively verifies to the same bytes. wai-web gains
AnswerStream and the answer and telemetry calls (pins 24 native, 16 wasm32).

engine::telemetry defines the correctness record (codes, verdict level,
repairs, the person's accept or reject, the receipt) and turns the failures
among records into an eval corpus in the conformance format.

The specification (extensions/quantum-answers.md) is a draft whose token
comparison is still to come.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
The equivalence ladder, the prepares intent and the rewrite proofs
compared the programs' measurements as an ordered list, so a program that
measured q[3] into c[3] down to q[0] into c[0] was "different by shape"
from one that wrote c = measure q: a verdict of fails, by proof, for a
program that prepares the state asked for. A local model's answer in the
model harness found it. Measurements at the end act on separate qubits, so
what matters is which qubit each bit holds once the program has run
(qasm::readout, a bit written twice holding the last); the checks compare
that. A test holds a reversed order equal and crossed bits different.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
The Studio has an answer pane. It reads an answer in the view layer as it
streams from the assistant, draws each statement when it arrives, runs the
engine call each one is bound to, and seals the answer with a receipt that
is checked again by re-running. A stored answer carries its receipt and is
verified when it is read back.

The correctness record is off by default. When it is turned on, it keeps
one record per answer in the browser: the codes, the verdict level, the
repairs, whether the answer was accepted, and the receipt id. Nothing is
sent anywhere, and the records leave only when exported. The failures
export as an eval corpus in the conformance format. A test shows that
nothing is recorded while it is off.

The engine adds a noise argument to @Sample and @Check, keeps root-listed
names that have not arrived in the snapshot order, and gives a model the
layer's rules with a worked example. The desktop app answers the same
calls. macOS can read a running process's energy, for the model harness.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
The first measurement of a local model writing the answer view layer found
most of its errors in three places: a view given an engine call where it
takes a program, a name the root lists that nothing declares, and
arguments written as name=value, which the layer does not have.

The prompt now writes each signature with each argument's kind, states
that every name the answer uses must be declared and that a statement's
name is never a program's, says that noise two calls share can be
declared once and passed by name, and shows a Circuit statement in its
example. The reader answers `seed=7` in a call by saying that arguments go
by position, instead of asking for a comma.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
`wai-quantum eval run` asks a model each task of a set, once and at
temperature 0. The model is asked either for the program alone or for an
answer in the answer view layer. The engine then scores what it writes:
whether the answer reads, the verdict's level against the task's intent,
whether the task is solved, and the joules per solved task where the model
server's process energy can be read.

Repair rounds send the engine's codes back for a corrected answer, and the
report keeps the first try's counts. A model server that is neither on
this machine nor on a private network is refused unless allowed. The
report ranks nothing, and no report is committed.

The task set (wai/quantum-conformance/eval/tasks.json) is fourteen tasks
from the intent conformance set and the worked examples. Each has a
reference program that a test holds to its intent by proof.

`eval corpus` writes each task's answer four ways: the program alone, the
layer whole, the layer with the request alone, and a job's JSON. Noise
that two calls share is named once. token_cost.py counts each form with
a model's own vocabulary. Its report on three open-weight vocabularies is
committed beside the corpus.

The smoke checks run a scripted model through the harness, and CI names
each harness test.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
The answer view layer's specification records the measured comparison in
§9. In three open-weight vocabularies, the layer takes 29 to 32 percent
more tokens than a job's JSON for the same request. The cost is per
statement, and noise that two calls share is named once. The spec does
not claim the layer is cheaper.

§9.1 records how reliably one local model wrote the layer. It wrote the
layer far less reliably than a program alone: 4 of 14 answers were valid
against 12, and 7 against 13 after one repair round. It also lists the
errors and the prompt revision, which left the score where it was. §3
says there are no named arguments, and that a value several calls take
is declared once.

The engine's, the service's and the views crate's READMEs describe the
views, the layer and the correctness record. The service's smoke checks
open a views session. The changelog entry covers the views in agent
hosts, the layer, the records, the harness and the measurement-order fix.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
The apps branch's documents join the version contract. The answer layer's
documents (wai.quantum.answer/1: an answer read, carried out, a seal's
request and result, a stored answer checked), described as a draft whose form
may change before the extension settles; a correctness record and its corpus
(wai.quantum.telemetry/1); the views page's manifest
(wai.quantum.views-bundle/1); and the command line's harness report, corpus
and token counts (wai.quantum.eval-report/1, eval-answers/1, token-cost/1).
The engine's test holds every answer of the layer's conformance set (read,
carried out, half arrived, and stored and verified), records, the corpus and
the committed manifest to them; the eval tests hold a scripted run's report,
a model server's, the corpus and the committed token counts; check_schemas.py
holds the committed documents too. The tool and diagnostic schemas take the
answer layer's outcomes, dropped and defaulted.

The result view's own tool, poll_quantum_job, listed only to a host that
draws views, answers to the job's schema, and the strict test holds it.

The basis rename reaches the views: a compile's words and its view name the
gate set by its basis (both read the certificate's old target), and a test in
each holds it.

The service's job summary now lives in engine::views (the apps branch moved
it there); it carries the durable branch's set summary and the processor
packages' energy wording with it.

The answer set's stored seal was made at 0.6.16; the values it seals name
their engine, so it is written again at 0.7.0 (WAI_ANSWER_BUNDLE_WRITE=1).
The views crate's lock moves to wai-quantum 0.7.0.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
engine::course reads the course from wai-quantum/course/: 21 lessons from a
first circuit through superposition, entanglement, interference, the standard
algorithms, noise and mitigation, error correction and fault tolerance to
resource estimates, each a Markdown text in English and Simplified Chinese and
an exercise.json with a schema. A check runs each case of an exercise (a
generator's inputs) with its intent and the verdict, measures its constraints
(the gates allowed, counts, the T count, the critique's smells, the resource
estimate's counts), and says what went wrong from the diagnostics, the verdict
and the critique, never from the solution. The tests hold every solution to
pass by proof, every known wrong answer to fail for its stated reason, and
every locale to every text and message.

wai-quantum learn shows, starts, checks, hints and explains a lesson, keeps
progress only on this machine, and speaks the language --lang or LANG names;
the command summaries and docs topics have Chinese translations held to the
English they came from. The verdict gains of_diagnostic for a generator's
refusal. llms.txt names the course.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
The Course pane lists the 21 lessons, shows a lesson's text and exercise,
loads its starter, and checks the program in the editor with the engine
(engine_course_check in the page, the same commands in the desktop app):
each case's verdict, each rule, What went wrong? from the diagnostics, the
verdict and the critique, the hints one at a time with the engine's pointer,
and a hint from the assistant when a model is connected, any program in its
answer held back. Progress is kept only in this browser and says so.

The interface's words are data, locales/<locale>/<area>.json for every part,
English the source and Simplified Chinese marked machine-assisted; the Studio
follows the browser's language until the reader picks one with the switch.
test/locales.test.mjs holds every locale to every key and placeholder. The
e2e checks the course in English and in Chinese. wai-web's engine tests pin
23 native and 16 wasm32, a course check the same bytes in both.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
wai/tools/quantum-docs/check_docs.py runs every block marked runnable on the
pages docs.json names (the engine, the command line, the service, Python,
the Studio, the desktop app, the editors, the providers, the compiler,
estimates, verdicts, the feature matrix, the course and the agent skill) in
a scratch directory of fixtures, holds each shown output to the real one,
verifies every receipt a block writes, builds and runs the Rust blocks, and
checks every block that cannot run for the commands and flags it names,
every wai-quantum command in the prose, every relative link and every
dependency shown; a translation must hold its English page's code. ci.sh
builds the command line, the service and the wheel and starts a service, as
wai-quantum-docs.yml runs it, beside the course's and the locales' tests.

Drift fixed: the crate pinned "0.4", named an unrelated crate for the command
line, ran its research tools outside lab, claimed the whole suite under
wasip2, and split its feature table from its header; the command line's
README said the reader refuses while, inv and pow, used placeholders and
optional flags that do not run, and merged versions that do not exist; the
estimate page's output lacked its receipts line; build steps now match CI.
An observable may lead with its coefficient ("0.5 X2"), as documented.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
The command line's, the crate's, the Studio's and the Python package's READMEs, and the documentation index, each a machine-assisted translation marked so on its first line, to be reviewed by a fluent reader before it is advertised. Each holds its English page's code, which check_docs.py holds it to.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
The course's documents join the version contract. The course as kept and as
served (wai.quantum.course/1) and each exercise (wai.quantum.exercise/1) move
from course/schema/ to the crate's schemas/, named and versioned as the rest;
a check, a lesson as served and a hint are wai.quantum.course-check/1, and a
check now names its engine beside its schema; the command line's progress
file is wai.quantum.learn-progress/1. The engine's test holds the course,
every exercise, every lesson in each locale and a check and hint of some to
them; the learn test holds the progress file; the contract workflow requires
both, and the eval and lease tests, by name, and runs when the answer and
eval sets its tests read change.

The docs runner reads every page the branches added: the error-correction
page, the version policy, the deprecations page, the service's self-hosting,
scheduler and provenance pages, and the views' README. Each block the other
branches wrote either runs or says why it cannot (a sweep fixture added), and
the job service it starts keeps its store in its scratch. The crate's README
names wai-quantum 0.7. The Chinese READMEs hold the English pages' code again:
the sections for error correction, sets and sweeps, the service's dry runs,
the scheduler, scoring a model, the answer layer, views and versions are
translated, and the compile pages name the gate set basis. The command
line's Chinese words cover task, qec, eval and version, and submit as it
reads now. The documentation index links the policy, the deprecations, the
error-correction page and the service's pages in both languages.

The policy lists every schema file and says the answer layer is a draft
outside its promise. The 0.7.0 heading names what the four branches bring.

The views page bundles the Studio components that now read their words
through the locale module; build-views.mjs gives it the English words alone,
so no other language's words reach a host. The result parts the Studio and
the views share read their words through it too, so the Studio's result pane
stays translated, its English unchanged.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
wai-quantum 0.7.0 integrated: the generated material on the final tree, the pins it moves, and what replaying every job found
All checks were successful
wai-quantum views in agent hosts / views · the page and its engine (pull_request) Successful in 2m52s
Details
wai-quantum views in agent hosts / views · a scripted host (pull_request) Successful in 3m5s
Details
wai-quantum WebGPU member / shader checks · browser build · wasip2 inertness · MSRV (pull_request) Successful in 3m29s
Details
WAI energy receipts / energy receipts · macos (pull_request) Successful in 6m5s
Details
WAI conformance / cargo-class corpora · macos (pull_request) Successful in 19m28s
Details
wai-web reach builds / wai-web reach builds · the package of record, every output as recorded (pull_request) Successful in 2m25s
Details
wai-quantum command line / command line · macos (pull_request) Successful in 1m8s
Details
wai-quantum dataflow member / member · dataflow device absent (macos) (pull_request) Successful in 18s
Details
wai-quantum signal processor / processor and member · signal processor, emulated (pull_request) Successful in 15m53s
Details
wai-quantum editors / editors · macos (pull_request) Successful in 1m18s
Details
wai-quantum FPGA member / member · FPGA datapath, simulated (macos) (pull_request) Successful in 1m25s
Details
wai-quantum Metal member / member · Metal (macos) (pull_request) Successful in 35s
Details
wai-web wasm32 / wai-web wasm32 build · corpus, menu and writers (pull_request) Successful in 5m53s
Details
wai-quantum OpenCL member / member · OpenCL GPU (macos) (pull_request) Successful in 26s
Details
wai-web reach builds / wai-web reach builds · this tree's wai-web, every rung on its engine line (pull_request) Successful in 4m35s
Details
WAI mbt2018_mean integer decode (regenerated vectors) / regenerate mbt2018_mean integer vectors → Rust decode, required (pull_request) Successful in 5m32s
Details
wai-quantum for Python / python · macos (pull_request) Successful in 1m59s
Details
wai-quantum-qpu / credentials in the keychain (macos) (pull_request) Successful in 23s
Details
wai-quantum service / service · macos (pull_request) Successful in 1m11s
Details
wai-quantum matrix-extension member / member · matrix extension absent (macos) (pull_request) Successful in 11s
Details
WAI examples / WAI examples · the archive, the readiness check, the browser and Apple · macos (pull_request) Successful in 14m44s
Details
wai-quantum CPU vector units / member · vector unit absent (macos) (pull_request) Successful in 19s
Details
wai-quantum portable tensor program / tensor program · Metal and the arm64 CPU (macos) (pull_request) Successful in 18s
Details
wai-quantum WebGPU member / member · Metal (macos) (pull_request) Successful in 3m26s
Details
wai-quantum studio and desktop / desktop app · macos (pull_request) Successful in 4m35s
Details
wai-quantum neural-processor member / member · neural processor (macos) (pull_request) Successful in 9m55s
Details
wai-quantum WebGPU member / member · browser WebGPU (macos) (pull_request) Successful in 2m15s
Details
wai-sink-android native sink library / every ABI, the AAR, and the instrumented tests in a headless emulator · macos (pull_request) Successful in 7m1s
Details
WAI conformance / independent verifiers · claims, JWP, key discovery and integer payloads (Python) (pull_request) Successful in 1h0m15s
Details
wai-sink-swift native sink package / libwai slices, desktop tests, simulator tests · macos (pull_request) Successful in 15m58s
Details
de3383d7bd 
Generated on the final tree: the views page, rebuilt (802 495 bytes, under
1 MiB) from its sources; the notebooks' stored outputs; the agent docs. The
pins that move: wai-web's course check names its engine now, so its digest
moves (374b400e... to 969b2c1c..., and with every release from here), and the
page's wasm32 count is 18 (native 26, as pinned). wai-quantum-qpu's library
count is 34, as the cherry-picked pin says.

What replaying each workflow's jobs found, each fixed here:
- the views page's one line carried the estimate pane's English note, "no
  other beats on both", which the comparative-prose check reads across the
  line; the note says "none of the others beats on both";
- the docs runner's broken.qasm is broken on purpose, so the editors check
  requires it to fail to parse, as the intent set's broken programs;
- the command line's parse test named the service's submit and task in a
  build without the service; those checks are a test of their own, built
  with it;
- the set-only Merkle helpers warned in a build without receipts;
- a one-element loop in the service's strict test;
- the energy job looked for the live counter's line at the start of a line,
  where --nocapture puts it after the test's name;
- the Python test comparing a run on the service with one here now leaves out
  the provenance the service adds, and checks it is there.

The release heading's caller list is the final API check's: the frame text's
new fields and variant, and the request's compile passes and mitigation.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
wai/CHANGELOG.md: the 0.7.0 release acknowledges its fourteen breaking changes
All checks were successful
wai-quantum signal processor / processor and member · signal processor, emulated (pull_request) Successful in 16m18s
Details
wai-quantum WebGPU member / member · discrete GPU, Vulkan (jetson-hub) (pull_request) Successful in 22m15s
Details
WAI mbt2018_mean integer decode (regenerated vectors) / regenerate mbt2018_mean integer vectors → Rust decode, required (pull_request) Successful in 5m18s
Details
wai-web wasm32 / wai-web wasm32 build · corpus, menu and writers (pull_request) Successful in 5m38s
Details
wai-audit collector and player integration / collector, player integration and the browser end to end · macos (pull_request) Successful in 1m11s
Details
standards workspaces build + test / macOS energy backends (pull_request) Successful in 8m46s
Details
WAI conformance / cross-arch byte-equality · macos (pull_request) Successful in 26s
Details
WAI conformance / codec wrappers · fuzz smoke, text decode limits, C entry points, provenance, the semantic path (pull_request) Successful in 1m0s
Details
WAI energy receipts / energy receipts · macos (pull_request) Successful in 5m15s
Details
wai-quantum command line / command line · macos (pull_request) Successful in 1m3s
Details
wai-quantum dataflow member / member · dataflow device absent (macos) (pull_request) Successful in 21s
Details
wai-quantum editors / editors · macos (pull_request) Successful in 1m20s
Details
wai-quantum FPGA member / member · FPGA datapath, simulated (macos) (pull_request) Successful in 1m18s
Details
wai-quantum Metal member / member · Metal (macos) (pull_request) Successful in 41s
Details
WAI conformance / cargo-class corpora · macos (pull_request) Successful in 18m15s
Details
wai-quantum OpenCL member / member · OpenCL GPU (macos) (pull_request) Successful in 28s
Details
WAI examples / WAI examples · the archive, the readiness check, the browser and Apple · macos (pull_request) Successful in 13m56s
Details
wai-quantum for Python / python · macos (pull_request) Successful in 2m14s
Details
wai-quantum-qpu / credentials in the keychain (macos) (pull_request) Successful in 25s
Details
wai-quantum matrix-extension member / member · matrix extension absent (macos) (pull_request) Successful in 12s
Details
wai-quantum service / service · macos (pull_request) Successful in 1m18s
Details
wai-quantum CPU vector units / member · vector unit absent (macos) (pull_request) Successful in 17s
Details
wai-quantum portable tensor program / tensor program · Metal and the arm64 CPU (macos) (pull_request) Successful in 20s
Details
wai-quantum neural-processor member / member · neural processor (macos) (pull_request) Successful in 9m44s
Details
wai-quantum studio and desktop / desktop app · macos (pull_request) Successful in 4m18s
Details
wai-quantum WebGPU member / member · Metal (macos) (pull_request) Successful in 2m55s
Details
wai-quantum WebGPU member / member · browser WebGPU (macos) (pull_request) Successful in 2m2s
Details
WAI conformance / independent verifiers · claims, JWP, key discovery and integer payloads (Python) (pull_request) Successful in 58m41s
Details
wai-sink-android native sink library / every ABI, the AAR, and the instrumented tests in a headless emulator · macos (pull_request) Successful in 7m29s
Details
wai-sink-swift native sink package / libwai slices, desktop tests, simulator tests · macos (pull_request) Successful in 15m44s
Details
fb34b5596b 
`wai breaking --against origin/main` names fourteen API changes in
wai-quantum 0.7.0: new request and compile-option fields, new refusal
outcomes, the grown schema list, new circuit and error-model fields, and
the Observe operation. Each is intended; each line says what a caller
adds (a `None` or empty field, a match arm, or iterating over FILES).

Co-Authored-By: Claude Opus 5.5 <[email protected]>
dcharlot closed this pull request 2026-10-28 08:54:54 -04:00
All checks were successful
wai-quantum on every processor / emulated · aarch64-unknown-linux-gnu (pull_request) Successful in 2m13s
Details
wai-quantum on every processor / emulated · loongarch64-unknown-linux-gnu (pull_request) Successful in 2m55s
Details
wai-quantum on every processor / emulated · armv7-unknown-linux-gnueabihf (pull_request) Successful in 5m7s
Details
wai-quantum on every processor / emulated · powerpc64-unknown-linux-gnu (pull_request) Successful in 4m58s
Details
wai-web reach builds / wai-web reach · does this change touch it (pull_request) Successful in 6s
Details
wai-web reach builds / wai-web reach builds · the package of record, every output as recorded (pull_request) Successful in 2m15s
Details
wai-quantum on every processor / emulated · powerpc64le-unknown-linux-gnu (pull_request) Successful in 8m0s
Details
wai-quantum on every processor / emulated · sparc64-unknown-linux-gnu (pull_request) Successful in 5m52s
Details
wai-quantum on every processor / emulated · i686-unknown-linux-gnu (pull_request) Successful in 5m1s
Details
wai-quantum on every processor / emulated · riscv64gc-unknown-linux-gnu (pull_request) Successful in 9m24s
Details
wai-web reach builds / wai-web reach builds · this tree's wai-web, every rung on its engine line (pull_request) Successful in 4m30s
Details
wai-quantum WebGPU member / member · DX12 and Vulkan (cbio-windows) (pull_request) Successful in 12m21s
Details
wai-quantum on every processor / emulated · s390x-unknown-linux-gnu (pull_request) Successful in 11m29s
Details
standards workspaces build + test / which workspaces this change touches (pull_request) Successful in 11s
Details
wai-audit collector and player integration / does this change touch it (pull_request) Successful in 9s
Details
WAI breaking changes and the conformance runner / WAI breaking · does this change touch WAI (pull_request) Successful in 8s
Details
WAI conformance / does this change touch it (pull_request) Successful in 8s
Details
WAI energy receipts / does this change touch it (pull_request) Successful in 7s
Details
WAI examples / WAI examples · does this change touch them (pull_request) Successful in 7s
Details
wai-quantum command line / does this change touch it (pull_request) Successful in 6s
Details
wai-quantum contract / does this change touch it (pull_request) Successful in 7s
Details
wai-quantum CUDA member / does this change touch it (pull_request) Successful in 9s
Details
wai-quantum dataflow member / does this change touch it (pull_request) Successful in 12s
Details
wai-quantum docs, course and locales / does this change touch it (pull_request) Successful in 9s
Details
wai-quantum signal processor / does this change touch it (pull_request) Successful in 7s
Details
wai-quantum editors / does this change touch it (pull_request) Successful in 7s
Details
wai-audit collector and player integration / collector · linux (pull_request) Successful in 1m18s
Details
wai-quantum resource estimation / does this change touch it (pull_request) Successful in 7s
Details
wai-quantum FPGA member / does this change touch it (pull_request) Successful in 9s
Details
wai-quantum CUDA member / member · CUDA (jetson-hub) (pull_request) Successful in 33s
Details
wai-quantum HIP member / does this change touch it (pull_request) Successful in 11s
Details
wai-quantum OpenQASM reader / does this change touch it (pull_request) Successful in 16s
Details
WAI conformance / cross-arch byte-equality · linux (pull_request) Successful in 30s
Details
WAI conformance / faces from keypoints under wasm32-wasip2 (wasmtime) (pull_request) Successful in 1m41s
Details
repository checks / lockfiles, advisories, tests in CI, workflow hygiene, spec and section references, public text (pull_request) Successful in 2m50s
Details
WAI breaking changes and the conformance runner / WAI breaking · wire, record and API against main · linux (pull_request) Successful in 2m3s
Details
wai-quantum Metal member / does this change touch it (pull_request) Successful in 15s
Details
wai-quantum neural-processor member / does this change touch it (pull_request) Successful in 6s
Details
wai-quantum npu-cores member / does this change touch it (pull_request) Successful in 10s
Details
wai-quantum OpenCL member / does this change touch it (pull_request) Successful in 6s
Details
wai-quantum for Python / does this change touch it (pull_request) Successful in 6s
Details
wai-quantum error correction and mitigation / does this change touch it (pull_request) Successful in 6s
Details
wai-quantum-qpu / does this change touch it (pull_request) Successful in 6s
Details
wai-quantum service / does this change touch it (pull_request) Successful in 6s
Details
wai-quantum matrix-extension member / does this change touch it (pull_request) Successful in 7s
Details
wai-quantum studio and desktop / does this change touch it (pull_request) Successful in 6s
Details
wai-quantum CPU vector units / does this change touch it (pull_request) Successful in 6s
Details
WAI breaking changes and the conformance runner / WAI breaking and conform · their tests, and the independent verifiers through wai conform · linux (pull_request) Successful in 2m48s
Details
wai-quantum portable tensor program / does this change touch it (pull_request) Successful in 7s
Details
wai-quantum tensor-engine member / does this change touch it (pull_request) Successful in 8s
Details
wai-quantum verdicts and repairs / does this change touch it (pull_request) Successful in 6s
Details
wai-quantum views in agent hosts / does this change touch it (pull_request) Successful in 6s
Details
wai-quantum WebGPU member / does this change touch it (pull_request) Successful in 7s
Details
wai-sink-android native sink library / does this change touch it (pull_request) Successful in 6s
Details
wai-sink-swift native sink package / does this change touch it (pull_request) Successful in 6s
Details
wai-web wasm32 / does this change touch it (pull_request) Successful in 6s
Details
WAI mbt2018_mean integer decode (regenerated vectors) / does this change touch it (pull_request) Successful in 7s
Details
wai-quantum OpenCL member / member · OpenCL GPU and CPU (jetson-hub) (pull_request) Successful in 37s
Details
WAI conformance / fast integer kernels, every x86_64 kernel set (AVX-512 silicon) (pull_request) Successful in 3m5s
Details
WAI conformance / v2 vocabulary · manifests validate as stated (pull_request) Successful in 18s
Details
WAI conformance / quantum core and corpus under wasm32-wasip2 (wasmtime) (pull_request) Successful in 3m21s
Details
wai-quantum HIP member / member · HIP (framework-128gb) (pull_request) Successful in 32s
Details
wai-quantum service / service energy · linux packages (pull_request) Successful in 1m23s
Details
wai-quantum command line / command line · linux (pull_request) Successful in 2m23s
Details
wai-quantum contract / the policy is linked, and the deprecations page reads (pull_request) Successful in 4s
Details
wai-quantum npu-cores member / member · npu-cores, neural processor (framework-128gb silicon) (pull_request) Successful in 1m16s
Details
wai-quantum portable tensor program / tensor program · GPUs (jetson-hub) (pull_request) Successful in 31s
Details
wai-quantum CUDA member / member · CUDA absent (linux) (pull_request) Successful in 25s
Details
wai-quantum OpenCL member / member · OpenCL GPU (framework-128gb) (pull_request) Successful in 21s
Details
wai-quantum CPU vector units / member · vector units, avx2 and avx512 (framework-128gb silicon) (pull_request) Successful in 18s
Details
wai-quantum portable tensor program / tensor program · integrated GPU (framework-128gb) (pull_request) Successful in 13s
Details
wai-quantum contract / schemas and the committed tool lists · linux (pull_request) Successful in 3m24s
Details
wai-quantum contract / API compatibility · linux (pull_request) Successful in 4m16s
Details
wai-quantum dataflow member / member · dataflow device, simulated (pci 1e52:b140) (pull_request) Successful in 4m8s
Details
wai-quantum dataflow member / member · dataflow device, simulated (pci 1e52:401e) (pull_request) Successful in 2m52s
Details
standards workspaces build + test / joule-code-rs (joule-code/joule-code-rs, joule-code-rs, linux-arm64, true) (pull_request) Successful in 7m5s
Details
wai-quantum docs, course and locales / the Studio's words in every locale · linux (pull_request) Successful in 16s
Details
WAI conformance / delivery telemetry · CMCD and CMSD against an independent library (pull_request) Successful in 11s
Details
WAI conformance / cross-arch byte-equality · linux-arm64 (pull_request) Successful in 31s
Details
wai-quantum docs, course and locales / the course and the command line's languages · linux (pull_request) Successful in 2m3s
Details
WAI examples / WAI examples · portable · linux (pull_request) Successful in 9m59s
Details
WAI conformance / C2PA manifest emission · signed, read back, validated (pull_request) Successful in 1m54s
Details
WAI energy receipts / energy receipts · linux (pull_request) Successful in 11m24s
Details
wai-quantum editors / editors · linux (pull_request) Successful in 2m7s
Details
wai-quantum resource estimation / estimation and calibration · linux, release (pull_request) Successful in 1m38s
Details
wai-quantum FPGA member / member · FPGA simulation absent (linux) (pull_request) Successful in 22s
Details
wai-quantum Metal member / member · Metal absent (linux) (pull_request) Successful in 27s
Details
wai-quantum OpenQASM reader / corpus under wasm32-wasip2 (wasmtime) (pull_request) Successful in 39s
Details
WAI conformance / each feature of the independent verifiers' steps compiles alone (pull_request) Successful in 11m8s
Details
wai-quantum neural-processor member / member · neural processor absent (linux) (pull_request) Successful in 21s
Details
wai-quantum WebGPU member / member · integrated GPU, Vulkan (framework-128gb) (pull_request) Successful in 8m46s
Details
wai-quantum OpenCL member / member · OpenCL absent (linux) (pull_request) Successful in 24s
Details
wai-quantum OpenQASM reader / reader and corpus · linux (pull_request) Successful in 1m39s
Details
wai-quantum-qpu / clients against their contracts (linux) (pull_request) Successful in 42s
Details
wai-quantum for Python / python · linux (pull_request) Successful in 2m27s
Details
wai-quantum error correction and mitigation / codes, decoders, texts and mitigation · linux, release (pull_request) Successful in 2m19s
Details
wai-quantum matrix-extension member / member · matrix extension, emulated (aarch64 Linux) (pull_request) Successful in 16s
Details
wai-quantum CPU vector units / member · vector unit, rvv 1024-bit (riscv64, emulated) (pull_request) Successful in 20s
Details
wai-quantum service / service · linux (pull_request) Successful in 2m3s
Details
wai-quantum CPU vector units / member · vector unit, sve 128-bit (aarch64, emulated) (pull_request) Successful in 26s
Details
wai-quantum CPU vector units / member · vector unit, rvv 128-bit (riscv64, emulated) (pull_request) Successful in 20s
Details
wai-quantum CPU vector units / member · vector unit, sve 2048-bit (aarch64, emulated) (pull_request) Successful in 13s
Details
WAI conformance / cargo-class corpora · linux (pull_request) Successful in 18m37s
Details
wai-quantum CPU vector units / member · vector unit, avx2 (x86_64 silicon) (pull_request) Successful in 20s
Details
wai-quantum CPU vector units / member · vector unit, sve 512-bit (aarch64, emulated) (pull_request) Successful in 19s
Details
wai-quantum portable tensor program / tensor program · CPU, mutants, GPU builds (pull_request) Successful in 30s
Details
WAI examples / WAI examples · android-app · linux-arm64 (pull_request) Successful in 5m16s
Details
wai-quantum verdicts and repairs / verdicts, repairs and the intent set · linux (pull_request) Successful in 1m33s
Details
wai-quantum verdicts and repairs / the intent set and the verdict under wasm32-wasip2 (wasmtime) (pull_request) Successful in 1m11s
Details
wai-quantum HIP member / member · HIP absent (linux-arm64) (pull_request) Successful in 35s
Details
wai-quantum studio and desktop / studio · browser (pull_request) Successful in 3m36s
Details
wai-quantum npu-cores member / member · npu-cores absent (linux-arm64) (pull_request) Successful in 31s
Details
wai-quantum tensor-engine member / member · tensor engine absent (linux-arm64) (pull_request) Successful in 26s
Details
wai-quantum docs, course and locales / every command and snippet in the docs · linux (pull_request) Successful in 15m56s
Details
WAI energy receipts / energy receipts · linux-arm64 (pull_request) Successful in 10m12s
Details
wai-quantum views in agent hosts / views · the page and its engine (pull_request) Successful in 2m48s
Details
wai-quantum tensor-engine member / member · tensor engine, the kernel toolchain's simulator (linux) (pull_request) Successful in 4m48s
Details
wai-quantum views in agent hosts / views · a scripted host (pull_request) Successful in 3m12s
Details
wai-sink-android native sink library / the JNI layer and the platform-free half on the host JVM · linux-arm64 (pull_request) Successful in 2m41s
Details
wai-quantum WebGPU member / shader checks · browser build · wasip2 inertness · MSRV (pull_request) Successful in 3m33s
Details
WAI conformance / cargo-class corpora · linux-arm64 (pull_request) Successful in 21m41s
Details
wai-quantum WebGPU member / member · software Vulkan (linux) (pull_request) Successful in 1m58s
Details
wai-quantum signal processor / processor and member · signal processor, emulated (pull_request) Successful in 16m18s
Details
wai-quantum WebGPU member / member · discrete GPU, Vulkan (jetson-hub) (pull_request) Successful in 22m15s
Details
WAI mbt2018_mean integer decode (regenerated vectors) / regenerate mbt2018_mean integer vectors → Rust decode, required (pull_request) Successful in 5m18s
Details
wai-web wasm32 / wai-web wasm32 build · corpus, menu and writers (pull_request) Successful in 5m38s
Details
wai-audit collector and player integration / collector, player integration and the browser end to end · macos (pull_request) Successful in 1m11s
Details
standards workspaces build + test / macOS energy backends (pull_request) Successful in 8m46s
Details
WAI conformance / cross-arch byte-equality · macos (pull_request) Successful in 26s
Details
WAI conformance / codec wrappers · fuzz smoke, text decode limits, C entry points, provenance, the semantic path (pull_request) Successful in 1m0s
Details
WAI energy receipts / energy receipts · macos (pull_request) Successful in 5m15s
Details
wai-quantum command line / command line · macos (pull_request) Successful in 1m3s
Details
wai-quantum dataflow member / member · dataflow device absent (macos) (pull_request) Successful in 21s
Details
wai-quantum editors / editors · macos (pull_request) Successful in 1m20s
Details
wai-quantum FPGA member / member · FPGA datapath, simulated (macos) (pull_request) Successful in 1m18s
Details
wai-quantum Metal member / member · Metal (macos) (pull_request) Successful in 41s
Details
WAI conformance / cargo-class corpora · macos (pull_request) Successful in 18m15s
Details
wai-quantum OpenCL member / member · OpenCL GPU (macos) (pull_request) Successful in 28s
Details
WAI examples / WAI examples · the archive, the readiness check, the browser and Apple · macos (pull_request) Successful in 13m56s
Details
wai-quantum for Python / python · macos (pull_request) Successful in 2m14s
Details
wai-quantum-qpu / credentials in the keychain (macos) (pull_request) Successful in 25s
Details
wai-quantum matrix-extension member / member · matrix extension absent (macos) (pull_request) Successful in 12s
Details
wai-quantum service / service · macos (pull_request) Successful in 1m18s
Details
wai-quantum CPU vector units / member · vector unit absent (macos) (pull_request) Successful in 17s
Details
wai-quantum portable tensor program / tensor program · Metal and the arm64 CPU (macos) (pull_request) Successful in 20s
Details
wai-quantum neural-processor member / member · neural processor (macos) (pull_request) Successful in 9m44s
Details
wai-quantum studio and desktop / desktop app · macos (pull_request) Successful in 4m18s
Details
wai-quantum WebGPU member / member · Metal (macos) (pull_request) Successful in 2m55s
Details
wai-quantum WebGPU member / member · browser WebGPU (macos) (pull_request) Successful in 2m2s
Details
WAI conformance / independent verifiers · claims, JWP, key discovery and integer payloads (Python) (pull_request) Successful in 58m41s
Details
wai-sink-android native sink library / every ABI, the AAR, and the instrumented tests in a headless emulator · macos (pull_request) Successful in 7m29s
Details
wai-sink-swift native sink package / libwai slices, desktop tests, simulator tests · macos (pull_request) Successful in 15m44s
Details

Pull request closed

Please reopen this pull request to perform a merge.
Sign in to join this conversation.
Reviewers
No reviewers
Labels
Clear labels
No items
No labels
Milestone
Clear milestone
No items
No milestone
Projects
Clear projects
No items
No project
Assignees
Clear assignees
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
Transaction-Science/open-standards!523
No description provided.