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

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

Merged
dcharlot merged 41 commits from wai/quantum-wave5b into main 2026-10-28 12:19:52 -04:00
Conversation 0 Commits 41 Files changed 414 +87988 -12803
dcharlot commented 2026-10-28 08:54:39 -04:00
Owner
Copy link

This replaces #523. Its checks all passed, but it could no longer merge once #522 changed one line of the Studio's critique panel. The work is the same, rebased onto main 877636ca5; that line keeps both changes, the panel's group role and its translated label.

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. Fourteen changes to the public Rust API (new request, compile-option, circuit and error-model fields, new refusal outcomes, the Observe operation, and the schema list growing from 11 to 22) are each acknowledged there, with what a caller adds; wai breaking --against origin/main reports none unacknowledged.

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 877636ca5: WAI Studio's end-to-end run in Chromium and Firefox, local and hosted, with Quantum Studio mounted (every panel passes axe for WCAG 2.2 A/AA, nothing scrolls sideways at a phone's width), and its unit tests and drift check.
  • On #523, before the rebase: 152 of 152 checks green. 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

This replaces #523. Its checks all passed, but it could no longer merge once #522 changed one line of the Studio's critique panel. The work is the same, rebased onto main 877636ca5; that line keeps both changes, the panel's group role and its translated label. 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. Fourteen changes to the public Rust API (new request, compile-option, circuit and error-model fields, new refusal outcomes, the `Observe` operation, and the schema list growing from 11 to 22) are each acknowledged there, with what a caller adds; `wai breaking --against origin/main` reports none unacknowledged. 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 877636ca5: WAI Studio's end-to-end run in Chromium and Firefox, local and hosted, with Quantum Studio mounted (every panel passes axe for WCAG 2.2 A/AA, nothing scrolls sideways at a phone's width), and its unit tests and drift check. - On #523, before the rebase: 152 of 152 checks green. 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) 
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]>
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
Some checks failed
WAI mbt2018_mean integer decode (regenerated vectors) / regenerate mbt2018_mean integer vectors → Rust decode, required (pull_request) Successful in 5m34s
Details
wai-web wasm32 / wai-web wasm32 build · corpus, menu and writers (pull_request) Successful in 5m57s
Details
WAI Studio / Studio in WebKit · linux (pull_request) Successful in 10m15s
Details
wai-audit collector and player integration / collector, player integration and the browser end to end · macos (pull_request) Successful in 1m30s
Details
WAI conformance / codec wrappers · fuzz smoke, text decode limits, C entry points, provenance, the semantic path (pull_request) Has been cancelled
Details
WAI energy receipts / energy receipts · macos (pull_request) Has been cancelled
Details
WAI examples / WAI examples · the archive, the readiness check, the browser and Apple · macos (pull_request) Has been cancelled
Details
wai-quantum command line / command line · macos (pull_request) Has been cancelled
Details
wai-quantum dataflow member / member · dataflow device absent (macos) (pull_request) Has been cancelled
Details
wai-quantum editors / editors · macos (pull_request) Has been cancelled
Details
standards workspaces build + test / macOS energy backends (pull_request) Has been cancelled
Details
WAI conformance / cargo-class corpora · macos (pull_request) Has been cancelled
Details
wai-quantum FPGA member / member · FPGA datapath, simulated (macos) (pull_request) Has been cancelled
Details
wai-quantum Metal member / member · Metal (macos) (pull_request) Has been cancelled
Details
WAI conformance / cross-arch byte-equality · macos (pull_request) Has been cancelled
Details
wai-quantum neural-processor member / member · neural processor (macos) (pull_request) Has been cancelled
Details
wai-quantum OpenCL member / member · OpenCL GPU (macos) (pull_request) Has been cancelled
Details
wai-quantum for Python / python · macos (pull_request) Has been cancelled
Details
wai-quantum-qpu / credentials in the keychain (macos) (pull_request) Has been cancelled
Details
wai-quantum service / service · macos (pull_request) Has been cancelled
Details
wai-quantum matrix-extension member / member · matrix extension absent (macos) (pull_request) Has been cancelled
Details
wai-quantum studio and desktop / desktop app · macos (pull_request) Has been cancelled
Details
wai-quantum portable tensor program / tensor program · Metal and the arm64 CPU (macos) (pull_request) Has been cancelled
Details
wai-quantum CPU vector units / member · vector unit absent (macos) (pull_request) Has been cancelled
Details
WAI conformance / independent verifiers · claims, JWP, key discovery and integer payloads (Python) (pull_request) Has been cancelled
Details
wai-quantum WebGPU member / member · Metal (macos) (pull_request) Has been cancelled
Details
wai-quantum WebGPU member / member · browser WebGPU (macos) (pull_request) Has been cancelled
Details
wai-sink-android native sink library / every ABI, the AAR, and the instrumented tests in a headless emulator · macos (pull_request) Has been cancelled
Details
wai-sink-swift native sink package / libwai slices, desktop tests, simulator tests · macos (pull_request) Has been cancelled
Details
WAI Studio / Studio in Chromium and Firefox · macos (pull_request) Has been cancelled
Details
55311a78b6 
`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]>
wai-quantum views: the manifest records critique-view.js as main left it
Some checks failed
wai-quantum CPU vector units / member · vector unit, rvv 1024-bit (riscv64, emulated) (pull_request) Successful in 34s
Details
wai-quantum CPU vector units / member · vector unit, sve 128-bit (aarch64, emulated) (pull_request) Successful in 25s
Details
wai-quantum CPU vector units / member · vector unit, rvv 128-bit (riscv64, emulated) (pull_request) Successful in 14s
Details
wai-quantum CPU vector units / member · vector unit, sve 2048-bit (aarch64, emulated) (pull_request) Successful in 10s
Details
wai-quantum CPU vector units / member · vector unit, sve 512-bit (aarch64, emulated) (pull_request) Successful in 9s
Details
wai-quantum CPU vector units / member · vector unit, avx2 (x86_64 silicon) (pull_request) Successful in 18s
Details
wai-quantum WebGPU member / member · Metal (macos) (pull_request) Successful in 2m48s
Details
wai-quantum studio and desktop / desktop app · macos (pull_request) Successful in 4m17s
Details
wai-quantum studio and desktop / studio · browser (pull_request) Successful in 3m46s
Details
wai-quantum WebGPU member / member · browser WebGPU (macos) (pull_request) Successful in 2m6s
Details
wai-quantum views in agent hosts / views · the page and its engine (pull_request) Successful in 2m40s
Details
wai-quantum signal processor / processor and member · signal processor, emulated (pull_request) Successful in 13m54s
Details
wai-quantum views in agent hosts / views · a scripted host (pull_request) Successful in 2m57s
Details
wai-quantum tensor-engine member / member · tensor engine, the kernel toolchain's simulator (linux) (pull_request) Successful in 4m41s
Details
wai-quantum neural-processor member / member · neural processor (macos) (pull_request) Successful in 9m53s
Details
wai-quantum verdicts and repairs / the intent set and the verdict under wasm32-wasip2 (wasmtime) (pull_request) Successful in 1m10s
Details
WAI Studio / the catalogue's actions, the unit tests and the core · linux (pull_request) Successful in 58s
Details
wai-quantum verdicts and repairs / verdicts, repairs and the intent set · linux (pull_request) Successful in 1m47s
Details
wai-quantum WebGPU member / member · software Vulkan (linux) (pull_request) Successful in 2m2s
Details
wai-quantum WebGPU member / shader checks · browser build · wasip2 inertness · MSRV (pull_request) Successful in 3m33s
Details
wai-quantum docs, course and locales / every command and snippet in the docs · linux (pull_request) Successful in 15m29s
Details
wai-web reach builds / wai-web reach builds · the package of record, every output as recorded (pull_request) Successful in 2m27s
Details
wai-sink-android native sink library / every ABI, the AAR, and the instrumented tests in a headless emulator · macos (pull_request) Successful in 8m10s
Details
WAI mbt2018_mean integer decode (regenerated vectors) / regenerate mbt2018_mean integer vectors → Rust decode, required (pull_request) Successful in 5m38s
Details
wai-web wasm32 / wai-web wasm32 build · corpus, menu and writers (pull_request) Successful in 6m4s
Details
wai-web reach builds / wai-web reach builds · this tree's wai-web, every rung on its engine line (pull_request) Successful in 5m32s
Details
WAI Studio / Studio in Chromium and Firefox · macos (pull_request) Successful in 10m31s
Details
WAI Studio / Studio in WebKit · linux (pull_request) Failing after 11m48s
Details
wai-sink-swift native sink package / libwai slices, desktop tests, simulator tests · macos (pull_request) Successful in 17m10s
Details
WAI conformance / independent verifiers · claims, JWP, key discovery and integer payloads (Python) (pull_request) Successful in 1h0m8s
Details
c09d126bf3 
#522 gave the critique panel a group role. The views page does not carry
the panel, so its bytes and digest are unchanged; only the source's
digest in the manifest moves, rebuilt with wai-quantum-views/build.sh.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
Editing by drawing makes each gate a focusable button. An image's
children are presentational, so a focusable gate inside an svg with
role img is a nested interactive control (axe: nested-interactive,
serious), which WAI Studio's WebKit run reports. When the gates become
buttons, the diagram takes role group and keeps its name.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
wai-quantum-dataflow.yml: the instruction table's line matched anywhere in a line
All checks were successful
wai-quantum verdicts and repairs / the intent set and the verdict under wasm32-wasip2 (wasmtime) (pull_request) Successful in 1m11s
Details
WAI conformance / cargo-class corpora · linux-arm64 (pull_request) Successful in 23m50s
Details
wai-quantum views in agent hosts / views · the page and its engine (pull_request) Successful in 2m47s
Details
wai-quantum WebGPU member / member · discrete GPU, Vulkan (jetson-hub) (pull_request) Successful in 22m55s
Details
wai-quantum views in agent hosts / views · a scripted host (pull_request) Successful in 3m21s
Details
wai-quantum WebGPU member / member · software Vulkan (linux) (pull_request) Successful in 1m57s
Details
wai-quantum signal processor / processor and member · signal processor, emulated (pull_request) Successful in 13m58s
Details
WAI conformance / cargo-class corpora · macos (pull_request) Successful in 23m27s
Details
WAI Studio / the catalogue's actions, the unit tests and the core · linux (pull_request) Successful in 58s
Details
wai-quantum WebGPU member / shader checks · browser build · wasip2 inertness · MSRV (pull_request) Successful in 3m38s
Details
WAI examples / WAI examples · the archive, the readiness check, the browser and Apple · macos (pull_request) Successful in 17m55s
Details
wai-quantum OpenCL member / member · OpenCL GPU (macos) (pull_request) Successful in 34s
Details
wai-quantum for Python / python · macos (pull_request) Successful in 2m19s
Details
WAI mbt2018_mean integer decode (regenerated vectors) / regenerate mbt2018_mean integer vectors → Rust decode, required (pull_request) Successful in 5m40s
Details
wai-quantum-qpu / credentials in the keychain (macos) (pull_request) Successful in 48s
Details
wai-quantum docs, course and locales / every command and snippet in the docs · linux (pull_request) Successful in 21m56s
Details
wai-quantum matrix-extension member / member · matrix extension absent (macos) (pull_request) Successful in 17s
Details
wai-quantum service / service · macos (pull_request) Successful in 1m23s
Details
wai-quantum portable tensor program / tensor program · Metal and the arm64 CPU (macos) (pull_request) Successful in 21s
Details
wai-web wasm32 / wai-web wasm32 build · corpus, menu and writers (pull_request) Successful in 6m25s
Details
wai-quantum CPU vector units / member · vector unit absent (macos) (pull_request) Successful in 21s
Details
wai-quantum neural-processor member / member · neural processor (macos) (pull_request) Successful in 9m11s
Details
wai-quantum WebGPU member / member · browser WebGPU (macos) (pull_request) Successful in 3m9s
Details
wai-quantum WebGPU member / member · Metal (macos) (pull_request) Successful in 4m20s
Details
wai-quantum studio and desktop / desktop app · macos (pull_request) Successful in 5m20s
Details
WAI Studio / Studio in WebKit · linux (pull_request) Successful in 11m30s
Details
wai-sink-android native sink library / every ABI, the AAR, and the instrumented tests in a headless emulator · macos (pull_request) Successful in 9m6s
Details
WAI Studio / Studio in Chromium and Firefox · macos (pull_request) Successful in 13m19s
Details
wai-sink-swift native sink package / libwai slices, desktop tests, simulator tests · macos (pull_request) Successful in 19m40s
Details
WAI conformance / independent verifiers · claims, JWP, key discovery and integer payloads (Python) (pull_request) Successful in 1h5m43s
Details
ca65767cd9 
The tests run in parallel with --nocapture, so "tensix layouts: N
instructions match the table" can follow another test's "... ok" on the
same line, and the anchored grep then missed a check that had run.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
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!524
No description provided.