Repair EDCM audit defects with versioned 0.2 contracts

.agents/skills/README.md

@@ -3,12 +3,12 @@
 This directory contains repo-local copies of canonical skills from
 `The-Interdependency/skill-lib`.
 
-Source commit: `c14ee9d500579a4b5d6821f62c9d82ca96e73608`
+Source commit: `dd5027d99516831c0dcb83a176a67140d3819b66`
 
 Repo-local copies are not the source of truth. Edit `skill-lib` first,
 then propagate from the canonical source.
 
-Installed skills:
+Skills refreshed from the source commit above:
 
 - `canon/`
 - `domain-claims/`

.agents/skills/gonol-build/SKILL.md

@@ -1,80 +1,91 @@
 ---
 name: gonol-build
-description: Construction, closure, and replay contract for gonols across UCNS and EDCM. Load this when building or reviewing UCNS geometry used by gonols, or building EDCM character, word, definition, or recursive-relation gonols. UCNS owns geometry; EDCM owns text construction. The required EDCM order is characters -> words -> definitions -> recursive gonol relations. Pronunciation is not required unless an explicitly declared later experiment makes it part of the construction. Do not load for unrelated geometry, ordinary prose editing, or measurement over already-closed gonols.
+description: Construction, closure, and replay discipline for active gonol-language research. Load this when building or reviewing language constructions made from UCNS gonol objects in The-Interdependency/stack, or when checking closure, atomic participation, provenance, replay, and unresolved geometry boundaries. UCNS owns gonol objects, constructors, and geometry; Stack owns active construction research; EDCM owns measurement/evaluation only. Closed gonols participate atomically at admissible consuming scales; no universal adjacent-scale ladder is required. Pronunciation is not required unless an explicitly declared construction makes it part of the build. Do not load for unrelated geometry, ordinary prose editing, or measurement over already-closed gonols.
 ---
 
 # gonol-build
 
-Use this skill to keep gonol construction on the declared architecture and nothing else.
+Use this skill to keep gonol-language construction on the declared architecture and nothing else.
 
 ## Workflow
 
-1. Resolve the current UCNS and EDCM authorities before building.
+1. Resolve the exact UCNS authority and the exact owning Stack research workspace before building.
 2. Before launching construction or replay whose completion materially depends on scarce resources, preflight the resources required to finish the declared scope.
-3. Keep the EDCM order load-bearing: characters -> words -> definitions -> recursive gonol relations.
-4. Close each completed gonol before it participates atomically at the next declared scale.
-5. If required UCNS geometry is unresolved, preserve that boundary as `hmmm`.
-6. Replay the complete declared scope only where replay is required by the governing protocol.
+3. Resolve the owning Stack workspace's declared source/admission profile, participant eligibility, relations, and closure rules; do not impose a universal adjacent-scale ladder.
+4. Consume UCNS gonol constructors and geometry rather than defining a competing gonol object in the language layer.
+5. Close each completed gonol before it participates atomically at an admissible consuming scale.
+6. If required UCNS geometry is unresolved, preserve that boundary as `hmmm`.
+7. Replay the complete declared scope only where replay is required by the governing protocol.
 
 ## Authority
 
 ```text
-UCNS      = geometry
-EDCM      = text-domain gonol construction
+UCNS      = gonol objects, constructors, and underlying geometry
+Stack     = active language-gonol construction research workspaces
+EDCM      = measurement and evaluation of constructed outputs
 skill-lib = construction/replay discipline
 ```
 
-Resolve the current UCNS and EDCM authorities before building. Do not move text semantics into UCNS or invent geometry in EDCM.
+Repository placement does not transfer authority. A Stack workspace may construct English, Python, French, TypeScript, or another domain from UCNS gonol objects without thereby owning UCNS geometry. Language workspaces consume UCNS construction authority; they do not redefine it. EDCM may measure a completed construction without defining that construction.
 
-## EDCM construction contract
+Historical EDCM constructor names and sealed artifacts remain valid historical identities for replay. They do not restore active construction authority to EDCM.
+
+## Active construction contract
 
 ```text
-characters -> words -> definitions -> recursive gonol relations
+declared source/admission profile
++ eligible already-closed participants
++ constitutive relation
++ UCNS gonol construction
+-> closure
 ```
 
