Move text gonol construction authority into EDCM

.agents/skills/README.md

@@ -3,7 +3,7 @@
 This directory contains repo-local copies of canonical skills from
 `The-Interdependency/skill-lib`.
 
-Source commit: `a0cb6285e37734609b4b487ae4a2e44c6108d2b8`
+Source commit: `a1c6a7124af537ee9937b6fc6084940091982fe5`
 
 Repo-local copies are not the source of truth. Edit `skill-lib` first,
 then propagate from the canonical source.
@@ -12,6 +12,7 @@ Installed skills:
 
 - `canon/`
 - `domain-claims/`
+- `gonol-build/`
 - `interdependent-work-graph/`
 - `meta-module-build/`
 - `msdmd/`

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

@@ -0,0 +1,303 @@
+---
+name: gonol-build
+description: Cross-repository construction, review, replay, and continuation discipline for gonols. Load this when realizing gonol or affixiation geometry in UCNS; when constructing character, word, morphology, definition, punctuation-function, or recursive gonols in EDCM; when deciding whether a relation belongs inside a gonol; or when promoting a completed gonol to atomic participation at another scale. Do not load for unrelated geometry, ordinary prose editing, or EDCM measurement that consumes already-closed gonols without changing their construction. Resolve METAPAT semantic authority, UCNS geometric authority, and EDCM text-domain authority separately; never restore historical gonal-morphology, omega/phi/psi, bone/flesh, or carrier-LCM language rules.
+---
+
+# gonol-build — construct, close, promote, recurse
+
+Use this procedural skill to preserve gonol construction semantics without
+collapsing repository authority boundaries.
+
+The governing split is:
+
+```text
+METAPAT   -> conceptual meaning of affixiation and relational integration
+UCNS      -> gonol geometry, native Möbius/Public Gonol carrier, geometric operations
+EDCM      -> text-domain admission and linguistic/semantic gonol construction
+skill-lib -> construction, evidence, replay, and continuation discipline
+```
+
+No repository gains another repository's authority merely because a construction
+crosses the boundary.
+
+## Workflow: authority gate
+
+Before acting:
+
+1. Resolve the current commits or PR heads of every repository whose authority
+   the construction uses.
+2. Read the governing repository instructions and the directly applicable
+   canon/contract source before choosing a construction rule.
+3. For affixiation, resolve current METAPAT semantics before implementing its
+   geometry or text-domain application.
+4. For carrier, topology, orientation, closure geometry, or Public Gonol
+   operations, resolve current UCNS authority.
+5. For character admission, morphology, words, definitions, source corpora, and
+   recursive textual relations, resolve current EDCM authority.
+6. Distinguish declared architecture, implemented construction, evidence status,
+   proposed continuation, and `hmmm`.
+7. If governing sources disagree, stop at the conflict. Do not choose the most
+   convenient repository or reconstruct authority from historical artifacts.
+
+Treat `hmmm` and an unresolved constructor as a ban on unqualified promotion,
+not as a ban on declared candidate construction. An unresolved constructor is
+permission to construct a named, bounded, falsifiable candidate under the
+contracts that are already fixed; it is not permission to invent the missing
+contract. `hmmm` blocks unqualified certainty and silent canonization. It does
+not block declared experimentation, implementation, comparison, or candidate
+construction.
+
+## Domain rule: every character is a gonol
+
+For active EDCM text construction:
+
+```text
+every admitted character is a gonol
+```
+
+This is an **EDCM text-domain rule**, not a UCNS linguistic rule and not a
+METAPAT axiom.
+
+EDCM owns what counts as an admitted character for a declared source/profile.
+If the source boundary has not selected code point, grapheme, exact Public Gonol
+glyph inventory, or another character unit, preserve that question as `hmmm`.
+UCNS may geometrically realize an admitted character on its carrier; UCNS does
+not silently decide EDCM's character-admission semantics.
+
+Character occurrences remain separately addressable even when repeated. Their
+source identity, order, multiplicity, and provenance are preserved according to
+the active EDCM construction profile.
+
+## Construction invariant
+
+```text
+eligible gonol participants
+    -> explicit relation or geometrically authorized function application
+    -> relation enters the construction
+    -> closure with source identity and receipt
+    -> completed gonol
+    -> atomic participant at another declared scale
+```
+
+`atomic` means indivisible for participation at the consuming scale. It does
+not mean internally structureless, provenance-free, irreversible, or forbidden
+from inspection.
+
+When a relationship helps constitute the result, keep it intrinsic to the
+gonol construction. Sidecars may carry indexes, caches, projections,
+provenance, and receipts; an external edge table does not become the gonol's
+authoritative relational content merely because it is easier to query.
+
+## Active EDCM text order
+
+Unless current EDCM authority explicitly changes it, preserve:
+
+```text
+characters -> morphology -> definitions -> recursive gonol relations
+```
+
+This is an order of construction dependencies, not permission to flatten every
+higher-scale gonol back into characters. Close each completed construction and
+reuse its atomic identity at the consuming scale.
+
+Words and other intermediate closures may exist where the declared construction
+requires them; do not manufacture a mandatory scale merely because a conventional
+NLP pipeline usually has one.
+
+## Affixiation boundary
+
+METAPAT defines affixiation conceptually: already-bounded participants remain
+individually addressable, their identity and provenance are preserved, the
+declared relation may integrate as a higher-scale object-whole, and the
+integrated whole may later participate recursively without erasing its
+constituents.
+
+UCNS owns any exact geometric realization of that operation. Do not invent an
+alternative carrier, topology, scale increment, arity rule, containment rule,
+or coupling law merely to complete an implementation. Implement the native
+carrier under the fixed METAPAT invariants and let unresolved geometric law
+remain `hmmm` until construction exposes it.
+
+EDCM applies affixiation to text-domain gonols. Linguistic prefixes and suffixes
+are one instance of affixiation; they do not define affixiation.
+
+The complete English root, stem, affix, irregular-transformation, and family law
+remains unresolved unless current EDCM source/evidence establishes otherwise.
+Never invent a decomposition to complete a pipeline. Do not assume every word is
+`root + affix`, that a lemma is a final root, or that one stemmer supplies
+semantic authority.
+
+## Closure rules
+
+- Preserve ordered occurrence identity, multiplicity, exact source evidence,
+  source offsets, and provenance required by the governing EDCM profile.
+- Apply no normalization, folding, trimming, deduplication, inferred sorting,
+  or silent collapse unless the current profile explicitly authorizes it.
+- Keep completed gonol closure intact inside larger constructions. Do not reopen
+  a closed word or definition merely because a larger relation contains it.
+- A repeated completed gonol may reuse atomic identity when the governing
+  construction says it is the same gonol; repeated occurrences remain
+  separately addressable.
+- Larger and smaller scales may couple directly when the governing construction
+  permits it. Do not invent mandatory adjacent-scale traversal.
+- Do not materialize an all-pairs relationship graph as semantic authority.
+- Do not substitute conventional NLP token IDs, subword IDs, opaque embedding
+  vectors, or whole-string hashes for gonol identity.
+
+## Public Gonol function application
+
+UCNS owns the geometric operation of Public Gonol function positions. EDCM may
+apply only operations geometrically authorized by the current UCNS source and
+evidence.
+
+- An unresolved geometric operation remains `hmmm`; Unicode names, dictionary
+  definitions, neighboring glyphs, or conventional punctuation grammar do not
+  fill it.
+- Require occurrence-addressed application context when the governing EDCM
+  construction requires context.
+- Never infer adjacency, precedence, grammatical role, or application scope from
+  glyph shape alone.
+- Bind function identity, result identity, ordered participants, occurrence
+  addresses, carrier/construction identity, and source profile in the receipt.
+- Replay against the same geometric authority and explicit construction plan.
+- Do not promote structural survival into parsing, grammar, semantic utility, or
+  universal function law.
+
+## Candidate construction
+
+`Constructor unresolved` means no constructor is yet canonical. It does not mean
+construction cannot begin.
+
+- Inventing hidden canon is prohibited.
+- Constructing a declared, falsifiable candidate is required progress once the
+  governing contracts name the participants and boundary sufficiently to build.
+- Freeze selectable implementation choices before inspecting the candidate's
+  evidentiary outcome when those choices could change the claimed result.
+- A candidate must name its identity, standing, frozen choices, nonclaims, and
+  selection effect before a completion receipt is minted.
+- Replay of a candidate establishes only that candidate's reproducibility. It
+  does not select it or transfer authority across repositories.
+
+## Evidence and replay
+
+For a construction that claims completion:
+
+1. Bind exact METAPAT, UCNS, EDCM, source-artifact, profile, code, and option
+   identities that materially determine the construction.
+2. Admit the complete declared source, not an inspected prefix presented as a
+   finished run.
+3. Preflight required compute and storage before starting. Once an admitted
+   healthy run begins, let it reach its natural terminal condition unless a
+   genuine safety boundary or preregistered load-bearing stop condition fires.
+4. Emit deterministic construction/semantic receipts separately from resource
+   observations.
+5. Independently reconstruct or replay the complete declared scope.
+6. Compare byte-for-byte where the protocol requires exact identity.
+7. Propagate failures and unresolved prerequisites without changing criteria
+   after outcome inspection.
+
+Passing fixtures proves only the fixtures. A historical receipt remains
+historical evidence after its constructor or authority split is superseded; it
+is not a receipt for the replacement construction.
+
+## Required output
+
+Report:
+
+```text
+authority identities:
+source identity:
+construction identity:
+participants and scales:
+intrinsic relations/functions:
+closure boundary:
+atomic participation boundary:
+receipt and replay status:
+claims supported:
+claims not supported:
+hmmm:
+next dependency-complete action:
+```
+
+Use `SURVIVED`, `FALSIFIED`, `BLOCKED`, `UNRESOLVED`, and `DEPRECATED` only under
+the governing protocol. Do not translate `SURVIVED` into proved or canonical.
+
+## Usage guidance
+
+When building text gonols, start in EDCM and consume UCNS geometry rather than
+moving text semantics into UCNS. When building or repairing carrier geometry,
+start in UCNS and use the METAPAT contract only for the relational invariants it
+authorizes. When affixiation semantics themselves are in question, repair or
+resolve them in METAPAT before downstream construction.
+
+A minimal routing example is:
+
+```text
+METAPAT: affixiation preserves bounded participant identity/provenance
+UCNS:    realize that relation on the native Möbius/Public Gonol geometry
+EDCM:    admit characters as gonols and construct text through affixiation
+```
+
+## Anti-patterns: refuse these
+
+- Assigning character, morphology, definition, or lexical-source authority to
+  UCNS merely because UCNS provides their geometry.
+- Assigning affixiation semantics to EDCM or UCNS merely because they implement
+  or apply it.
+- Reopening closed gonols merely because a larger construction contains them.
+- Inferring function context, syntax, precedence, or operation from adjacency,
+  Unicode names, dictionary glosses, or glyph shape.
+- Treating a source word list as a semantic dictionary.
+- Treating `hmmm` or an unresolved constructor as permission to refuse a
+  declared candidate construction, complete run, or replay.
+- Inventing morphology, a lexical family map, geometry, measurement authority,
+  alternate carrier, scale rule, or coupling law to fill an absent constructor.
+- Promoting a sidecar relationship graph into intrinsic gonol semantics.
+- Treating a partial corpus run as complete evidence.
+- Adding arbitrary wall-clock limits to a healthy admitted computation.
+- Restoring the deprecated omega/phi/psi cores, bone/flesh categories, fixed
+  morphology weights, or `multiplyFuel`/carrier-LCM as the universal language
+  law.
+- Transferring UCNS construction survival into EDCM measurement validity,
+  PTCNA efficacy, cognition claims, or selected universal canon.
+
+## Minimal examples
+
+Character admission:
+
+```text
+EDCM source/profile admits "a" -> that character occurrence is a gonol
+UCNS supplies its authorized carrier geometry
+EDCM owns the text-domain construction that consumes it
+```
+
+Recursive closure:
+
+```text
+bounded gonols + declared relation
+    -> affixiate under METAPAT invariants
+    -> UCNS geometric realization
+    -> closed EDCM text-domain gonol
+    -> atomic participation in a later declared relation
+```
+
+Honest incomplete continuation:
+
+```text
+geometric coupling law unresolved
+    -> construct the smallest declared UCNS candidate allowed by fixed contracts
+    -> preserve candidate standing
+    -> hmmm blocks promotion, not construction
+```
+
+## hmmm
+
+`hmmm` blocks unqualified promotion. It does not block experimentation or
+construction of a declared candidate.
+
+- which exact EDCM character-admission unit applies where not already source-pinned;
+- the source-supported complete English morphology law;
+- the exact UCNS Möbius-carrier affixiation/coupling law exposed by implementation;
+- executable geometry for direct coupling across distant recursive scales;
+- quantitative compression and reconstruction behavior after recursive gonols exist;
+- which recursive-gonol candidate, if any, later becomes selected canon.