From c9052ef4b0b0ea577b93f116aab96da42880110e Mon Sep 17 00:00:00 2001
From: Shay <assetoverflow@icloud.com>
Date: Wed, 13 May 2026 13:10:50 -0700
Subject: [PATCH] Add language pack schema foundation

---
 language_packs/schema.py | 157 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 157 insertions(+)
 create mode 100644 language_packs/schema.py

diff --git a/language_packs/schema.py b/language_packs/schema.py
new file mode 100644
index 00000000..8631273c
--- /dev/null
+++ b/language_packs/schema.py
@@ -0,0 +1,157 @@
+"""
+Schemas for CORE compiled linguistic manifolds.
+
+A language pack is not a dataset. It is a deterministic, checksummed,
+compiled linguistic manifold: lexical surfaces, morphology, grammar
+attractors, cross-language resonances, and holonomy-level proof cases.
+
+These schemas intentionally do not load corpora. They define the contract the
+Supervised Seeding Epoch must satisfy before Hebrew and Koine Greek gates can
+engage.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Mapping, Sequence
+
+
+class LanguageRole(str, Enum):
+    """Architectural role of a language pack in CORE-Logos."""
+
+    OPERATIONAL_BASE = "operational_base"
+    ARTICULATION_SURFACE = "articulation_surface"
+    DEPTH_ROOT = "depth_root"
+    DEPTH_RELATION = "depth_relation"
+
+
+class OOVPolicy(str, Enum):
+    """Out-of-vocabulary behavior for a pack."""
+
+    FAIL_CLOSED = "fail_closed"
+    TAGGED_FALLBACK = "tagged_fallback"
+    PROPOSE_VOCAB_EXPANSION = "propose_vocab_expansion"
+
+
+@dataclass(frozen=True, slots=True)
+class LanguagePackManifest:
+    """Pinned manifest for one compiled language pack."""
+
+    pack_id: str
+    language: str
+    role: LanguageRole
+    script: str
+    normalization_policy: str
+    source_manifest: str
+    determinism_class: str
+    checksum: str
+    version: str = "1.0.0"
+    gate_engaged: bool = False
+    oov_policy: OOVPolicy = OOVPolicy.FAIL_CLOSED
+
+    def __post_init__(self) -> None:
+        if not self.pack_id:
+            raise ValueError("LanguagePackManifest.pack_id is required.")
+        if not self.language:
+            raise ValueError("LanguagePackManifest.language is required.")
+        if not self.checksum:
+            raise ValueError("LanguagePackManifest.checksum is required.")
+        if self.role in {LanguageRole.DEPTH_ROOT, LanguageRole.DEPTH_RELATION}:
+            if self.gate_engaged and self.oov_policy is not OOVPolicy.FAIL_CLOSED:
+                raise ValueError(
+                    "Depth packs must fail closed while gate_engaged=True; "
+                    "unknown Hebrew/Greek surfaces must not collapse to a fallback point."
+                )
+
+
+@dataclass(frozen=True, slots=True)
+class MorphologyEntry:
+    """
+    Morphological decomposition for a surface form.
+
+    Ordering is load-bearing. For Semitic root morphology and Koine grammar,
+    non-commutative composition means prefix/stem/inflection/suffix order must
+    be preserved exactly.
+    """
+
+    surface: str
+    lemma: str
+    language: str
+    root: str | None = None
+    prefix_chain: tuple[str, ...] = field(default_factory=tuple)
+    stem: str | None = None
+    inflection: Mapping[str, str] = field(default_factory=dict)
+    suffix_chain: tuple[str, ...] = field(default_factory=tuple)
+
+
+@dataclass(frozen=True, slots=True)
+class LexicalEntry:
+    """One surface/lemma entry in a compiled linguistic manifold."""
+
+    entry_id: str
+    surface: str
+    lemma: str
+    language: str
+    part_of_speech: str | None = None
+    morphology_id: str | None = None
+    semantic_domains: tuple[str, ...] = field(default_factory=tuple)
+    manifold_point_checksum: str | None = None
+    provenance_ids: tuple[str, ...] = field(default_factory=tuple)
+
+
+@dataclass(frozen=True, slots=True)
+class GrammarAttractor:
+    """
+    Structural grammar attractor seeded into the shared manifold.
+
+    Morphology is operator composition. Semantic domain is attractor geometry.
+    Alignment is resonance. This class represents the attractor layer only.
+    """
+
+    attractor_id: str
+    language: str
+    role: str
+    description: str
+    operator_order: tuple[str, ...] = field(default_factory=tuple)
+    checksum: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class AlignmentEdge:
+    """Weighted directional resonance between entries or concepts."""
+
+    source_id: str
+    target_id: str
+    relation: str
+    weight: float
+    evidence_ids: tuple[str, ...] = field(default_factory=tuple)
+
+    def __post_init__(self) -> None:
+        if not 0.0 <= self.weight <= 1.0:
+            raise ValueError("AlignmentEdge.weight must be in [0, 1].")
+
+
+@dataclass(frozen=True, slots=True)
+class HolonomyAlignmentCase:
+    """
+    Crown proof case for the three-language design.
+
+    The language system succeeds when aligned canonical clauses produce nearby
+    holonomies without flattening their distinctions. This is not token-level
+    translation; it is dynamic field-path resonance.
+    """
+
+    case_id: str
+    description: str
+    source_refs: tuple[str, ...]
+    pack_ids: tuple[str, ...]
+    expected_relation: str
+    negative_source_refs: tuple[str, ...] = field(default_factory=tuple)
+    tolerance: float | None = None
+
+    def __post_init__(self) -> None:
+        if len(self.source_refs) < 2:
+            raise ValueError("HolonomyAlignmentCase requires at least two source_refs.")
+        if len(self.pack_ids) < 2:
+            raise ValueError("HolonomyAlignmentCase requires at least two pack_ids.")