-This order is load-bearing.
+The active constructor contract belongs to the owning Stack research workspace. Resolve its exact files and commit before selecting participants. For the current English research workspace this includes `research/english-gonol/`; for current Python research this includes `research/python-gonol/`. These paths are workspace locations, not universal language canon.
 
-- Every admitted character is a gonol.
-- Ordered character gonols close into a word gonol.
-- A closed word gonol is atomic at the consuming scale while its constituent identities, order, multiplicity, source positions, and provenance remain recoverable.
-- Definition gonols are constructed from the applicable closed word gonols and exact source definition evidence.
-- Recursive relations are constructed from already-closed gonols without reopening or erasing their internal structure.
+The sequence `characters -> words -> definitions -> recursive relations` may describe a particular construction, but it is not a mandatory ladder for every language or every admitted construction.
 
-Do not insert another required stage into this sequence unless the governing contract is explicitly changed.
+- Every admitted primitive occurrence required by the active profile remains individually addressable.
+- Ordered closed gonols may close into a higher construction when the owning workspace authorizes that relation.
+- Any closed gonol is atomic at an admissible consuming scale while constituent identities, order, multiplicity, source positions, relations, and provenance remain recoverable.
+- Constitutive relationships belong inside the construction. Sidecars may index or cache them but must not replace them.
+- Recursive relations consume already-closed gonols without reopening or erasing their internal structure.
+
+Do not invent participant eligibility, a required intermediate stage, semantic axes, or a geometry law merely to complete a pipeline.
 
 ## Pronunciation boundary
 
-Pronunciation is not required for this construction. Pronunciation, phonetic spelling, IPA, audio, or other sound representations must not alter gonol identity, closure, ordering, or relations unless a later explicitly declared experiment makes phonology part of its construction.
+Pronunciation is not required by default. Pronunciation, phonetic spelling, IPA, audio, or other sound representations must not alter gonol identity, closure, ordering, or relations unless the owning construction explicitly admits phonology.
 
-Source pronunciation data may remain source metadata. It is not a dependency of the current build.
+Source pronunciation data may remain evidence or metadata. It becomes construction only under an explicit source/admission contract.
 
 ## Construction invariant
 
-At every scale:
+At every admitted scale:
 
 ```text
-ordered eligible gonols
--> authorized UCNS geometric relation/application
+ordered eligible closed gonols
+-> constitutive relation declared by the owning workspace
+-> UCNS gonol construction / authorized geometric application
 -> closure
 -> deterministic identity + provenance receipt
--> atomic participation at the next declared scale
+-> atomic participation at an admissible consuming scale
 ```
 
-Preserve exact source identity, occurrence order, multiplicity, and provenance. Do not normalize, deduplicate, infer relations, or substitute tokens, embeddings, hashes, or another representation for gonol identity unless the active contract explicitly authorizes it.
+Preserve exact source identity, occurrence order, multiplicity, relation identity, and provenance. Do not normalize, deduplicate, infer relations, or substitute tokens, AST nodes, compiler objects, embeddings, hashes, or metadata for gonol construction unless the active contract explicitly authorizes their role.
 
 If required UCNS geometry is unresolved, preserve that boundary as `hmmm`; do not fill it with an invented rule.
 
 ## Candidate boundary
 
-An unresolved constructor is permission to construct a named, bounded candidate; it does not block declared experimentation. It blocks promotion beyond the evidence, not construction or testing.
+An unresolved constructor or geometry operation permits named, bounded candidate work where the declared evidence permits it. It does not block declared experimentation. It blocks promotion beyond the evidence.
 
 ## Completion and replay
 
-Before launching a construction or replay run whose completion materially depends on scarce resources, preflight the resources required to finish it. If the preflight cannot establish enough resource confidence to finish the declared scope, do not start the compute run; record the unresolved resource boundary as `hmmm` or narrow the declared scope under the governing protocol. Once a healthy admitted run begins, let it reach its natural terminal condition unless a genuine safety/resource boundary or preregistered load-bearing stop condition fires. Do not add arbitrary wall-clock limits.
+Before launching a construction or replay run whose completion materially depends on scarce resources, preflight the resources required to finish it. If the preflight cannot establish enough resource confidence to finish the declared scope, do not start the compute run; record the resource boundary as `hmmm` or narrow the declared scope under the governing protocol. Once a healthy admitted run begins, let it reach its natural terminal condition unless a genuine safety/resource boundary or preregistered load-bearing stop condition fires. Do not add arbitrary wall-clock limits.
 
 A completion claim requires:
 
