research(english-gonol): correct primitive-layer contract and suffixiation

Return final-y behavior to the y character gonol definition-space:
- add character definition layer (vowel/consonant/digit/operator/punctuation,
  letter pronunciation, orthographic behavior) with multi-definition origins
- digits close number-name definitions from characters (3 -> three -> t,h,r,e,e)
  plus numerology definitions
- add suffixiate(): affixiation between already-closed base and suffix gonols;
  resolves final-y interaction from the y character definition-space and the
  suffix's suffix-specific behavior without reopening either gonol
- repair gonol contract/docs/tests that carried final-y behavior on suffix
  gonols (try+ing preserves y, try+ed resolves y-to-i)
- frozen primitive-layer receipt experiments/primitive-layer-v0.json
- full-corpus run and 1-7 sweep control remain byte-identical

Author: erinepshovel-code

research/english-gonol/README.md

@@ -70,16 +70,25 @@ research/english-gonol/
 ├── README.md
 ├── english_gonol/
 │   ├── gonol.py                  # unified candidate constructor (identity edcm.gonol)
-│   ├── language/                 # English lexical evidence over UCNS carrier
-│   └── orthogonal_carrier_sweep.py  # 1-7 carrier experimental sweep
+│   ├── definition_affixiation_run.py  # full-corpus definition re-affixiation
+│   ├── orthogonal_carrier_sweep.py  # 1-7 carrier experimental sweep (control)
+│   ├── primitive_layer_run.py    # character definitions + corrected suffixiation
+│   └── language/
+│       ├── character_definitions.py  # primitive character definition-space
+│       ├── suffixiation.py       # closed-gonol affixiation for suffixes
+│       └── data/                 # affix + character definition tables
 ├── tools/build_oewn2025_embeddings.py
 ├── tests/
 ├── docs/
 │   ├── GONOL_LANGUAGE_BOUNDARY.md
-│   └── orthogonal-carrier-sweep-v0.md
+│   ├── orthogonal-carrier-sweep-v0.md
+│   ├── oewn-orthogonal-affixiation-v0.md
+│   └── primitive-layer-correction-v0.md
 └── experiments/
     ├── lexical/                  # frozen lexical-floor run artifacts
-    └── orthogonal-carrier-sweep-v0.json
+    ├── orthogonal-carrier-sweep-v0.json
+    ├── primitive-layer-v0.json
+    └── oewn-affixiation-v0/      # full-corpus manifest (records local-only)
 ```
 
 ## Entry points
@@ -132,6 +141,16 @@ See [`docs/oewn-orthogonal-affixiation-v0.md`](docs/oewn-orthogonal-affixiation-
 The large `records.jsonl` is local persisted state and is not committed; the
 committed `manifest.json` binds it via `records_sha256`.
 
+The primitive-layer correction and extension (character definitions, digit
+number names, corrected suffixiation):
+
+```bash
+python -m english_gonol.primitive_layer_run \
+  --out experiments/primitive-layer-v0.json
+```
+
+See [`docs/primitive-layer-correction-v0.md`](docs/primitive-layer-correction-v0.md).
+
 ## Research status
 
 Standing: **stack-local research, not canon**. The construction is an

research/english-gonol/docs/GONOL_LANGUAGE_BOUNDARY.md

@@ -67,7 +67,7 @@ UCNS owns any exact geometric realization of that operation. The native Möbius/
 
 English Gonol Construction applies affixiation to text-domain gonols. Linguistic prefixes and suffixes are one instance of affixiation; they do not define affixiation.
 
-Suffix-coupling options that affect a suffix relation are carried by the relevant closed suffix gonol. For example, a closed `ing` suffix gonol may carry `suffix-coupling.final-y-after-consonant = preserve-y`; the suffix-coupling construction preserves that option through the suffix participant instead of storing an `ing` exception in a global morphology law or reopening the suffix.
+Suffix-coupling options that are suffix-specific are carried by the relevant closed suffix gonol. For example, a closed `ing` suffix gonol may carry `suffix-coupling.vowel-initial = true`. Character-specific behavior is not placed on suffix gonols: final-y rendering belongs to the `y` character gonol's definition-space (`orthographic-behavior:final-y-after-consonant`). `suffixiate()` resolves the interaction between the closed base's final character definitions and the closed suffix's suffix-specific behavior without reopening either gonol.
 
 The complete English root, stem, affix, irregular-transformation, and family law remains unresolved unless source-backed English Gonol evidence establishes it. English Gonol Construction must not invent decomposition to complete a pipeline.
 
@@ -123,13 +123,21 @@ Copy-pasteable unified candidate:
 
 ```python
 from english_gonol.gonol import construct_gonol, replay_gonol
+from english_gonol.language.suffixiation import suffixiate
 
 word = construct_gonol(scale="word", source="try", source_id="example:try")
