wave: CM0 — a CM must compile before it may measure (compiler + prereg/judgment schemas + admissibility report)

[usurobor]

Filing role: κ (Herald) — records operator design intent (2026-07-06) as typed input. Master tracker for the CM0-compiler wave.
Dispatch config: to be set at launch (.cdd/DISPATCH §5.2 single-session δ-as-γ, or multi-session) — not yet dispatched. This issue prepares the wave; launch is an operator gate.
Engineering level (target): L7 — System-Shaping Leverage (per .cdd/skills/cds/CDS.md §Assessment). This introduces a new admissibility layer (the CM compiler) that reshapes how TSC admits any instrument; a genuine boundary move, not a local fix. Score-the-release-not-the-intent applies — the level is earned by what ships.
Mode: explore → design-and-build. The design below is strong operator intent but is not yet committed at a stable DESIGN.md/CM0.md path — so this is not MCA. Sub-1/Sub-2 produce the canonical source-of-truth artifacts; Sub-3+ become MCA against them once committed.

The invariant (operator, verbatim)

A CM may express human values, but it must compile before it may measure.
Compile means: its parts exist, its parts fit, its evolution rules are honest, its preregs are executable, its semantic judgments are bounded, its consistency is measured, and its report tells a human what to clarify when witnesses disagree.

Human supplies salience → CM encodes salience → Prereg freezes a proposed test → CM0 checks whether the whole thing hangs together → TSC refuses inconsistent instruments.

Treat a CM like human-written code for measurement: creative, opinionated, domain-specific — but it must pass a compiler before TSC executes it as an instrument. CM0 is the pristine reference CM: the methodology that defines how CMs are written, checked, reported, and admitted, and simultaneously the compiler that admits (or rejects) candidate CMs.

Problem

What exists: A mature CM0 already ships — skills/cm-of-cms/SKILL.md (29 KB) declares the triad-against-an-instrument (§1), the consistency protocol (§3), the mechanical/LLM split (§4), the self-application fixed point (§5), and the adversarial-CM / admissibility / held-out / registration doctrine (§6), backed by executable instruments (scripts/cm-consistency.sh, scripts/cm-admissibility.sh, scripts/cm-heldout.sh) and the comparable contract schemas/skill.cue #CoherenceMethodology.

What is expected: CM0 as an actual compiler: a candidate CM is parsed → typechecked → linked → factorization-checked → consistency/discrimination-defined → standing-checked → report-checked before it may execute, with (a) a required-parts contract, (b) preregs and semantic judgment-calls as first-class typed compile objects, and (c) a report that tells a human what to clarify when witnesses disagree. CM0 itself rewritten in that grammar as the exemplar.

Where they diverge: Today CM0's admissibility is a set of prose sections + attacker scripts, not a staged compiler over a typed CM document; there is no coh cm-compile, no prereg schema (schemas/prereg.cue), no bounded per-call judgment schema generalized beyond the β witness, and no CM0-authored-in-its-own-H1/H2-form exemplar. Preregs (e.g. factorized-β rev-4) live as prose, not as objects a compiler can typecheck against the CM's declared axes/evidence/gates.

Impact

Every instrument TSC runs — the 1st methodology (methodology/self-measure), the factorized-β route, any future or adversarial CM — currently gains standing by convention and scattered checks. Without a compiler, "does this CM cohere as an instrument?" has no single mechanical gate, and prereg quality (does the gate actually test the axis it claims? can it be gamed?) is unenforced. This wave is the structural home for the #76 finding: it turns "witnesses disagree on an under-specified predicate" into a reported compile/standing signal (predicate under-specified → clarify or mark no-standing) rather than a silent scalar wobble.

Status truth (no overclaiming)

