diff --git a/CHANGELOG.adoc b/CHANGELOG.adoc index d9f8ce70..8231fb4d 100644 --- a/CHANGELOG.adoc +++ b/CHANGELOG.adoc @@ -53,9 +53,22 @@ to end, plus the plan for the phases after it. source "GitHub Actions"; `pages.yml` lost its `push` and `workflow_dispatch` triggers. The helper's old `publish` route is no longer used by any workflow and is left in place for a follow-up removal. +* Soundness repair (2026-11-07): the gate clears valid writable outputs before + wrapper-level errors, and its tests start with poisoned bytes. The 14-byte + field extent within a 16-byte struct is corrected, and the invalid foreign + binding is removed. Experimental: the evidence report records observed + results only. ==== Added +* Source-bound u8 pilot (experimental): `source-vc` and `source-coq` lower a + closed Zig u8 fragment. The generated Coq theorem covers all 256 inputs. + Only the tiny closed fragment is covered; the general Zig subset is not. +* Finite-model replay (experimental): the generated Coq proof runs through + ECHIDNA `prove --output json`, an independent `coqchk` pass and a + no-axioms audit. The receipt status is always `INCOMPLETE`. Compiler, + refinement and full Dedukti/Coq/Lean4 chain arguments remain open. + * **Chain minting: a minted repo can be minted again.** "Use this template" on a minted repo now mints correctly (owner ruling 2026-11-04, after the Codex review of #251 showed the grandchild inherited its parent's identity). diff --git a/CITATION.cff b/CITATION.cff index 12a9ee72..69db5dfb 100644 --- a/CITATION.cff +++ b/CITATION.cff @@ -5,18 +5,7 @@ authors: given-names: "Jonathan D.A." website: "https://github.com/hyperpolymath" title: "Atoma" -abstract: >- - Atoma is a verification toolchain for Zig at the Idris2 ABI seam. It takes the - contract a repository already declares in Idris2 and the contract its Zig - export fn already documents, canonicalises both into one hash-checked Core - Spec IR, checks the implementation against a deliberately small verifiable - subset of Zig, and derives SMT verification conditions from the result. The - shape is Ada/SPARK or Rust/Creusot: one name for the subset, the contracts and - the toolchain. Witnesses are intended to be exported as canonical Dedukti and - rechecked by coqchk and lean4checker before any claim is promoted from - INCOMPLETE (Warrant) to COMPLETE (Receipt). Status: Phase 0/1 - the seam, - layout, subset and VC gates run and the soundness theorem typechecks for a - store-free core fragment; the kernel chain is specified, not yet run. +abstract: "Atoma is experimental, source-bound verification for an explicitly closed Zig subset. It provides canonical contracts, a syntax screen, typechecked Idris2 specifications, Agda proofs of a store-free model and a finite u8 source pilot. It is not yet a general sound verifier for Zig. Evidence remains INCOMPLETE (Warrant): finite-model replay runs through ECHIDNA and coqchk, while compiler and refinement arguments and the full kernel chain remain unfinished." version: "0.1.0" date-released: "2026-10-22" url: "https://github.com/hyperpolymath/atoma" diff --git a/docs/plan/FAMILY-ULTRAPLAN.adoc b/docs/plan/FAMILY-ULTRAPLAN.adoc new file mode 100644 index 00000000..6370081c --- /dev/null +++ b/docs/plan/FAMILY-ULTRAPLAN.adoc @@ -0,0 +1,326 @@ +// SPDX-License-Identifier: CC-BY-SA-4.0 +// SPDX-FileCopyrightText: 2026 Jonathan D.A. Jewell += Verifier family: shared plan to v1.0.0 +:revdate: 2026-11-15 +:toc: +:toclevels: 2 + +This plan covers six sibling verifier repositories. It holds the work that is +the same in more than one of them. Each repository keeps its own plan for the +work that only it can do, at `docs/plan/ULTRAPLAN.adoc`. + +[cols="1,1,3",options="header"] +|=== +| Repository | Target | Role in the family +| `atoma` | Zig | Pathfinder. It has the strongest evidence discipline today. +| `quintessence` | Elixir/OTP | Most code. Weakest evidence integrity today. +| `Apodeixis.jl` | Julia | Source-policy audit only. Clean tests. +| `bactrian` | OCaml, BEAM actors, FFI | Design documents and a readiness preflight. +| `canonry` | Agda theory for Chapel arrays | One checked theory module. +| `chancel` | Chapel front end (Rust) | Placeholder crate. +|=== + +This file lives in `atoma` because `docs/decisions/ATOMA-SIBLING-TRANSFER.adoc` +already makes `atoma` the first slice. The owner can move it. The repositories +stay separate. Nothing here merges them. + +== Status vocabulary + +A statement in this plan is *measured* only if a command ran on 2026-11-15 and +the result was seen. All other statements are *read* (from source) or *planned*. +Estimates are judgments. They are not measured velocity. + +== Measured state on 2026-11-15 + +Each row ran in one cloud session. Tool versions: Julia 1.12.1, Zig 0.15.2 and +0.17.1, Agda 2.6.3 with standard library 1.7.3, Z3 4.8.12, cvc5 1.1.2, Rust +stable. + +[cols="1,3,2",options="header"] +|=== +| Repository | Command and result | Not run +| `Apodeixis.jl` | `Pkg.test()`: 366 passed, 0 failed (347 before this session, plus 19 new). | Julia 1.9.4 leg. Idris2 and Zig scaffold. +| `atoma` | `zig build test`: 24 of 24 passed. `verification/atoma/check-agda.sh`: 4 modules, 0 postulates, 0 holes. | `scripts/atoma-gate.sh` (needs Z3 4.13.3, Idris2, ECHIDNA build). +| `quintessence` | `zig build test`: 10 of 10 passed. `tests/quintessence/run_suite.sh`: 14 passed, 2 failed. | Elixir front end. Suite with the solver versions that the README names. +| `bactrian` | `tests/bactrian/doctor_test.sh`: PASS. `scripts/bactrian/doctor.sh`: exit 2 (blocked, by design). | No product code exists to run. +| `canonry` | `scripts/check-proofs.sh agda`: 2 of 2 gated modules PASS under `agda --safe --without-K --cubical-compatible`. | Rocq and Lean legs do not exist. +| `chancel` | `cargo test --locked`: 2 passed. `cargo clippy -D warnings` and `cargo fmt --check`: clean. | No verifier code exists to run. +|=== + +== Aspect evaluation + +One row for each aspect. `ok` means measured and sound for the scope that the +repository claims. `gap` means a defect or a missing part. `none` means the +part does not exist yet. + +[cols="2,2,2,2,2,2,2",options="header"] +|=== +| Aspect | atoma | quintessence | Apodeixis.jl | bactrian | canonry | chancel +| Claims match code | ok | gap: fixed in README today; receipt format still overclaims | ok | ok after README repair | ok after README repair | ok after wording repair +| Soundness of results | ok for the u8 pilot; model proof only | gap: structural Alethe check, heuristic Layer C, fixed BMC model | gap closed today: deny-list held 7 bypasses | none | ok: 0 postulates | none +| Source to proof link | partial: one closed u8 function | gap: example-specific special cases | none | none | none: no Chapel link | none +| Independent replay | partial: ECHIDNA and coqchk, receipt INCOMPLETE | none: no ECHIDNA call | none | none | none: no Rocq or Lean leg | none +| Falsifiers | ok: 8 groups | partial: 16 cases, 2 fail off the pinned solvers | ok: tests fail without the fix | ok for the preflight | none | none +| Project CI gate | ok: `atoma.yml` | gap: no workflow runs the engine | ok: `julia.yml` | added today: `bactrian.yml` | added today: `canonry.yml` | ok: `rust-ci.yml` +| Reproducible toolchain | partial: pins, runner not frozen | gap: Zig 0.17 in code, 0.16.0 in `mise.lock`; solvers not pinned; NIF hash does not reproduce | partial: no `Manifest.toml`, `julia = "latest"` | gap: 8 authorities UNPINNED | partial: apt pins | ok: `Cargo.lock`, no dependencies +| Project benchmarks | none: template only | none: template only | none: template only | none | none | none +| Proof grade (theory) | ungraded: no receipt | none | none | none | `proven`, ungraded: no receipt | none +| Deed identity | set | set, no uuid | UNASSIGNED | UNASSIGNED | UNASSIGNED | UNASSIGNED +| Plan to v1 | yes | two plans that disagree | detailed, no v1 gate | detailed, no v1 gate | roadmap only | none +|=== + +== What is common and what is bespoke + +=== Common: do it one time, then apply it six times + +[cols="1,4,2",options="header"] +|=== +| ID | Work | Kind of sameness +| F1 | Template truth-up at the source (`rsr-template-repo`), then one sync of all six. Three template revisions are in use now. See the defect list below. | Identical files +| F2 | Deed identity fields: IS, IS-NOT, pipeline position, clade. Owner only. | Same form, different values +| F3 | Evidence kit: one receipt schema, one status vocabulary, one replay adapter, one falsifier harness. Start from `scripts/atoma-replay.sh` and `scripts/atoma-gate-falsifiers.sh`. | Same thing, change of name +| F4 | CI gate shape: `.yml`, `scripts/-gate.sh`, `scripts/-ci-toolchain.sh`, evidence artifact, required check. | Same thing, change of name +| F5 | Project benchmarks in the estate bench format. They replace `benches/template_bench.sh`. | Same harness, different workload +| F6 | One toolchain pin table for Zig, Z3, cvc5, Agda, Coq, Idris2 and ECHIDNA. | Identical values +| F7 | ECHIDNA client contract: `echidna prove --output json`, schema `echidna.prove.result/1`, one pinned ECHIDNA revision. | Identical adapter +| F8 | Zig seam. `atoma` checks the Zig code that `quintessence` (NIF) and `bactrian` (FFI) admit. | One provider, two consumers +| F9 | BEAM actor protocol layer. `quintessence` Layer B and `bactrian` Layer B use the same K-CUT rules, occupancy bound and upstream Agda authorities. | Same semantics, two front ends +| F10 | Coprocessor contract with ECHIDNA. See the section below. | One contract +| F11 | Proof Witness Grade recipe for theory: receipt for `PWG-3`, then a Rocq leg and a Lean leg. Applies to `canonry` and to the `atoma` Agda modules. | Same recipe +| F12 | Release engineering: changelog, citation, version tags, the standards V1-GATE audit. | Same checklist +|=== + +=== Bespoke: each repository must do it alone + +* The front end: parser or compiler adapter for the target language. +* The closed subset and its exclusions. +* The semantics: memory and aliasing (Zig), dispatch and numeric tiers (Julia), + actors and supervision (Elixir), modules and effects (OCaml), strided domains + and array loops (Chapel). +* The refinement argument from admitted source to the proved semantics. +* The pilots and the diagnostics for users of that language. + +`ATOMA-SIBLING-TRANSFER.adoc` forbids a shared semantic IR until two adapters +show the same meaning. This plan keeps that rule. + +=== Template defects found in more than one repository (input to F1) + +Fix each one in the template. Do not patch the six copies. + +* `docs/status/TEST-NEEDS.adoc` claims "CRG Grade C, achieved 2026-04-04" in + repositories born in October and November 2026. +* `docs/status/READINESS.adoc` ships unfilled `_<...>_` placeholders. +* `docs/status/PROOF-NEEDS.adoc` names a file on the owner's desktop. +* `docs/EXPLAINME.adoc` is titled "RSR Template Repo" in every child. +* `SUPPORT.adoc` uses Markdown syntax. +* `scripts/check-bench-regression.sh` names `benchmarks/`; the directory is `benches/`. +* `benches/template_bench.sh` measures template scripts in every child. +* `.gitignore` ignores `verification/proofs/agda/*.agdai` and misses nested modules. +* The deed carries `:last-updated "2026-04-11"`, before the birth date of the child. +* The deed sets `:port 0` and the mint answers set `:port "8080"`. +* `docs/decisions/` has two files numbered 0001. +* `pages.yml` runs `cabal build` in repositories with no cabal file. +* `rust-ci.yml` is green by no-op where no `Cargo.toml` exists. +* `docker-build.yml` triggers on `build/container/**` where that directory is absent. +* `sonar-project.properties` and `sonarqube.yml` keep an old project key. +* `Justfile` recipes `readiness`, `build-release` and `test-smoke` are TODO stubs that fail. +* The sample proofs under `verification/proofs/` say "Replace with your project's proofs" and stay gated. + +== Definition of v1.0.0 + +`atoma/docs/plan/ULTRAPLAN.adoc` defines seven conjunctive gates. Every +verifier in the family uses the same seven. Only the acceptance text changes. + +[cols="1,4",options="header"] +|=== +| Gate | Family rule +| Language boundary | A closed, typed subset with stated exclusions. An unsupported construct fails closed. +| Source connection | Obligations come from the body. A change to a body, an import or a target invalidates old evidence. +| Semantics | The semantic rules that the subset needs are proved, and the trusted computing base is published. +| Replay | A source-derived witness passes every kernel that the specification requires. Unknown, timeout, missing and malformed evidence fail closed. +| Practical coverage | Three pilots. A second consumer needs no special case. +| Assurance | Mutants are killed by gates that ran. Evidence is reproducible and bound to source. +| Release and estate | Claims, deed, README and installation are true. The standards V1-GATE audit passes. +|=== + +`canonry` is a theory library, not a verifier. Its v1 gates are in its own +plan. A repository can release `0.x` versions before it passes all gates. + +== Waves: how the six move forward together + +A wave closes when each repository has its exit evidence. A repository that +cannot close a wave narrows its subset. It does not skip the wave. + +[cols="1,3,3",options="header"] +|=== +| Wave | Shared work | Exit evidence in each repository +| W0 Truth and wiring | F1, F2, F4 (first half) | README is true. One project gate runs in CI. Each known hole is closed or is an open obligation in `PROOF-STATUS.adoc`. +| W1 Evidence spine | F3, F6, F7, F5 | The gate uses the evidence kit without a local fork. One benchmark has a baseline from a real run. +| W2 First source-bound obligation | none (bespoke front ends on the shared kit) | One closed function goes from source to obligation to ECHIDNA replay. One body-only mutant is rejected. Receipt status is INCOMPLETE. +| W3 Subset and semantics | F8, F9 | The checked argument covers the admitted subset. An alias, overflow or nontermination counterexample is rejected. +| W4 Kernel chain and grades | F7 (exchange), F10, F11 | End-to-end replay. Adversarial certificates fail. Theory theorems have receipts. +| W5 Pilots and release | F12 | All seven gates pass on the release commit. +|=== + +W0 is partly done (see "Done in the first session"). W2 is the first wave +that tests the transfer claim: measure time to a valid proof, time to reject a +body-only mutant, adapter size, and the count of kit components reused +unchanged. Re-estimate W3 to W5 from those numbers. + +== Models, effort and cost + +=== Roles + +[cols="1,3,3",options="header"] +|=== +| Model | Use it for | Do not use it for +| Fable (advisor) | Plan ratification. Wave gate review. Review of each claim promotion. Review of a cross-repository contract. | Execution. Routine review. +| Opus (lead) | Proof work. Semantics. Refinement arguments. Contract and schema design. Repair of a soundness hole. Review of Sonnet work on a trust path. | CI, template drift, status files (doctrine rule 16). +| Sonnet (executor) | Implementation against a written specification, 3 to 20 files. CI workflows. Adapters. Tests. README and status documents. | Design of a trust rule. +| Haiku (bulk) | Scout pass before each step. Mechanical edits. Template sync. Counts and stale-string sweeps. | Any edit that needs judgment about a claim. +|=== + +=== Orchestration rules + +. Opus leads one wave in one repository at a time. It writes the brief for each Sonnet or Haiku task. +. One writer for each repository tree at a time. Each brief names one allowed tree. +. A Haiku scout runs before each Sonnet or Opus step. It reports blockers in 20 lines or fewer. +. The advisor is called at four points only: plan ratification, the close of each wave, each promotion of a status word, and each change to a shared contract. The input is evidence files, not a narrative. +. A subagent never states that a check passed unless it ran the check. The lead reruns one check from each report. +. Work that touches a status word, a receipt, a trust level or a proof goes to Opus, with advisor review. +. Common work (F1 to F12) is done in one repository first. Sonnet or Haiku then replays it in the others from a replay brief. +. Shared code is extracted only after two repositories use the same thing. + +=== Effort scale + +`S` is one agent session. `M` is 2 to 4 sessions. `L` is 5 to 10 sessions. +`XL` is more than 10 sessions and must be split before it starts. Measured in +the first session: a recon of one repository used about 180,000 to 260,000 +tokens on Sonnet or Haiku. A polish task used about 160,000 to 180,000 tokens. + +[cols="1,4,1,1,1",options="header"] +|=== +| ID | Work | Lead | Workers | Size +| F1 | Template truth-up and one sync | Sonnet | Haiku | M +| F2 | Deed identity | Owner | Haiku to regenerate the arrival pack | S +| F3 | Evidence kit: schema, adapter, falsifier harness | Opus, advisor review | Sonnet | L +| F4 | CI gate shape in each repository | Sonnet | Haiku | M +| F5 | Benchmarks | Sonnet | Haiku | M +| F6 | Toolchain pin table | Sonnet | Haiku | S +| F7 | ECHIDNA client contract and exchange | Opus | Sonnet | L +| F8 | Zig seam through `atoma` | Opus | Sonnet | L +| F9 | Actor protocol layer | Opus, advisor review | Sonnet | XL +| F10 | Coprocessor contract | Opus, advisor review | Sonnet | M +| F11 | Proof Witness Grade recipe and legs | Opus | Sonnet for receipts | L +| F12 | Release engineering | Sonnet | Haiku | M +|=== + +The bespoke work is much larger than the shared work. The existing plans give +30 to 60 person-weeks for `atoma` and about 160 person-weeks for +`quintessence`. Those figures are the authors' judgments. This plan does not +shorten them. It removes repeated work and it orders the risk. + +== CI/CD design (F4, F5) + +Every repository has one project workflow with the same shape. `atoma.yml` is +the reference. + +. `actions/checkout`, no persisted credentials, read-only permissions. +. `scripts/-ci-toolchain.sh`: installs pinned tools and checks each digest. +. `scripts/-gate.sh`: one fail-closed entry point. A missing tool is a failure, not a skip. +. The gate runs unit tests, project proofs, falsifiers, then the benchmark. +. The evidence directory is uploaded even on failure. +. The job is a required check on `main`. +. After a workflow change, run `scripts/lock-sync-fix.sh`, then `scripts/check-lock-sync.sh`. Do not edit `actions.lock` by hand. + +[cols="1,2,3",options="header"] +|=== +| Repository | Gate today | Next step +| `atoma` | `atoma.yml`: full gate | Add the replay time and the mutant-rejection time as benchmarks. +| `Apodeixis.jl` | `julia.yml`: package tests on two Julia versions | Add audit throughput on a fixed corpus as a benchmark. +| `quintessence` | none | Add `quintessence.yml` with the Zig unit tests first. Add the suite only after the solvers are pinned and the NIF receipt reproduces. +| `bactrian` | `bactrian.yml`: preflight test | Flip the expected preflight status when WP-00 pins the authorities. +| `canonry` | `canonry.yml`: Agda proof gate | Add the receipt step (F11). +| `chancel` | `rust-ci.yml` | Add the subset-gate fixtures when the gate exists. +|=== + +A benchmark is valid only if its baseline comes from a recorded run on the +pinned toolchain. A benchmark gate compares against that baseline with the +estate script `scripts/check-bench-regression.sh`. + +== ECHIDNA coprocessor (F10) + +Question from the owner: are these repositories wired to the ECHIDNA +coprocessor layer and its Julia side, `src/julia/coprocessor.jl`, and can that +be done without friction? + +Answer: no repository in the family refers to the coprocessor. The wiring is +not possible without friction today. These are the facts, read from the +ECHIDNA source on 2026-11-15: + +* The Rust coprocessor layer has 16 kinds. The in-process backends are real code. +* No external entry point exists. The CLI, REST, gRPC and GraphQL interfaces have no coprocessor route. +* `coprocessor.jl` implements 6 `Math` operations. No recipe, container or Julia file starts it. Rust code never constructs the bridge. No round-trip test exists. +* The coprocessor default URL and the ML sidecar default URL both use port 8090. +* The wire format has no version field and no published schema. +* The trust tier of a coprocessor is defined. No code outside the module reads it. +* The ECHIDNA plan (decision D-G) defers the coprocessor trait "until a second consumer needs it". + +The verifier family is that second consumer. The path, in order: + +. The owner rules on D-G. +. ECHIDNA publishes a versioned contract, `echidna.coprocessor/1`, in the style of `PROVE-RESULT-CONTRACT.adoc`. +. ECHIDNA adds one entry point, for example `echidna coprocessor dispatch --output json`, and a capability probe. +. Trust rule: a coprocessor answer is a hint. It never raises a status word. A prover or an exhaustive check must confirm it. +. The Julia server gets its own port, a launcher and a round-trip test. + +First uses that pay for the work: + +* `canonry` and `chancel`: exact `gcd` and `lcm` for strided-domain alignment. Use them to search for counterexamples before a proof attempt. +* `Apodeixis.jl`: exact integer and rational cross-checks for the exact numeric tier. Interval arithmetic needs new operations. +* `atoma` and `quintessence`: evaluation of bit-vector counterexamples. + +Until the contract exists, each verifier calls ECHIDNA only through +`echidna prove --output json`. + +== Shared libraries + +[cols="2,1,3",options="header"] +|=== +| Candidate | Verdict | Reason +| Evidence kit (schema, replay adapter, falsifier harness) | Extract in W1 | It holds no language semantics. `ATOMA-SIBLING-TRANSFER.adoc` rates its reuse high. +| Canonical JSON and hashing | Use `hyperpolymath/ijson-jcs` | `atoma` (`canon.zig`) and `quintessence` (`jcs.zig`) each carry a private copy. +| SMT driver and Alethe check | Do not share the `quintessence` copy | Its Alethe check is structural. Use the ECHIDNA dispatch and certificate path (F7). +| Mutation engine | Use the ECHIDNA mutation planner | The `quintessence` engine is a local imitation with the ECHIDNA name. +| Finite arithmetic and linear resources in Agda (`Bv.agda`, `Lin.agda`) | Extract when a second repository needs them | The second-adopter rule. +| Shared semantic IR | Not yet | Forbidden until two adapters show the same meaning. +|=== + +The home of the evidence kit is an owner decision. The options are a new +small repository, a directory in ECHIDNA next to the prove contract, or a +directory that the template sync carries. + +== Enhancements that the lead recommends + +. Make `quintessence` consume `atoma` for Layer C. It replaces a pattern heuristic with a checked result, and it gives `atoma` its second consumer. +. Pair `canonry` and `chancel` under one wave schedule. `chancel` has no purpose until `canonry` M1 defines the obligation format. +. Put `bactrian` Layer B behind `quintessence` Layer B. Both need the same protocol rules. Build them one time. +. Record the reuse measures from `ATOMA-SIBLING-TRANSFER.adoc` in each W2 exit report. Decide the order of W3 from them. +. Give every repository the same plan path, `docs/plan/ULTRAPLAN.adoc`, and the same seven gates. An agent that learns one repository can then work in the others. +. Keep one page for each repository that lists the measured state with the date. Refresh it at each wave close. +. Unify the status words. `quintessence` uses `TrustLevel`. The estate grades theory with `PWG`. Receipts use INCOMPLETE and COMPLETE. The evidence kit must map them one time. + +== Done in the first session (2026-11-15) + +* `Apodeixis.jl`: the policy audit accepted `@ccall`, `unsafe_wrap`, `pointer_from_objref`, `include`, `llvmcall`, an alias of a forbidden call and `getfield(Base, :unsafe_load)`. It now rejects them. 19 new tests fail without the fix. +* `quintessence`: a `coqc` and a `lean` binary on PATH gave TrustLevel 5 with no check. The maximum is now 4. Suite case 16 fails without the fix. The README states the measured state and the limits. +* `canonry`: `canonry.yml` runs the Agda proof gate. The README describes the theory. +* `bactrian`: `bactrian.yml` runs the preflight test. The README describes the project. +* `chancel`, `atoma`: stale statements corrected. +* Each repository has a plan at `docs/plan/ULTRAPLAN.adoc`. + +== Stop points + +* If a W2 spike fails in a language, narrow the advertised subset or change the architecture. Do not add features. +* If the evidence kit needs a language-specific branch, stop F3 and review the schema with the advisor. +* If a status word would be promoted without a receipt, stop. A grade is derived from receipts. It is never asserted. diff --git a/docs/plan/ULTRAPLAN.adoc b/docs/plan/ULTRAPLAN.adoc index f895e4bd..f86b700a 100644 --- a/docs/plan/ULTRAPLAN.adoc +++ b/docs/plan/ULTRAPLAN.adoc @@ -157,3 +157,36 @@ the scaffold aspect script does not demonstrate coverage of these paths. Exercise sequences across aspects, not isolated checklists. Record reusable lessons in `docs/decisions/ATOMA-SIBLING-TRANSFER.adoc`; extract a shared engine only after a second language demonstrates the same semantic boundary. + +== Execution model and family links + +Added 2026-11-15. The stages, gates and task IDs above do not change. + +The work that Atoma shares with its sibling verifiers (`quintessence`, +`Apodeixis.jl`, `bactrian`, `canonry`, `chancel`) is in +link:FAMILY-ULTRAPLAN.adoc[the family plan]. That plan holds the shared work +packages F1 to F12, the waves W0 to W5, the model roles and the effort scale. +Atoma is the pathfinder: each shared package is done here first. + +Measured on 2026-11-15: `zig build test` in `tools/atoma` gave 24 of 24 passed +(Zig 0.15.2). `verification/atoma/check-agda.sh` gave 4 modules, 0 postulates +and 0 holes (Agda 2.6.3). `scripts/atoma-gate.sh` was not run in that session; +the hosted workflow is the evidence for it. + +[cols="1,2,1,1,3",options="header"] +|=== +| Stage | Family wave and packages | Lead | Size | Notes +| R0 | W0 | Sonnet | S | Done, apart from the inherited template drift (F1). +| R1 | W1 and W2: F3, F6, F7 | Opus | L | Extract the evidence kit from the replay scripts here. Then finish the alias counterexample and the typed boundary. +| R2 | W2 and W3 | Opus | XL (split first) | Tasks S1 to S6 and T6. Sonnet implements from Opus briefs. +| R3 | W3: F8 | Opus, advisor review | XL (split first) | Tasks T1 to T4 and T7. Proof work. `quintessence` and `bactrian` become consumers of the Zig seam. +| R4 | W4: F7 exchange, F11 | Opus | L | Tasks K1 to K9. The Agda modules get receipts, then the Rocq and Lean legs. +| R5 | W5: F12 | Opus for pilots; Sonnet for release | L | Tasks H1 to H6. +|=== + +Size `S` is one agent session, `M` is 2 to 4, `L` is 5 to 10, and `XL` is +more than 10 and must be split before it starts. Haiku runs the scout pass +before each step and does the mechanical edits. The advisor reviews the close +of each stage and each change to a status word. The person-week ranges in the +sequence table above stay the planning basis; the sizes here only order the +agent work. diff --git a/sonar-project.properties b/sonar-project.properties index d4d82818..8b28f9b9 100644 --- a/sonar-project.properties +++ b/sonar-project.properties @@ -1,9 +1,9 @@ # SPDX-License-Identifier: MPL-2.0 # SonarQube Cloud (SonarCloud) configuration. -# Project: https://sonarcloud.io/project/overview?id=hyperpolymath_zigprove +# Project: https://sonarcloud.io/project/overview?id=hyperpolymath_atoma # Requires the SONAR_TOKEN repository secret + a SonarCloud project (owner setup). sonar.organization=hyperpolymath -sonar.projectKey=hyperpolymath_zigprove +sonar.projectKey=hyperpolymath_atoma # Analysable surface = shell scripts + any JS/TS the template carries. Idris2, # Zig, Elixir and AffineScript have no SonarCloud analyser; vendored, generated,