+y_character = word.gonol.source_characters[-1]
+construct_gonol(
+    scale="definition",
+    participants=(y_character,),
+    relation="orthographic-behavior:final-y-after-consonant",
+    source_id="example:y-orthographic-behavior",
+)
 ing = construct_gonol(
     scale="suffix",
     source="ing",
     source_id="example:ing",
-    carried_options=(("suffix-coupling.final-y-after-consonant", "preserve-y"),),
+    carried_options=(("suffix-coupling.vowel-initial", "true"),),
 )
 definition = construct_gonol(
     scale="definition",
@@ -144,13 +152,11 @@ recursive = construct_gonol(
     participants=(word.gonol, definition.gonol),
     source_id="example:relation#1",
 )
-suffix_coupling = construct_gonol(
-    scale="suffix-coupling",
-    participants=(word.gonol, ing.gonol),
-    source_id="example:trying#1",
-)
+suffix_coupling = suffixiate(word.gonol, ing.gonol, source_id="example:trying#1")
 assert recursive.receipt_digest == replay_gonol(receipt=recursive).receipt_digest
-assert suffix_coupling.receipt_digest == replay_gonol(receipt=suffix_coupling).receipt_digest
+assert suffix_coupling.coupling_receipt.receipt_digest == replay_gonol(
+    receipt=suffix_coupling.coupling_receipt
+).receipt_digest
 ```
 
 If an explicit `geometry_authority` supplies `PUBLIC_GONOL_157` with a digest matching the pinned Public Gonol identity, `english_gonol.gonol` (constructor identity retained as `edcm.gonol`) observes source-unit positions. If no authority is supplied, construction records geometry as `hmmm` and still closes the candidate. It does not probe ambient imports and does not mutate `sys.path`.

research/english-gonol/docs/primitive-layer-correction-v0.md

@@ -0,0 +1,116 @@
+# Primitive-layer correction and extension — v0
+
+Status: `UNRESOLVED` experimental correction. Standing: implemented
+experimental candidate inside English Gonol Construction only. Nothing here is
+UCNS geometry canon, an English lexical truth claim, or a cultural/linguistic
+canon selection.
+
+## What changed and why
+
+The previous contract carried character-specific final-y behavior on closed
+suffix gonols (`suffix-coupling.final-y-after-consonant = preserve-y` on
+`ing`). That misplaced a character property on a suffix. This correction
+returns the behavior to the primitive layer and extends construction upward
+from characters without rebuilding the existing full-corpus machinery.
+
+## Primitive layer
+
+### Character gonols
+
+Characters remain the most primitive admitted gonols. Each admissible character
+closes as a `scale="character"` gonol with an exact source identity
+(`char:<char>`); each occurrence inside a word remains individually addressable
+through the word gonol's recoverable `source_characters`, preserving identity,
+order, multiplicity, relation, and provenance.
+
+Every character gonol may have multiple definition gonols sharing that
+character gonol as origin. Character definitions are not mutually exclusive:
+
+- `-` carries both `char-class:operator` and `char-class:punctuation`.
+- `y` carries both `char-class:vowel` and `char-class:consonant`.
+- Letters carry `letter-pronunciation:<name>` definitions.
+- `y` carries `orthographic-behavior:final-y-after-consonant` in its own
+  definition-space.
+
+### Digits
+
+Each digit is its own primitive character gonol. Each digit receives:
+
+- a `digit-number-name` definition composed from the number name's own word
+  gonol, constructed normally from characters
+  (`3 -> three -> (t,h,r,e,e)`);
+- additional `numerology:<meaning>` definition gonols (candidate evidence,
+  not canon).
+
+### Letters
+
+Letters carry their letter identity, pronunciation definition(s), and any
+source-backed character-specific orthographic behavior. `y` carries its
+final-y behavior in the `y` character gonol's definition-space; it is not
+recreated as a global morphology rule during suffixiation.
+
+## Suffixiation
+
+Suffixes close first (`scale="suffix"`) with their own identity, definitions,
+behavior, and provenance. Suffixiation is then affixiation between
+already-closed gonols:
+
+```text
+G(base); affix; G(suffix)
+```
+
+- The base contributes its complete closed construction, including its
+  constituent characters' definitions and behavior.
+- The suffix contributes its own closed construction and suffix-specific
+  behavior (for example `suffix-coupling.vowel-initial = true`).
+- Neither gonol is reopened. `suffixiate()` reads only recoverable internal
+  construction, resolves the interaction, and closes a normal
+  `scale="suffix-coupling"` gonol over the two atomic participants.
+
+Final-y resolution is therefore produced by the `y` character gonol's own
+definition-space together with the suffix's suffix-specific behavior:
+
+- `try + ing` (vowel-initial, `ing`) -> `preserve-y`
+- `try + ed` (vowel-initial, non-`ing`) -> `y-to-i`
+- `play + ing` (final `y` after a vowel) -> no final-y rule applies
+
+## Words and definitions
+
+Character gonols affixiate into word gonols; each word gonol is the common
+origin of its distinct definition gonols. Definitions are ordinary
+`scale="definition"` closures over the word's already-closed constituent
+gonols — not pairwise Euclidean orthogonals. Every word occurrence inside
+every definition remains attached as its complete word gonol, with its own
+definitions available recursively.
+
+## Frozen run
+
+- Module: `english_gonol.primitive_layer_run`
+- Receipt: `experiments/primitive-layer-v0.json`
+  - character layer: 55 entries, 179 definition receipts,
+    `receipt_digest = 8f0931a15865600fba6a11a995f6331d1081317c2bb8c86593fae83d57d93933`
+  - `primitive:trying` -> `y_realization = preserve-y`
+  - `primitive:tried` -> `y_realization = y-to-i`
+- Replay:
+  `python -m english_gonol.primitive_layer_run --out experiments/primitive-layer-v0.json`
+
+## Preserved, not rebuilt
+
+- The full-corpus orthogonal definition affixiation run
+  (`experiments/oewn-affixiation-v0`) replays byte-for-byte unchanged.
+- The 1-7 hash-carrier sweep control is unchanged (same report digest).
+- Constructor closure logic is unchanged; only the corrected contract text and
+  examples moved character-specific behavior off suffix gonols.
+- Surface-rendering evidence (`rendering.py`) is unchanged; it remains
+  evidence, not construction authority, and is not consulted by suffixiation.
+
+## hmmm
+
+- "y would like its belongings returned by ing" — returned: final-y behavior
+  now lives in the `y` character gonol definition-space.
+- Exact UCNS affixiation geometry remains unresolved; `suffixiate()` closes
+  the coupling gonol and records resolution without inventing geometry.
+- Pronunciation is currently a letter-name definition only; full
+  source-backed pronunciation evidence remains unresolved.
+- Numerology definitions are declared candidate evidence; their source
+  standing is not canon.

research/english-gonol/english_gonol/gonol.py

@@ -10,20 +10,26 @@
 ``character -> word -> definition -> recursive`` ladder.
 
     from english_gonol.gonol import construct_gonol, replay_gonol
+    from english_gonol.language.suffixiation import suffixiate
 
     word = construct_gonol(scale="word", source="try", source_id="example:try")
+    y_character = word.gonol.source_characters[-1]  # already-closed "y" gonol
+    construct_gonol(
+        scale="definition",
+        participants=(y_character,),
+        relation="orthographic-behavior:final-y-after-consonant",
+        source_id="example:y-orthographic-behavior",
+    )
     ing = construct_gonol(
         scale="suffix",
         source="ing",
         source_id="example:ing",
-        carried_options=(("suffix-coupling.final-y-after-consonant", "preserve-y"),),
+        carried_options=(("suffix-coupling.vowel-initial", "true"),),
     )
-    rel = construct_gonol(
-        scale="suffix-coupling",
-        participants=(word.gonol, ing.gonol),
-        source_id="example:trying#1",
-    )
-    assert rel.receipt_digest == replay_gonol(receipt=rel).receipt_digest
+    rel = suffixiate(word.gonol, ing.gonol, source_id="example:trying#1")
+    assert rel.coupling_receipt.receipt_digest == replay_gonol(
+        receipt=rel.coupling_receipt
+    ).receipt_digest
 
 Frozen choices for ``edcm.gonol/v1``:
 
@@ -35,8 +41,10 @@
   folding, trimming, deduplication, or token substitution;
 - relation identity is exact caller-supplied text where the option set requires
   it;
-- suffix-coupling exceptions are carried by the closed suffix gonol, not by a
-  global morphology law or by reopening the suffix during coupling;
+- suffix-coupling options that are suffix-specific (for example vowel-initial)
+  are carried by the closed suffix gonol; character-specific behavior such as
+  final-y rendering belongs to the ``y`` character gonol's definition-space and
+  is resolved during suffixiation without reopening either gonol;
 - UCNS Public Gonol geometry is consumed only from an explicit supplied
   authority, and absence remains ``hmmm`` rather than a base-package failure;
 - no UCNS function operation or Mobius coupling law is invented.
@@ -76,11 +84,11 @@
 #   class: construction
 #   since: 2026-08-22
 #
-# id: suffix_exception_carried_by_suffix_gonol
-#   given: suffix coupling has a final-y exception such as ing preserving y after a consonant
-#   then: the exception is stored on the closed suffix gonol participant and replayed through participant provenance rather than global morphology law
+# id: character_behavior_resolved_during_suffixiation
+#   given: a suffix coupling touches a final y after a consonant
+#   then: the y character gonol's own orthographic-behavior definitions supply the y rendering, the closed suffix supplies only suffix-specific behavior, and suffixiation resolves their interaction without reopening either gonol
 #   class: construction
-#   since: 2026-08-22
+#   since: 2026-09-12
 #
 # id: construction_survives_absent_ucns_geometry
 #   given: UCNS Public Gonol geometry authority is not explicitly supplied