• CM0 exists and is rich (skills/cm-of-cms/SKILL.md); this wave restructures and mechanizes it — it does not create it.
• The comparable contract partially exists (schemas/skill.cue #CoherenceMethodology / #CMOfCMs); schemas/cm.cue and schemas/prereg.cue are new/extending, not from zero.
• coh cm-compile does not exist; the coh binary today exposes factorized-beta-*, katas, mechanical/hybrid/llm modes — no compiler subcommand.
• The "uploaded visual report" the design references is an external artifact not in the repo; its grammar must be vendored/pinned by the report sub or it is a source-drift risk.
• The bounded-judgment idea is partially realized in engine/ocaml/lib/factorized_beta.{ml,mli} (the β route) — the wave generalizes it into a per-call schema for arbitrary CMs.

Source of truth

Claim / surface	Canonical source	Status	Notes
Existing CM0 methodology	skills/cm-of-cms/SKILL.md	Shipped	To be restructured into H1/H2 compiler grammar
Comparable contract	schemas/skill.cue (#CoherenceMethodology)	Shipped	schemas/cm.cue extends/supersedes — Sub-1
Registry / measurable CMs	targets/registry.tsc, targets/{methodology,cm-of-cms}.tsc	Shipped	Sub-5 candidate corpus
β bounded adjudication (precedent)	engine/ocaml/lib/factorized_beta.{ml,mli}	Shipped (0.12.0)	Judgment-call schema generalizes this
Factorized-β prereg (to be typed)	docs/beta/governance/CONSISTENCY-FACTORIZATION-PREREG.md	Shipped (terminal FAIL)	Becomes a prereg.cue conformance fixture
Meter-loop stop rule	docs/beta/governance/METER-LOOP-DECISION.md	Shipped	This wave must not reopen it (see non-goals)
A3 disagreement request	docs/beta/governance/A3-DISAGREEMENT-REQUEST.md	Shipped	The predicate-underspecification finding CM0 operationalizes
CM0 document (new canonical)	docs/beta/governance/CM0.md	Does not exist	Sub-1 creates as source of truth

Scope

In scope:

• CM0 restated as a typed document with required α — Parts / β — Fit / γ — Evolve H1 sections and measurable H2 clauses; CM0 rewritten in its own grammar as the exemplar.
• schemas/cm.cue (CM document contract) + schemas/prereg.cue (prereg as a first-class compile object) + a bounded LLM/human judgment-call schema.
• coh cm-compile <cm.md> implementing the compiler stages (parse → typecheck → link → factorization → consistency-defined → discrimination-defined → standing → report → execute-gate) emitting {status, alpha_parts, beta_relations, gamma_evolution, preregs, execution_plan, refusal_reasons}.
• A CM0 admissibility report (HTML/JSON) in the existing axis-card / module-card / critical-findings / recommended-actions grammar, retuned from software-project modules to methodology organs/relations, with a consistency/disagreement section.
• Running the compiler over a candidate corpus (CM0 itself, self-measure CM, factorized-β prereg, one deliberately-bad CM, one simple good toy CM).

Out of scope (non-goals — see below): any change to the scalar meter's consistency-optimization; a v3.2.5 prompt/schema tweak; promoting standing from a self-pass; re-running the terminal factorized-β experiment.

Deferred: external-steward adjudication and cross-route witnesses (the §6 held-out/registration future; feeds later issues, not this wave).

Design tensions the wave must resolve (pinned by κ — not resolved here)

These are recorded so the design sub (Sub-1) resolves them explicitly rather than by drift. They are the review findings, carried into the artifact:

1. The axis rename is a γ-Migration event on the 0th methodology — version it. Existing CM0: α = instrument self-agreement / consistency. Proposed CM0: α = Parts, with consistency pulled out into a separate standing axis (α Parts / β Fit / γ Evolve / Consistency standing). β (Fit) and γ (Evolve) align with the existing decomposition; α does not — "consistency" moves out of α. Silently renaming axes on the self-referential 0th methodology is precisely the γ ## Migration / ## Standing Discipline discipline CM0 itself demands. Constraint: Sub-1 must treat this as a versioned migration — old readings must stay interpretable, and the CM0 that does the renaming must pass its own Migration clause. Failing to do so makes the wave violate the methodology it formalizes.
2. Compile-time admissibility ≠ runtime standing. Parse/typecheck/link/factorization and the definition of consistency/discrimination gates are static (compile). Actually passing those gates requires a k=3 measurement run (execute). The compiler must check that a CM defines repeatability/controls; it must not claim a CM has standing without a run. The report keeps "admissible (static)" and "has standing (measured)" as separate columns — the existing skill's §5 (hygiene ≠ merit) is the governing precedent.
3. Self-pass is hygiene, never authority. CM0 checks CMs including itself; a self-pass qualifies it to compete and wins nothing (existing §5/§6). Standing still comes from external anchors, rival CMs, and outcome correlation. Constraint carried verbatim from the operator's own caution.
4. Provisional-γ must remain admissible-as-candidate. A brand-new CM has no evolution history; γ = provisional / insufficient-history (not zero, not ignored). The compiler must let provisional-γ CMs be admissible candidates — else nothing new can ever enter.

Cycle scope sizing

Factor	Reading	Splitting signal?
(a) New code surface	coh cm-compile CLI + cm.cue + prereg.cue + judgment-call schema + report generator	Yes — ≥2 new modules/contracts
(b) Cross-module breadth	engine bin, schemas, skills/cm-of-cms, docs/governance, targets, fixtures	Yes — ≥3 surfaces
(c) Lifecycle span	design → schema → code → report → execute; cannot fully overlap	Yes — phases serialize
(d) MCA-precondition stability	design not yet committed at a stable path	Yes — stage design first
(e) Independent shippability of AC groups	schema/docs ship independently of the compiler; compiler independent of the report	Yes — subs are the right shape

Decision: split into master + 5 subs. Five-of-five split signals; this is a staged pipeline, not embarrassingly-parallel — captured honestly below.

The decomposition (planned subs — filed at launch)

Sequencing is a staged pipeline (design-first), not full parallelism. Subs 1 & 2 are independently shippable and can run in parallel; 3 consumes their schemas; 4 consumes 3's structured output; 5 validates the whole. The master states the dependency openly rather than pretend the anti-pattern away.

• Sub-1 — CM0 document structure + cm.cue. Create docs/beta/governance/CM0.md and restructure skills/cm-of-cms/SKILL.md into # α — Parts / # β — Fit / # γ — Evolve with H2 measurable clauses (each H2 compiles to a typed clause: id, axis, evidence, mechanical_checks, semantic_checks, failure_modes, actions). Add schemas/cm.cue (extending/superseding #CoherenceMethodology). Resolves design tensions 1 & 4. (design-and-build; independently shippable)
• Sub-2 — Prereg schema + fixtures. schemas/prereg.cue (id/axis/status/human_intent/hypothesis/factorization(owners+loci)/judgment_contract/aggregation/consistency_gate/discrimination_gate/no_decision/success/failure/post_result_rule) + fixtures/preregs/valid/*.yaml and .../invalid/*.yaml; validate axis exists, evidence exists, factorization owners declared, judgment labels match aggregation, gates executable, failure/no-decision consequences defined, standing effect explicit. Type the factorized-β prereg as a conformance fixture. (design-and-build; independently shippable; parallel with Sub-1)
• Sub-3 — coh cm-compile. The staged compiler over a CM document, emitting {status: compiled|rejected, alpha_parts, beta_relations, gamma_evolution, preregs, execution_plan, refusal_reasons}. The factorization stage is the enforceable heart: for every semantic score, who enumerates / judges / aggregates — if the LLM owns all three → reject or mark draft. A non-compiling CM may exist as draft / not-executable / no-standing. (MCA once Sub-1/Sub-2 committed; depends on both)
• Sub-4 — CM0 admissibility report. HTML/JSON in the axis-card/module-card/critical-findings/recommended-actions grammar, retuned to methodology organs/relations, with the executive verdict (admissible / provisional / rejected / no-decision), the α/β/γ module breakdowns, and a consistency section (witness agreement by clause, disagreement examples, ambiguous predicates, standing decision). Vendor/pin the report grammar to remove the external-artifact source-drift. Enforces tension 2 (admissible vs has-standing as separate columns). (depends on Sub-3's structured output)
• Sub-5 — Execute CM0 on candidates (terminal validation). Run the compiler over: CM0 itself, the self-measure CM (methodology), the factorized-β prereg, one deliberately-bad CM, one simple good toy CM. Prove the compiler rejects the bad one and admits the good ones, and that the factorized-β prereg's predicate-underspecification surfaces as a reported finding (the Implement meter-found semantic ambiguity queue from factorized-β runs #76 line), classification not meter-tuning. (depends on Sub-3, Sub-4)

Proof plan (wave-level)

• Invariant: a candidate CM is admissible-for-execution iff it compiles (parts present, fit typed, evolution honest, preregs executable, judgments bounded, consistency/controls defined, report traceable).
• Oracle: coh cm-compile over the Sub-5 corpus.
• Positive case: CM0 and the good toy CM compile → admissible/provisional.
• Negative case: the deliberately-bad CM (missing an α organ, or a prereg whose gate can pass without touching its declared axis, or an LLM that owns enumerate+judge+aggregate) → rejected with a named refusal_reason; and an invalid prereg fixture fails prereg.cue.
• Operator-visible projection: the CM0 report renders the verdict + critical findings + recommended actions for a human.
• Known gap: compile-time cannot prove a CM passes consistency/discrimination — only that it defines them; runtime standing needs an actual k=3 run (tension 2).

Skills to load (at launch)

Tier 2: .cdd/skills/cdd/CDD.md, role skill (α/β/γ). Tier 3: .cdd/skills/cdd/issue, design, plan, review. CDS engineering-level framework (.cdd/skills/cds/CDS.md §Assessment) for the L7 PRA.

Related artifacts

• Implement meter-found semantic ambiguity queue from factorized-β runs #76 — meter-found semantic ambiguity queue; CM0 is its structural home (the factorized-β FAIL becomes a compile/report input, not a re-run).
• docs/beta/governance/A3-DISAGREEMENT-REQUEST.md, CONSISTENCY-FACTORIZATION-PREREG.md, METER-LOOP-DECISION.md, DEFECT-HARVESTING.md.
• wave: factorized-β witness-consistency experiment (rev-4 pre-registration) #73 (factorized-β wave, closed, FAIL) — the precedent this generalizes.

Non-goals

• No change to the scalar meter's consistency-optimization; this does not reopen the stopped meter loop (METER-LOOP-DECISION.md). CM0 is instrument admissibility, not Coh-consistency tuning; its metrics are admissibility/agreement/ambiguity — never Coh.
• No v3.2.5 prompt/schema tweak; no standing promotion from a self-pass; no re-run of the terminal factorized-β experiment.
• CM0 claims no absolute authority merely because it checks itself.

Success / closure condition

This wave is closeable when:

• all filed subs are closed (or a deferred sub is named as tracked debt);
• coh cm-compile admits the good candidates and rejects the deliberately-bad one with a named refusal reason (Sub-5 proof passes);
• CM0 is authored in its own α-Parts/β-Fit/γ-Evolve grammar and passes its own compile (with the axis-rename recorded as a versioned γ-migration — tension 1);
• non-goals remain unviolated (no meter-loop reopen; no standing from self-pass);
• the admissible-vs-has-standing distinction is preserved in the report (tension 2);
• known gaps are carried explicitly in the closing self-coherence record.

Launch is an operator gate. κ has prepared the wave; dispatch (config + subs filing + go) is δ's call.

[usurobor]

Wave launched (κ) — 2026-07-06

Operator dispatch (δ): file subs · .cdd/DISPATCH §5.2 single-session δ-as-γ · priority P1. γ-axis grade capped at A− per release/SKILL.md §3.8 (state in every closeout).

Subs filed + linked (staged pipeline):

• CM0 Sub-1: CM0 document grammar (α-Parts / β-Fit / γ-Evolve) + schemas/cm.cue #78 Sub-1 — CM0 grammar (α-Parts/β-Fit/γ-Evolve) + schemas/cm.cue · no dep · carries the axis-rename-as-γ-migration constraint + provisional-γ-admissible.
• CM0 Sub-2: prereg as a first-class typed compile object — schemas/prereg.cue + fixtures #79 Sub-2 — schemas/prereg.cue + fixtures · no dep · carries preregs-as-typed-β-objects.
• CM0 Sub-3: coh cm-compile — the staged CM compiler #80 Sub-3 — coh cm-compile · dep CM0 Sub-1: CM0 document grammar (α-Parts / β-Fit / γ-Evolve) + schemas/cm.cue #78 + CM0 Sub-2: prereg as a first-class typed compile object — schemas/prereg.cue + fixtures #79 · carries compile-time admissibility ≠ runtime standing; Implement meter-found semantic ambiguity queue from factorized-β runs #76 not a blocker.
• CM0 Sub-4: CM0 admissibility report (methodology organs/relations) #81 Sub-4 — admissibility report · dep CM0 Sub-3: coh cm-compile — the staged CM compiler #80 · carries admissible≠standing + vendor the report grammar (no live external dep); Implement meter-found semantic ambiguity queue from factorized-β runs #76 input-only.
• CM0 Sub-5: execute the compiler over the candidate corpus (terminal validation) #82 Sub-5 — execute over candidate corpus (terminal validation) · dep CM0 Sub-3: coh cm-compile — the staged CM compiler #80 + CM0 Sub-4: CM0 admissibility report (methodology organs/relations) #81 · carries self-pass = hygiene, not authority; consumes Implement meter-found semantic ambiguity queue from factorized-β runs #76 if available, else uses A3-DISAGREEMENT-REQUEST.md as the fixture request and marks live extraction deferred.

#76 dependency (precise): input to Sub-4/Sub-5 for the disagreement table only — not a blocker for Sub-1/2/3.

Dispatched now (foundation-first): #78 and #79 as parallel α cells (branches cycle/78, cycle/79). Sub-3/4/5 remain gated on their dependencies — grammar + schemas ship before the runner. Non-goals hold across the wave: no meter-consistency reopen, no v3.2.5, no standing promotion, terminal factorized-β FAIL unchanged.

---

Generated by Claude Code