From b4934249eedd37b4ef6c85dc9e32372dd8fe13a6 Mon Sep 17 00:00:00 2001 From: "Jonathan D.A. Jewell" <6759885+hyperpolymath@users.noreply.github.com> Date: Sun, 15 Nov 2026 15:05:23 +0000 Subject: [PATCH] docs(architecture): reconcile Scaffoldia with deed-era spine contracts Record the observed design-phase baseline, current ownership boundaries, composer/retrofit acceptance gates, and proposed engine ADR without claiming implementation or CI success. --- .machine_readable/descriptiles/STATE.a2ml | 22 +-- README.adoc | 29 ++-- docs/architecture/TOPOLOGY.adoc | 111 +++++++++++--- ...0002-scaffoldia-composer-architecture.adoc | 141 ++++++++++++++++++ docs/status/ROADMAP.adoc | 67 +++++++-- 5 files changed, 314 insertions(+), 56 deletions(-) create mode 100644 docs/decisions/0002-scaffoldia-composer-architecture.adoc diff --git a/.machine_readable/descriptiles/STATE.a2ml b/.machine_readable/descriptiles/STATE.a2ml index a83aa54..377594b 100644 --- a/.machine_readable/descriptiles/STATE.a2ml +++ b/.machine_readable/descriptiles/STATE.a2ml @@ -8,12 +8,12 @@ [metadata] project = "scaffoldia" version = "0.1.0" -last-updated = "2026-07-21" +last-updated = "2026-11-15" status = "active" # active | paused | archived [project-context] name = "scaffoldia" -purpose = "Full-featured repository designer for the RSR estate: composes spine@pin x variant pack x features x profile into new repos, and retrofits existing ones (owner mandate 2026-07-07: composer + retrofit from day one). Sits above rsr-template-repo (`just init`, basic) in the scaffolding stack; consumes variant contracts (VARIANT.a2ml, ADR-0002 in rsr-template-repo) as data." +purpose = "Full-featured repository designer for the RSR estate: composes spine@pin x archetype/pack x features x capability profile into new repos and retrofits existing ones. Must consume the spine current deed-based archetype, variant, provenance and mint-answer contracts (rsr-template-repo ADR-0002/0003, partly superseded 2026-10-06); cannot invent a second format." completion-percentage = 5 [position] @@ -23,30 +23,32 @@ maturity = "experimental" # experimental | alpha | beta | production | lts [route-to-mvp] milestones = [ { name = "Phase 0: RSR shell extracted from reposystem (2026-06-26), identity + hygiene", completion = 90 }, - { name = "Phase 1: composer design ADR (compose spine@pin x pack x features x profile)", completion = 0 }, - { name = "Phase 2: consume VARIANT.a2ml contracts as pack definitions (julia = first pack)", completion = 0 }, + { name = "Phase 1: proposed composer design ADR; decision and review outstanding", completion = 0 }, + { name = "Phase 2: parse spine praxis deeds, repo deed clauses, overlays and capability profile; julia-library first", completion = 0 }, { name = "Phase 3: retrofit engine (pack-diff against existing repos)", completion = 0 }, { name = "Phase 4: template-maintenance sync loop (regenerate rsr-*-template-repo family until cut-off)", completion = 0 }, ] [blockers-and-issues] issues = [ - "Composer design ADR pending — MUST explicitly weigh the dormant GitLab-lineage implementation (developer-ecosystem/scaffoldia: Haskell CLI + Nickel builder), not ignore it; fork resolved 2026-07-21: this repo is canonical, engine dormant, registry harvested (machine-readable-design/harvested-registry/)", + "Composer ADR-0002 proposed, not accepted: must compare dormant Haskell/Nickel, Rust core, and ABI/FFI options against working evidence; canonical repo is here, historical registry harvested as untrusted source data", + "Current source tree has no core composer, mint planner, retrofit engine or working cross-language ABI; CI and local validators contain stale template assumptions", + "Current canonical contract is deed-based; old VARIANT.a2ml / ARCHETYPE.a2ml references are superseded in part by rsr-template-repo ADR-0002/0003 (2026-10-06)", "repo-batcher absorption (reposystem#56 V->Zig port) undecided — revisit after composer v0.1", ] [critical-next-actions] actions = [ - "Author composer design ADR (consume VARIANT.a2ml/ARCHETYPE.a2ml; weigh dormant Haskell+Nickel engine; two distribution paths stay coherent)", - "Define pack format derived from the spine contracts (rsr-template-repo archetypes/ per ADR-0003 + rsr-julia-library-template-repo VARIANT.a2ml = references; harvested-registry entries = input data)", - "Decide src/ pillar implementation approach (current Idris2+Zig ABI seam is inherited scaffold)", + "Review ADR-0002 against current standards and spine; select engine via working spike without creating a competing contract schema", + "Implement pinned-source and deed/archetype readers, deterministic plan and dry-run, then mint and retrofit using one planner", + "Reconcile validation/CI failures; prove any retained Idris2-Zig ABI using real linked symbol and behaviour tests, or retire unused seam", ] [fork-resolution] # Two scaffoldia codebases existed with no recorded relationship. Resolved # 2026-07-21 (see machine-readable-design/harvested-registry/README.adoc): decision = "this repo = canonical design surface + consumer of spine contracts; developer-ecosystem/scaffoldia (GitLab lineage, implemented Haskell CLI + Nickel builder) = dormant engine, registry harvested as data, no parallel development" -profile-axis = "resolved: profile = capability set per standards template-capability-gates.toml (preset or direct list), i.e. what rsr-profile.a2ml declares (ADR-0003)" +profile-axis = "capability set from metadatastician/standards .machine_readable/template-capability-gates.toml; written as (rsr-profile) in the repository deed by current spine repo-init" [maintenance-status] last-run-utc = "never" @@ -57,4 +59,4 @@ open-failures = 0 [ecosystem] part-of = ["RSR Framework", "scaffolding stack (standards -> rsr-template-repo -> scaffoldia)"] -depends-on = ["rsr-template-repo", "standards"] +depends-on = ["hyperpolymath/rsr-template-repo", "metadatastician/standards"] diff --git a/README.adoc b/README.adoc index 249ca43..4da1603 100644 --- a/README.adoc +++ b/README.adoc @@ -15,25 +15,30 @@ repositories, and retrofits existing ones. [NOTE] ==== -*Status: design phase.* This repository currently carries the RSR substrate -(governance, CI, machine-readable metadata) and the design surface for the -composer; the composition engine itself is not built yet. See -`.machine_readable/descriptiles/STATE.a2ml` for the honest state. +*Status: design phase; composition and retrofit are not implemented.* The +inherited RSR governance, CI and Idris2/Zig interface scaffold are not a +working repository designer. The present architecture and blockers are tracked +in `docs/architecture/TOPOLOGY.adoc`, `docs/status/ROADMAP.adoc`, and +`.machine_readable/descriptiles/STATE.a2ml`. The composer design is a +*proposal*, not an accepted engine decision (ADR-0002). ==== == What this is Scaffoldia is the top layer of the estate's scaffolding stack: - standards → rsr-template-repo → scaffoldia → (designed/retrofitted repos) + metadatastician/standards → rsr-template-repo → scaffoldia → (designed/retrofitted repos) `standards` defines the RSR canon; `rsr-template-repo` operationalises it as a GitHub template with a basic `just init` scaffolder; *scaffoldia* is the full-featured designer that treats variation as data. It consumes each variant -template's *variant contract* (`VARIANT.a2ml` — parent pin + declared path -divergences; see ADR-0002 in rsr-template-repo and the reference -implementation in `rsr-julia-library-template-repo`) so that GitHub's -"Use this template" path and the composed path can never silently diverge. +template's current *deed contracts*: archetype `*_praxis.deed` files, +overlays and the `(variant)`, `(provenance)`, `(rsr-profile)` and +`(mint-answers)` clauses of a repository `*_chora.deed`. Earlier standalone +`VARIANT.a2ml`/`ARCHETYPE.a2ml` descriptions were superseded in part by +rsr-template-repo ADR-0002/0003 on 2026-10-06. Both the template mint and +Scaffoldia must use the same upstream contract semantics, with replayable +mint answers and drift checks; no parallel schema. Mandated scope (owner, 2026-07-07): *composer + retrofit from day one* — the same pack-diff machinery that composes new repos re-synchronises existing @@ -55,8 +60,10 @@ just validate # structure + metadata checks (RSR shape) in a2ml, so tools and agents can read the project's state and boundaries. * *AI gatekeeper protocol* — `0-AI-MANIFEST.a2ml` is the universal entry point that tells an AI agent how to work in this repo before it touches anything. -* *Typed ABI/FFI seam* — `src/interface/Abi/` (Idris2 type + layout proofs) over - `src/interface/ffi/` (Zig implementation), with generated C headers. +* *Inherited ABI/FFI scaffold* — `src/interface/Abi/` (Idris2) and + `src/interface/ffi/` (Zig). Their symbol names, return codes and pointer + semantics currently disagree; compilation of each side does *not* establish + cross-language conformance. Do not use the seam for composition yet. * *CI/CD* — GitHub Actions for quality, security (CodeQL, Scorecard, secret scanning), multi-forge mirroring, and RSR anti-pattern enforcement. * *Supply-chain & reproducibility* — container layering (stapeln), Nix/Guix shells, diff --git a/docs/architecture/TOPOLOGY.adoc b/docs/architecture/TOPOLOGY.adoc index f07df1e..b6fd919 100644 --- a/docs/architecture/TOPOLOGY.adoc +++ b/docs/architecture/TOPOLOGY.adoc @@ -1,36 +1,107 @@ // SPDX-License-Identifier: CC-BY-SA-4.0 -// Copyright (c) Jonathan D.A. Jewell -// Last updated: 2026-04-04 -= Architecture Topology += Scaffoldia Architecture Topology +:toc: +:sectnums: -== System Overview +== Verified baseline (2026-11-15) -RSR (Rhodium Standard Repository) template provides the canonical scaffold for all hyperpolymath projects, with integrated CI/CD, documentation, and service discovery patterns. +Inspection base: `hyperpolymath/scaffoldia` main commit +`84e13a6e8b41e12026f2a5cbbd97fb91fc3fa849`. +This describes observed source, not a completed runtime. +`.machine_readable/descriptiles/STATE.a2ml` records 5% completion and design phase. -== Component Overview +== Ownership boundaries -[cols="1,1,2", options="header"] +[cols="1,2,3",options="header"] |=== -| Component | Language | Purpose +| Layer | Repository | Authority / output -| dogfood-gate workflow | YAML | Quality checks (CRG, security, linting) -| eclexiaiser-validate job | YAML | Resource cost awareness scoring -| Groove discovery | JSON | Service endpoint registration +| Canon | `metadatastician/standards` | RSR criteria, format rules, template-capability-gates.toml, scaffold lifecycle +| Spine | `hyperpolymath/rsr-template-repo` | `repo-init`, pinned base tree, `archetypes//_praxis.deed`, overlays, lock fragments, deed clauses +| Composer | `hyperpolymath/scaffoldia` | Future deterministic composition, dry-run mint and retrofit plans, apply and reconciliation receipts +| Oracle | `hyperpolymath/hypatia` | Conformance scoring; Scaffoldia must not redefine scoring +| Sustain | `hyperpolymath/gitbot-fleet` and `hyperpolymath/reposystem` | Audit-first corrective campaigns and owner-gated application |=== -== Data Flow +The normative lifecycle is `metadatastician/standards/0-canon/rsr/SCAFFOLD-LIFECYCLE.adoc` +and the spine's accepted ADR-0002/0003. The upstream ADRs were amended +2026-10-06: standalone `VARIANT.a2ml` and `ARCHETYPE.a2ml` files are +superseded by `*_chora.deed` clauses and archetype `*_praxis.deed`. +Scaffoldia consumes these schemas; it does not fork their definitions. +== Present repository components (not a composer) + +[cols="2,3,2",options="header"] +|=== +| Path | Present code/data | Status + +| `src/core`, `src/contracts`, `src/bridges`, `src/definitions`, `src/errors` | AI manifests/READMEs only | No composition engine +| `machine-readable-design/harvested-registry` | Seven legacy Nickel registry inputs | Data only; not live packs +| `src/interface/Abi/` | Generic Idris2 foreign declarations and type/layout model | Not matched to Zig exports +| `src/interface/ffi/` | Zig exported scaffold functions and unit/integration tests | No composer operations; Zig-side tests only +| `verification/proofs/` | Example/skeleton proof artifacts | No linked composer assurance +| `tests/` | Shell E2E, aspect, workflow tests | No actual mint/retrofit acceptance test +| `.github/workflows/` | 25 YAML workflows, actions.lock | Multiple pre-existing CI failures +| `.machine_readable/`, `build/`, `Justfile` | RSR substrate and task recipes | Some checks refer to removed/moved paths +|=== + +The `developer-ecosystem/scaffoldia` historical Haskell CLI + Nickel +builder is dormant, not an alternate implementation authority. Its CLI +`init` and `build` paths do not invoke the actual composer; the registry +is suitable for reviewed harvesting only. + +== Required operational seams (proposed) + +[source,text] ---- -[Code Push] → [GitHub Actions] → [hypatia scan] → [eclexiaiser validate] → [Results] +Canon (version + gates) ------. +Spine (pin + deeds + overlays) +--> validated SourceSnapshot +Identity + capability request -' | + CompositionPlan + / deterministic / dry-run + / \ + Mint adapter Retrofit adapter + \ / + Reconciliation/ExecutionReceipt + | + provenance + Hypatia + fleet proposal ---- -== Integration Points +* Ingest: pinned canon/spine snapshots, exact deed contracts and overlays; + reject unknown capability, unpinned inputs and invalid paths. +* Plan: deterministic ordering; detect duplicate and overlapping path claims; + emit explicit conflicts; never silent last-writer-wins. +* Apply: sandboxed file staging, no remote mutation by default; authorisation + required for real repository modification and all forge configuration. +* Reconcile: compare pinned base, current child, and desired child; preserve + unrelated user edits; report conflicts rather than overwrite. +* Observe: test/build/hypatia/drift evidence and outcome receipts. A skipped + or absent check cannot be reported as passing. + +These are interfaces to implement, not capabilities claimed present. + +== ABI/FFI blocker + +`src/interface/Abi/Foreign.idr` imports C symbols `rsr_init`, +`rsr_free`, `rsr_process`; Zig exports `scaffoldia_init`, +`scaffoldia_free`, `scaffoldia_process`. Their result semantics differ. +The Idris2 platform model is a simplified 64-bit template, including +inapplicable generalisations. The Zig integration tests import Zig directly; +they do not link Idris2 calls through the C ABI. The interface is therefore +not verified and must not be called 'proven' before an end-to-end link test. +ADR-0002 leaves retention/retirement of this optional seam open. -* *Upstream*: Hypatia (neurosymbolic CI/CD), eclexiaiser (resource scoring) -* *Downstream*: All RSR-based repositories (500+ instances) +== Existing CI debt (observed on base commit) -== Deployment +* Well-known enforcement ignores existing `www/.well-known/security.txt`. +* Workflow linter's first-line SPDX check rejects managed lockfile headers, + then its literal SHA-only rule conflicts with actions.lock's tag-to-SHA map. +* Static analysis gate produced startup_failure; investigate workflow + permissions, allowlist and pinned reusable workflows separately. +* Some reusables still refer to `hyperpolymath/standards` while the live + canon is `metadatastician/standards`. +* The `e2e.yml` job invokes a script requiring Idris2 and Zig without + explicit toolchain provisioning. -* Container: Stapeln Six ecosystem -* CI/CD: GitHub Actions → Hypatia scan → eclexiaiser-validate (6 scorecard dimensions) → Mirror -* Service Discovery: Groove protocol (.well-known/groove/manifest.json) +Do not suppress failures to create a green summary. Fix at the owning layer +and verify the first real passing and deliberately failing checks. diff --git a/docs/decisions/0002-scaffoldia-composer-architecture.adoc b/docs/decisions/0002-scaffoldia-composer-architecture.adoc new file mode 100644 index 0000000..825fe1b --- /dev/null +++ b/docs/decisions/0002-scaffoldia-composer-architecture.adoc @@ -0,0 +1,141 @@ +// SPDX-License-Identifier: CC-BY-SA-4.0 += ADR-0002: Scaffoldia Composer and Retrofit Architecture (proposed) +:toc: +:sectnums: + +*Status:* Proposed — requires review against live standards and spine. +*Date:* 2026-11-15 +*Scope:* Compose and retrofit from the first usable vertical slice; not +a commitment to any implementation language or binary ABI today. + +== Context and hard boundaries + +Scaffoldia is the design surface for `standards -> rsr-template-repo -> +scaffoldia -> (estate repos)` and was mandated on 2026-07-07 to support +both new repository composition and retrofit, not mint first and retrofit +indefinitely deferred. Its active repository presently contains an RSR +shell, generic Idris2/Zig interface scaffold, and harvested registry data, +but no composition engine. The historical +`developer-ecosystem/scaffoldia` code contains Haskell CLI parsing, +a Nickel merge library and MiniKanren constraints; the Haskell `init` +and `build` operations do not invoke a real renderer. It must not be +treated as production implementation. + +Upstream contracts changed on 2026-10-06 (rsr-template-repo ADR-0002/0003). +`*_chora.deed` with `(variant)`, `(provenance)`, `(rsr-profile)` +and `(mint-answers)`, plus `archetypes//_praxis.deed`, +overlays, `prune.txt` and `actions.lock` fragments, replace the +legacy standalone `VARIANT.a2ml`/`ARCHETYPE.a2ml` contracts. +`metadatastician/standards` defines capability gates; the spine defines +template mechanics. No Scaffoldia-specific alternative public grammar. + +Normative lifecycle: `metadatastician/standards/0-canon/rsr/SCAFFOLD-LIFECYCLE.adoc` +(Mint, Provision, Configure, Harness; then corrective, adaptive, +perfective, preventive sustain). Reuse Hypatia for conformance measurement, +not a forked score; use reposystem/gitbot-fleet for owner-approved campaigns. + +== Proposed data flow (not yet implemented) + +. Resolve immutable source snapshot(s): canon version, spine commit and + archetype praxis deed; reject missing/ambiguous pins. +. Validate requested capabilities against the canonical gate table; + read existing profile/variant/answers from the target repo's native deed. +. Create `CompositionPlan` from spine, one archetype, declared features, + identity and profile: sorted path actions, provenance, conflicts and + required toolchains. Never accept silent last-writer-wins. +. For mint, compare desired state against an empty/staged target. +. For retrofit, perform a three-way comparison: pinned base, working + target and desired pinned successor. Preserve user changes, classify + intentional divergence, fail closed on conflicts. +. Dry-run by default. Apply only to approved local target staging; no + forge identity, visibility, branch-protection or fan-out changes + without an explicit owner approval step. +. Emit provenance and mint answers using the spine's existing deed writer, + then validate with its drift check, real build/test and Hypatia oracle. +. Emit an `ExecutionReceipt` of file operations, skipped checks, failure + evidence and recovery information. A plan/receipt is internal engine + output, NOT a new normative RSR document format. + +Proposed internal types: +`SourceSnapshot`, `RepositorySpecification`, `CompositionPlan`, +`ReconciliationPlan`, `ExecutionReceipt`. Each type needs an explicit +schema and compatibility version *internal* to Scaffoldia before use. + +== Engine selection — open decision + +[cols="2,2,3",options="header"] +|=== +| Candidate | Existing evidence | Decision risk / spike required + +| Adapt dormant Haskell CLI + Nickel builder | Parser and merge helpers +exist, Haskell is expressly permitted for Scaffoldia by the current +language policy | CLI build/init are not connected; merging overwrites +conflicting paths; legacy language/license defaults and untested registry +must be corrected; prove working deed ingestion and replay +| Rust core with verified contracts | Fits deterministic filesystem +planning, constrained write operations and Creusot/Pearlite + Verus +direction | New implementation cost; proof plan and parser reuse required; +prove minimal deed input -> deterministic dry-run with no duplicate grammar +| Idris2/Zig as engine boundary | Generic code and Zig tests inherited +from RSR template | FFI symbols/result codes already mismatch; native ABI +need is unproven. Avoid committing to this seam until linked cross-language +consumer test demonstrates necessity and safety +|=== + +Selection gate: implement equal-scope minimal spikes, measure correctness, +maintenance cost, language-policy compliance, typed-contract faithfulness +and testability. Document why the selected option wins before merging +composer code. Archived ReScript and stale registry defaults cannot +silently become eligible templates. Do not auto-edit license/SPDX data. + +== Interfaces and ownership + +[cols="1,3,2",options="header"] +|=== +| Interface | Required behaviour | Owner/authority + +| CanonReader | Versioned criteria and capability vocabulary | standards +| SpineReader | Pin, praxis deed, overlays, prune and action locks | rsr-template-repo +| PlanEngine | Deterministic file plan and conflicts | scaffoldia +| Mint / Retrofit | One planner, two base-state adapters | scaffoldia +| ForgeConfig | Explicit out-of-band, operator-approved settings | forge/operator +| Conformance | Scorable profile, actual tests and report | hypatia + build tools +| Drift | Replayable mint and pinned-parent comparison | spine check scripts +| Sustain | Reviewable audit-first remediation, never silent fan-out | fleet/reposystem +| Trust | k9/deed validation and scope of permissions | standards/k9 tooling +|=== + +== Safety invariants + +* No filesystem traversal, path alias/case collision, symlink escape, + outside-root writes, or overwriting target files without a plan. +* Source snapshots and provenance are pinned, never inferred from latest + on replay; unknown source/schema/capability is a hard diagnostic. +* Same pinned inputs yield byte-equivalent planned artifacts; applying a + completed plan twice is idempotent. +* A child preserves a unique identity; template self-name and parent + references must not be conflated. +* Workflow lock fragments merge by action identity and reject conflicting + hashes; no gate should be green after a skipped required tool. +* Auth/forge mutations are not implicit side effects; license and + attribution changes are flag-only, requiring owner review. +* Proof obligations and limitations are explicit: Zig-side tests alone + do not validate an Idris2 -> C -> Zig ABI. + +== Acceptance evidence for first vertical slice + +A disposable Julia library minted from the pinned spine's +`julia-library` praxis deed must build/test, carry correct native deed +clauses and replay without drift. A second Rust CLI fixture must check +archetype diversity. A deliberately modified existing repo must yield +a non-destructive retrofit plan and an explicit conflict. Negative tests +must include bad pin, unknown capability, path traversal, conflicting +lock entry, missing toolchain and non-idempotent application attempt. +No M0 assertion until those tests pass on the PR head. + +== Decision follow-up + +This ADR is *proposed*. Next scoped PR: implement read-only source/contract +resolution and compare Haskell/Nickel reuse against a minimal Rust planning +spike, without modifying live repositories. No release, merge or promotion +is implied by accepting this document. diff --git a/docs/status/ROADMAP.adoc b/docs/status/ROADMAP.adoc index bafe0ce..9b6c73f 100644 --- a/docs/status/ROADMAP.adoc +++ b/docs/status/ROADMAP.adoc @@ -1,23 +1,60 @@ // SPDX-License-Identifier: CC-BY-SA-4.0 -// Copyright (c) Jonathan D.A. Jewell -= YOUR Template Repo Roadmap += Scaffoldia Delivery Roadmap +:toc: +:sectnums: -== Current Status +== Current status (2026-11-15) -Initial development phase. +Design phase, CRG X (unproven composer). The RSR repository substrate is +substantial; composer, mint planner, retrofit planner and template-sync loop +are not implemented. No release or completion claim follows from inherited +Zig tests or passing isolated workflows. -== Milestones +== P0 — Corrective architecture/contract reconciliation -=== v0.1.0 - Foundation -* [ ] Core functionality -* [ ] Basic documentation -* [ ] CI/CD pipeline +* [ ] Review proposed ADR-0002 and ratify implementation strategy using a + running comparison of historical Haskell/Nickel and a minimal Rust spike. +* [ ] Replace obsolete standalone `VARIANT.a2ml`/`ARCHETYPE.a2ml` + assumptions with the canonical deed clauses and praxis deeds; do not + invent new public contract formats. +* [ ] Inventory and reconcile stale validation gates, CI workflow headers, + Actions locks, reusable workflow references and well-known paths. +* [ ] Decide whether Idris2/Zig ABI is necessary for the composer; if retained, + test actual cross-language linking and repair signature/result/platform mismatches. +* [ ] Do not claim CI green until all required latest-commit checks execute + successfully and review threads are resolved. -=== v1.0.0 - Stable Release -* [ ] Full feature set -* [ ] Comprehensive tests -* [ ] Production ready +== M0 — Complete scaffold with live interfaces -== Future Directions +* [ ] Parse pinned canon/spine and archetype praxis deeds, overlay/prune and + `actions.lock` fragments; reject invalid/unknown inputs. +* [ ] Build a deterministic file-level `CompositionPlan` with collision, + path-traversal, license-policy and capability checks. +* [ ] Implement dry-run mint with actual Julia-library archetype (first + vertical slice) and an independently demonstrated Rust-CLI archetype. +* [ ] Implement dry-run three-way retrofit against pinned parent; preserve + unrelated changes and stop on conflicts. +* [ ] Emit native deed clauses (profile, variant, provenance, mint-answers) + and verify replayable mint drift via the existing spine mechanisms. +* [ ] Make the forge/configure step explicitly operator-approved; no hidden + repo rename, visibility or protection mutation. +* [ ] Attach build/test, Hypatia scoring, drift and signed/typed evidence + receipts; skips remain reported as skips. +* [ ] Prove idempotence, deterministic replay, negative-case enforcement and + same-input repeatability in CI. -_To be determined based on community feedback._ +== M1 — Sustain loop (after M0) + +* [ ] Regenerate template variants as declared artifacts, compare with + hand-maintained reference, and record upstream promotion candidates. +* [ ] Send audit-first proposals to reposystem and gitbot-fleet; fan-out + changes require owner approval and scoped PRs. +* [ ] Integrate tests/assurance without replacing proven-tests-and-benches, + Hypatia or the standard's normative checker. + +== Non-goals + +Do not redefine the canon, install a second RSR profile grammar, report +template boilerplate as implemented engine capability, auto-edit licenses +or SPDX attribution, bypass branch protections, or merge without current +review and real CI evidence.