-1. exact UCNS, EDCM, source/profile, and constructor identities;
+1. exact UCNS, Stack workspace, source/profile, and constructor identities;
 2. the complete declared source scope;
 3. deterministic construction receipts; and
 4. independent complete replay where replay is required by the governing protocol.
@@ -83,26 +94,37 @@ Replay establishes reproducibility of that construction only. It does not by its
 
 ## Usage guidance
 
-For text construction, start in EDCM and consume current UCNS geometry.
+For active gonol-language construction, start in the owning research workspace inside `The-Interdependency/stack` and consume current UCNS gonol constructors/geometry. Do not start in EDCM.
 
 ```text
-UCNS: geometry
-EDCM: characters -> words -> definitions -> recursive gonol relations
+UCNS:  gonol objects + constructors + geometry
+Stack: active construction research
+EDCM:  measurement/evaluation only
+```
+
+Use `stack-update` when ownership, placement, authority, lifecycle, or promotion changes. Use `interdependent-work-graph` whenever the task crosses repository boundaries.
+
+Run skill-lib's local authority regression gate after changing this boundary:
+
+```bash
+bash tools/check_gonol_authority.sh
 ```
 
-When a word closes, use that word gonol atomically at the next scale. Ignore pronunciation unless a future explicit construction says otherwise.
+When a gonol closes, use it atomically at an admissible consuming scale. Ignore pronunciation unless an explicit construction says otherwise.
 
 ## Anti-patterns
 
-- Moving text semantics into UCNS or inventing geometry in EDCM.
-- Inserting another required EDCM stage without an explicit contract change.
-- Letting pronunciation alter gonol identity, closure, ordering, or relations unless a later explicitly declared experiment makes phonology part of its construction.
-- Normalizing, deduplicating, inferring relations, or substituting tokens, embeddings, or hashes for gonol identity unless the active contract explicitly authorizes it.
+- Assigning active gonol or language construction authority to EDCM.
+- Defining a competing gonol object in an English, Python, or other language workspace instead of consuming UCNS construction authority.
+- Treating Stack placement as transfer of UCNS geometry authority.
+- Imposing an adjacent-scale ladder or inventing an eligible relation without the owning workspace's authority.
+- Letting pronunciation alter gonol identity, closure, ordering, or relations unless an explicit construction admits it.
+- Normalizing, deduplicating, inferring relations, or substituting tokens, AST nodes, embeddings, hashes, or metadata for gonol identity unless explicitly authorized.
 - Adding arbitrary wall-clock limits to a healthy admitted run.
 - Treating replay as semantic quality, measurement validity, cognition, or extra-scope canon.
 
 ## hmmm
 
 - exact UCNS geometric operations that remain unresolved in current implementation;
-- any future construction that explicitly adds phonology or another stage;
+- future repository/package placement for graduated language-gonol artifacts where no repository presently exists;
 - any recursive relation whose governing source or geometry is not yet established.

.agents/skills/meta-module-build/SKILL.md

@@ -1,15 +1,20 @@
 ---
 name: meta-module-build
-description: Metadata-first module build skill built on msdmd. Use this when turning a capability idea into a bounded module manifest, file plan, public/internal surface, permission boundary, tests, docs, rollout, and rollback notes before implementation.
+description: Native-first module planning built on msdmd. Consume existing manifests, schemas and design declarations; supplemental MODULE_BUILD blocks record remaining purpose, surface, boundary, test, rollout and rollback obligations. Load this when turning a capability idea into a bounded module manifest and file plan before implementation.
 ---
 
-GPT generated; context, prompt Erin Spencer
-
 # meta-module-build — Metadata-first module scaffolding
 
-`meta-module-build` is an application of [msdmd](../msdmd/SKILL.md). It uses self-declared metadata to keep a proposed module's purpose, surfaces, dependencies, boundaries, tests, and rollout notes visible beside the files that implement it.
+GPT generated; context, prompt Erin Spencer
 
-Read `msdmd/SKILL.md` first. This skill inherits the block syntax, parser contract, and visible gap-reporting requirement.
+`meta-module-build` is an application of [msdmd](../msdmd/SKILL.md). It
+keeps proposed purpose, surfaces, dependencies, boundaries, tests and rollout
+notes attributable to the sources that own them.
+
+Read `msdmd/SKILL.md` first. This skill inherits its source/provenance, native
+reader support, supplemental block and information-coverage contracts.
+Implementation status: this is a consuming-repo planning/runner contract;
+this repo does not ship a MODULE_BUILD runner or native planning readers.
 
 ## Doctrine
 
@@ -21,9 +26,21 @@ intent -> manifest -> file plan -> tests -> scaffold -> reviewable change
 
 If a field is not known, write `hmmm`. Do not guess certainty into the manifest.
 
+## Native-first coverage
+
+Consume existing package/module manifests, schemas, source-owned design
+records and explicit rollout/test declarations before requesting supplemental
+metadata. Preserve owning scope and source references. A package manifest is
+not automatically a module plan: map only information it actually expresses.
+
+The build's semantic obligations remain required, but their native owners need
+no MODULE_BUILD copies. Supplement genuinely unexpressed intent. Unsupported
+mapping is unresolved coverage, not absence. Native readers remain implementation
+work, not capabilities supplied by this text.
+
 ## The block
 
-A module owns its build declaration in a `MODULE_BUILD` block:
+A module may supplement its build declaration with a `MODULE_BUILD` block:
 
 ```python
 # === MODULE_BUILD ===
@@ -47,7 +64,9 @@ A module owns its build declaration in a `MODULE_BUILD` block:
 
 ## Field schema
 
-Required:
+This syntax governs supplemental MODULE_BUILD entries. Native sources retain
+their own schemas and must satisfy the applicable planning obligations without
+invented IDs or copied fields. Required for a supplemental entry:
 
 | Field | Meaning |
 |---|---|
@@ -62,7 +81,7 @@ Required:
 | `rollout` | How the module becomes active. |
 | `rollback` | How to disable or remove it cleanly. |
 
-Boundary fields are required because module generation often crosses hidden lines:
+Boundary information is required because module generation often crosses hidden lines:
 
 | Field | Meaning |
 |---|---|
@@ -139,21 +158,31 @@ Do not use raw factorization sentinels for A0-facing claims when a scoped envelo
 
 A `MODULE_BUILD` runner should:
 
-1. parse all `MODULE_BUILD` blocks using the msdmd universal parser;
-2. validate required fields;
-3. report boundary fields visibly;
-4. report modules without `MODULE_BUILD` as coverage gaps;
-5. optionally fail in strict mode when required build metadata is missing;
+1. extract supported native planning metadata and parse supplemental
+   `MODULE_BUILD` blocks using the msdmd universal parser;
+2. validate native mappings and supplemental fields under their own schemas;
+3. report boundary information and its owning sources visibly;
+4. report genuinely absent required planning information only after capable
+   inspection; keep missing blocks separate as adoption observations;
+5. fail strict mode on missing information, required unsupported extraction or
+   unresolved conflicts, rather than accepting incomplete coverage;
 6. emit a review summary grouped by `module_kind` and boundary risk.
 
+## Validation
+
+A supported native planning fixture must satisfy the information it actually
+expresses without a MODULE_BUILD copy. Include missing rollback, unresolved
+boundary, unsupported mapping and same-name/different-scope cases.
+
 ## Anti-patterns
 
 - Building code first and writing the manifest after.
-- Omitting boundary fields because the module feels small.
+- Omitting boundary information because the module feels small.
 - Marking unknowns as solved instead of `hmmm`.
 - Using implementation-shaped ids that do not explain the protected capability.
 - Adding UI or route behavior without declaring metadata expectations.
 - Treating frontier-domain UCNS results as absolute claims.
+- Demanding a second MODULE_BUILD copy of already-owned native information.
 
 ## Completion criteria
 
@@ -169,10 +198,13 @@ or
 scaffold PR with tests and docs
 ```
 
-It is incomplete if it only produces an idea, a patch with no manifest, or a module with no boundary/test plan.
+The manifest may be composed from source-linked native declarations and
+supplemental entries. An idea alone, a patch with no manifest, or a module with
+no boundary/test plan remains incomplete.
 
 ## hmmm
 
+Native planning readers remain consuming-repo implementation work.
 Default unresolved items for new modules:
 
 ```text