tgi-foundation 0.2.0.dev0__tar.gz → 0.2.0.dev11__tar.gz

tgi_foundation-0.2.0.dev11/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+recursive-include tgi *.py

{tgi_foundation-0.2.0.dev0 → tgi_foundation-0.2.0.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tgi-foundation
-Version: 0.2.0.dev0
+Version: 0.2.0.dev11
 Summary: Native character-identity and geometric knowledge mechanisms for Topological Geometric Intelligence
 Author: Emylton Leunufna
 License: Copyright (c) 2026 Emylton Leunufna
@@ -21,10 +21,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: license-file
 
-# TGI: Topological Geometric Intelligence
+# TGI foundation M2
 
-Research implementation by Emylton Leunufna. This repository contains the Python runtime, a minimal reproducible acceptance example and regression tests, and six manuscripts with PDF renderings. NMU retains one static ID per Unicode scalar; the mechanisms are derived from the TGI program.
-
-Python >=3.11. Local check: `python -m unittest discover -s tests -q`. CLI: `python -m tgi --help`. See `paper/technical/README.md` for the foundational and five technical papers. Raw research evidence and historical hypotheses are intentionally outside this public code tree.
-
-Copyright (c) 2026 Emylton Leunufna. No reuse allowed without permission.
+Native NMU identity, source-bound response atlas, endpoint transport, and one-NMU substitution transport. Emylton Leunufna. No reuse allowed without permission.

tgi_foundation-0.2.0.dev11/README.md

@@ -0,0 +1,3 @@
+# TGI foundation M2
+
+Native NMU identity, source-bound response atlas, endpoint transport, and one-NMU substitution transport. Emylton Leunufna. No reuse allowed without permission.

{tgi_foundation-0.2.0.dev0 → tgi_foundation-0.2.0.dev11}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tgi-foundation"
-version = "0.2.0.dev0"
+version = "0.2.0.dev11"
 description = "Native character-identity and geometric knowledge mechanisms for Topological Geometric Intelligence"
 readme = "README.md"
 requires-python = ">=3.11"
-dependencies = []
-authors = [{name = "Emylton Leunufna"}]
-license = {file = "LICENSE"}
+dependencies = []
+authors = [{name = "Emylton Leunufna"}]
+license = {file = "LICENSE"}
 keywords = ["topological geometric intelligence", "TGI", "NMU", "crystal memory"]
 classifiers = [
   "Development Status :: 3 - Alpha",

tgi_foundation-0.2.0.dev11/tgi/causal_port_classes.py

@@ -0,0 +1,226 @@
+"""NMU-preserving observational classes under sensor-local alphabet changes."""
+import copy
+import hashlib
+import json
+import os
+import re
+import tempfile
+from pathlib import Path
+
+from .frame_engine import canonical, unique_object
+from .identity import REGISTRY_ID, encode
+from .intervention_edit_contrast import contrast
+from .organization import OMEGA_CRIT
+
+REVISION = 'TGI-M1-CAUSAL-PORT-TOPOLOGY-V1'
+
+
+def _sha(data):
+    return hashlib.sha256(data).hexdigest()
+
+
+def _event(source, action, ports):
+    if type(source) is not str or not source or type(action) is not str or not action or \
+            type(ports) is not dict or len(ports) < 3:
+        raise ValueError('Original source, action and three port streams required')
+    observed = {}
+    for name, pair in sorted(ports.items()):
+        if type(name) is not str or not name or type(pair) not in (tuple, list) or len(pair) != 2:
+            raise ValueError('Raw port address and frame pair required')
+        observed[name] = contrast(*pair)
+    return {'source': source, 'action_nmu': list(encode(action)), 'ports': observed}
+
+
+def _evidence(events, members, names, action):
+    contexts = set()
+    controls = 0
+    comparators = set()
+    for event in events:
+        key = tuple(event['action_nmu'])
+        changed = all(event['ports'][name]['kind'] != 'STABLE' for name in members)
+        stable = all(event['ports'][name]['kind'] == 'STABLE' for name in members)
+        if changed and key == action:
+            contexts.add(tuple(tuple(event['ports'][name]['before_nmu']) for name in members))
+        if stable:
+            if key == action:
+                controls += 1
+            if any(event['ports'][name]['kind'] != 'STABLE' for name in names if name not in members):
+                comparators.add(key)
+    return len(contexts), controls, any(other != action for other in comparators)
+
+
+def form(events, *, revision=REVISION, valid_row=None):
+    if type(events) is not list:
+        raise ValueError('Ordered original events required')
+    from .intervention_edit_contrast_check import verify as valid_contrast
+    if valid_row is None:
+        valid_row = valid_contrast
+    traces, phases, names, seen, actions = {}, [], None, set(), set()
+    prior, epoch = None, 0
+    for index, event in enumerate(events):
+        if type(event) is not dict or set(event) != {'source', 'action_nmu', 'ports'} or \
+                type(event['source']) is not str or not event['source'] or event['source'] in seen or \
+                type(event['action_nmu']) is not list or not event['action_nmu'] or \
+                type(event['ports']) is not dict:
+            raise ValueError('Unique original event required')
+        seen.add(event['source'])
+        current = list(event['ports'])
+        if len(current) < 3 or current != sorted(current) or \
+                any(type(name) is not str or not name or not valid_row(event['ports'][name]) for name in current):
+            raise ValueError('Complete original port contrasts required')
+        if names is None:
+            names = current
+            traces = {name: [] for name in names}
+        if current != names:
+            raise ValueError('Fixed port inventory required')
+        actions.add(tuple(event['action_nmu']))
+        for name in names:
+            traces[name].append(event['ports'][name]['kind'])
+        grouped = {}
+        for name in names:
+            grouped.setdefault(tuple(traces[name]), []).append(name)
+        groups = sorted(tuple(members) for members in grouped.values())
+        cells, winners = [], []
+        for members in groups:
+            counts = []
+            for action in sorted(actions):
+                omega, controls, comparator = _evidence(events[epoch:index+1], members, names, action)
+                counts.append({'action_nmu': list(action), 'omega': omega,
+                               'controls': controls, 'comparator': comparator})
+                if omega >= OMEGA_CRIT and controls and comparator:
+                    winners.append((action, members))
+            cells.append({'members': list(members), 'C_L_by_action': counts, 'xi': 0})
+        if prior is not None and prior not in groups:
+            result = {'status': 'REVOKED', 'action_nmu': None, 'members': None}
+            prior, epoch = None, index + 1
+        elif len(winners) == 1:
+            action, members = winners[0]
+            result = {'status': 'CRYSTAL', 'action_nmu': list(action), 'members': list(members)}
+            prior = members
+            for cell in cells:
+                cell['xi'] = int(tuple(cell['members']) == members)
+        elif prior is not None and not any(members == prior for _, members in winners):
+            result = {'status': 'REVOKED', 'action_nmu': None, 'members': None}
+        else:
+            result = {'status': 'NO_PATH', 'action_nmu': None, 'members': None}
+        phases.append({'event_index': index, 'source': event['source'],
+                       'epoch_start': epoch, 'classes': cells, 'result': result})
+    return {'revision': revision, 'registry': REGISTRY_ID, 'events': copy.deepcopy(events),
+            'phases': phases, 'result': phases[-1]['result'] if phases else
+            {'status': 'NO_PATH', 'action_nmu': None, 'members': None}}
+
+
+class CausalPortClasses:
+    REVISION = REVISION
+    EVENT_FACTORY = staticmethod(_event)
+    FORM = staticmethod(form)
+
+    @staticmethod
+    def VERIFY(events, certificate):
+        from .causal_port_classes_check import verify
+        return verify(events, certificate)
+
+    def __init__(self, events=()):
+        self._events = copy.deepcopy(list(events))
+        self._certificate = self.FORM(self._events)
+        if not self.VERIFY(self._events, self._certificate):
+            raise ValueError('Independent causal topology replay failed')
+
+    def _verify(self):
+        if not self.VERIFY(self._events, self._certificate):
+            raise ValueError('Original causal state changed')
+
+    @property
+    def certificate(self):
+        self._verify()
+        return copy.deepcopy(self._certificate)
+
+    def observe(self, source, action, ports):
+        self._verify()
+        if any(row['source'] == source for row in self._events):
+            raise ValueError('Duplicate original source')
+        return type(self)(self._events + [self.EVENT_FACTORY(source, action, ports)])
+
+    def resolve(self, action):
+        self._verify()
+        if type(action) is not str or not action:
+            raise ValueError('Raw action required')
+        result = self._certificate['result']
+        return list(result['members']) if result['status'] == 'CRYSTAL' and \
+            result['action_nmu'] == list(encode(action)) else None
+
+    def commit(self, path):
+        self._verify()
+        payload = {'revision': self.REVISION, 'registry': REGISTRY_ID,
+                   'events': self._events, 'certificate': self._certificate}
+        envelope = {'payload': payload, 'sha256': _sha(canonical(payload).encode('utf8'))}
+        data = canonical(envelope).encode('utf8')
+        target = Path(path)
+        temporary = None
+        try:
+            with tempfile.NamedTemporaryFile(mode='wb', dir=target.parent, delete=False) as stream:
+                temporary = Path(stream.name)
+                stream.write(data)
+                stream.flush()
+                os.fsync(stream.fileno())
+            os.replace(temporary, target)
+            temporary = None
+        finally:
+            if temporary is not None and temporary.exists():
+                temporary.unlink()
+        return {'path': str(target), 'sha256': _sha(data), 'bytes': len(data)}
+
+    @classmethod
+    def recover(cls, path, expected_sha256):
+        if type(expected_sha256) is not str or re.fullmatch('[0-9a-f]{64}', expected_sha256) is None:
+            raise ValueError('External digest required')
+        data = Path(path).read_bytes()
+        if _sha(data) != expected_sha256:
+            raise ValueError('Checkpoint digest mismatch')
+        envelope = json.loads(data.decode('utf8'), object_pairs_hook=unique_object)
+        if type(envelope) is not dict or set(envelope) != {'payload', 'sha256'}:
+            raise ValueError('Invalid checkpoint envelope')
+        payload = envelope['payload']
+        if type(payload) is not dict or set(payload) != {'revision', 'registry', 'events', 'certificate'} or \
+                payload['revision'] != cls.REVISION or payload['registry'] != REGISTRY_ID or \
+                _sha(canonical(payload).encode('utf8')) != envelope['sha256']:
+            raise ValueError('Invalid checkpoint payload')
+        result = cls(payload['events'])
+        if canonical(result.certificate) != canonical(payload['certificate']):
+            raise ValueError('Recomputed causal certificate differs')
+        return result
+
+
+REVISION_INCIDENCE = 'TGI-M1-RESPONSE-INCIDENCE-V1'
+
+
+def _response_event(source, action, ports):
+    if type(source) is not str or not source or type(action) is not str or not action or \
+            type(ports) is not dict or len(ports) < 3:
+        raise ValueError('Original source, action and three port streams required')
+    observed = {}
+    for name, pair in sorted(ports.items()):
+        if type(name) is not str or not name or type(pair) not in (tuple, list) or len(pair) != 2 or \
+                type(pair[0]) is not str or not pair[0] or type(pair[1]) is not str or not pair[1]:
+            raise ValueError('Nonempty raw port frame pair required')
+        before, after = list(encode(pair[0])), list(encode(pair[1]))
+        changed = before != after
+        observed[name] = {'before_nmu': before, 'after_nmu': after,
+                          'kind': 'CHANGED' if changed else 'STABLE', 'changed': changed}
+    return {'source': source, 'action_nmu': list(encode(action)), 'ports': observed}
+
+
+def form_incidence(events):
+    from .response_incidence_check import valid_response
+    return form(events, revision=REVISION_INCIDENCE, valid_row=valid_response)
+
+
+class ResponseIncidenceClasses(CausalPortClasses):
+    REVISION = REVISION_INCIDENCE
+    EVENT_FACTORY = staticmethod(_response_event)
+    FORM = staticmethod(form_incidence)
+
+    @staticmethod
+    def VERIFY(events, certificate):
+        from .response_incidence_check import verify
+        return verify(events, certificate)

tgi_foundation-0.2.0.dev11/tgi/causal_port_classes_check.py

@@ -0,0 +1,93 @@
+"""Independent exhaustive replay of observational edit-topology classes."""
+from .frame_engine import canonical
+from .identity import REGISTRY_ID, decode
+from .intervention_edit_contrast_check import verify as valid_contrast
+from .organization import OMEGA_CRIT
+
+REVISION = 'TGI-M1-CAUSAL-PORT-TOPOLOGY-V1'
+
+
+def verify(events, certificate, *, revision=REVISION, valid_row=valid_contrast):
+    try:
+        if type(events) is not list or type(certificate) is not dict or \
+                set(certificate) != {'revision', 'registry', 'events', 'phases', 'result'} or \
+                certificate['revision'] != revision or certificate['registry'] != REGISTRY_ID or \
+                canonical(certificate['events']) != canonical(events) or \
+                type(certificate['phases']) is not list or len(certificate['phases']) != len(events):
+            return False
+        names = None
+        sources = set()
+        prior = None
+        epoch = 0
+        final = {'status': 'NO_PATH', 'action_nmu': None, 'members': None}
+        for stop, event in enumerate(events):
+            if type(event) is not dict or set(event) != {'source', 'action_nmu', 'ports'} or \
+                    type(event['source']) is not str or not event['source'] or event['source'] in sources or \
+                    type(event['action_nmu']) is not list or not event['action_nmu'] or \
+                    type(event['ports']) is not dict:
+                return False
+            sources.add(event['source'])
+            if not decode(event['action_nmu']):
+                return False
+            observed = list(event['ports'])
+            if len(observed) < 3 or observed != sorted(observed) or \
+                    any(type(name) is not str or not name or not valid_row(event['ports'][name])
+                        for name in observed):
+                return False
+            if names is None:
+                names = observed
+            if observed != names:
+                return False
+            prefix = events[:stop+1]
+            partition = {}
+            for name in names:
+                signature = tuple(row['ports'][name]['kind'] for row in prefix)
+                partition.setdefault(signature, []).append(name)
+            groups = sorted(tuple(members) for members in partition.values())
+            actions = sorted({tuple(row['action_nmu']) for row in prefix})
+            cells, winners = [], []
+            for members in groups:
+                counts = []
+                for action in actions:
+                    support = set()
+                    controls = 0
+                    separating_actions = set()
+                    for row in events[epoch:stop+1]:
+                        raw_action = tuple(row['action_nmu'])
+                        all_changed = all(row['ports'][name]['changed'] for name in members)
+                        all_stable = all(not row['ports'][name]['changed'] for name in members)
+                        if all_changed and raw_action == action:
+                            support.add(tuple(tuple(row['ports'][name]['before_nmu']) for name in members))
+                        if all_stable:
+                            if raw_action == action:
+                                controls += 1
+                            if any(row['ports'][name]['changed'] for name in names if name not in members):
+                                separating_actions.add(raw_action)
+                    comparator = any(other != action for other in separating_actions)
+                    omega = len(support)
+                    counts.append({'action_nmu': list(action), 'omega': omega,
+                                   'controls': controls, 'comparator': comparator})
+                    if omega >= OMEGA_CRIT and controls and comparator:
+                        winners.append((action, members))
+                cells.append({'members': list(members), 'C_L_by_action': counts, 'xi': 0})
+            if prior is not None and prior not in groups:
+                final = {'status': 'REVOKED', 'action_nmu': None, 'members': None}
+                prior = None
+                epoch = stop+1
+            elif len(winners) == 1:
+                action, members = winners[0]
+                final = {'status': 'CRYSTAL', 'action_nmu': list(action), 'members': list(members)}
+                prior = members
+                for cell in cells:
+                    cell['xi'] = int(tuple(cell['members']) == members)
+            elif prior is not None and not any(members == prior for _, members in winners):
+                final = {'status': 'REVOKED', 'action_nmu': None, 'members': None}
+            else:
+                final = {'status': 'NO_PATH', 'action_nmu': None, 'members': None}
+            expected = {'event_index': stop, 'source': event['source'],
+                        'epoch_start': epoch, 'classes': cells, 'result': final}
+            if canonical(expected) != canonical(certificate['phases'][stop]):
+                return False
+        return canonical(final) == canonical(certificate['result'])
+    except (ValueError, TypeError, KeyError, IndexError, AttributeError):
+        return False

{tgi_foundation-0.2.0.dev0 → tgi_foundation-0.2.0.dev11}/tgi/intervention_continuity_check.py

@@ -1,5 +1,4 @@
 """Independent complete epoch/bridge role-lineage outcome verification."""
-from copy import deepcopy
 from .frame_engine import canonical
 from .organization_snapshot import snapshot
 from .intervention_roles_check import verify_intervention_roles
@@ -12,14 +11,14 @@ def verify_intervention_continuity(old,bridge,new,root_port,certificate,*,max_se
     with budget.scope():
         budget.consume()
         try:
-            c=deepcopy(certificate)
+            c=certificate
             if set(c)!={'policy','root_port','epochs','outcomes','total_completions','result'} or c['policy']!='bridged_intervention_role_continuity_v1' or c['root_port']!=root_port:return False
             if not isinstance(c['epochs'],list) or len(c['epochs'])!=3:return False
             epochs=c['epochs']
             for raw,role in zip((old,bridge,new),epochs):
                 if raw is None:
                     if role is not None:return False
-                elif not isinstance(raw,(tuple,list)) or len(raw)!=3 or not verify_intervention_roles(snapshot(raw[0]),deepcopy(raw[1]),deepcopy(raw[2]),role):return False
+                elif not isinstance(raw,(tuple,list)) or len(raw)!=3 or not verify_intervention_roles(snapshot(raw[0]),raw[1],raw[2],role):return False
             left,middle,right=epochs
             if left is None or right is None or root_port not in left['ports']:return False
             li=left['ports'].index(root_port);bi=middle['ports'].index(root_port) if middle and root_port in middle['ports'] else None

{tgi_foundation-0.2.0.dev0 → tgi_foundation-0.2.0.dev11}/tgi/intervention_roles_check.py

@@ -1,5 +1,4 @@
 """Independent source/cell/complete-partition verifier for visible roles."""
-from copy import deepcopy
 from .identity import decode,encode
 from .organization import OMEGA_CRIT
 from .organization_snapshot import snapshot
@@ -17,7 +16,7 @@ def verify_intervention_roles(acquisition,groups,measurements,certificate,*,max_
             fields={'policy','groups','witness','ports','rows','changed_before_diversity','partitions','completions','role_candidates','status'}
             c=certificate
             if set(c)!=fields or c['policy']!='visible_intervention_roles_v1' or canonical(c['groups'])!=canonical(groups):return False
-            view=snapshot(acquisition);groups=deepcopy(groups);measurements=deepcopy(measurements)
+            view=snapshot(acquisition)
             if not verify_acquisition_witness(view,measurements,c['witness']):return False
             if not isinstance(groups,list) or not groups:return False
             measured={};expected={(s,i) for s,(frames,_) in view.episodes.items() for i in range(len(frames))}

{tgi_foundation-0.2.0.dev0 → tgi_foundation-0.2.0.dev11}/tgi/lineage_state_check.py

@@ -1,5 +1,4 @@
 """Independent complete observed-state, operation and native lineage check."""
-from copy import deepcopy
 from .identity import decode,encode
 from .frame_engine import canonical
 from .organization_snapshot import snapshot
@@ -15,10 +14,10 @@ def verify_lineage_state(old,bridge,new,root_port,anchor,actions,certificate,*,m
             if not isinstance(anchor,dict) or set(anchor)!={'source','frame'} or not isinstance(anchor['source'],str) or type(anchor['frame']) is not int or anchor['frame'] not in (0,2):return False
             if not isinstance(actions,(list,tuple)) or not actions or any(not isinstance(a,str) or not a for a in actions):return False
             for action in actions:encode(action)
-            c=deepcopy(certificate)
+            c=certificate
             if set(c)!={'policy','root_port','anchor','actions','lineage','port','states','inventory','result'} or c['policy']!='lineage_observed_state_v1' or c['root_port']!=root_port or canonical(c['anchor'])!=canonical(anchor) or canonical(c['actions'])!=canonical(list(actions)):return False
             if not verify_intervention_continuity(old,bridge,new,root_port,c['lineage']):return False
-            view=snapshot(new[0]);groups=new[1];lookup={(r['source'],r['frame']):deepcopy(r) for r in new[2]}
+            view=snapshot(new[0]);groups=new[1];lookup={(r['source'],r['frame']):r for r in new[2]}
             assignment={s['source']:s['port'] for group in groups for s in group}
             port=assignment[anchor['source']]
             def endpoint(source,frame):

tgi_foundation-0.2.0.dev11/tgi/phase_bound_port_classes.py

@@ -0,0 +1,204 @@
+"""Source-owned physical port classes gated by their original frame crystals.
+
+Port response topology and raw path organization are distinct TGI operators.
+This cycle binds their common raw experience without requiring a text-pattern
+organization to exist for a physical sensor class.
+"""
+import copy
+import hashlib
+import json
+import os
+import re
+import tempfile
+from pathlib import Path
+
+from .frame_engine import canonical, unique_object
+from .identity import REGISTRY_ID, decode
+from .local_edit_transport_classes import OwnedPortClasses, _event
+from .local_edit_transport_classes_check import verify as verify_classes
+from .causal_port_classes import (CausalPortClasses, ResponseIncidenceClasses,
+                                  _event as _causal_event, _response_event)
+from .causal_port_classes_check import verify as verify_causal_classes
+from .response_incidence_check import verify as verify_response_incidence
+from .organization import RawOrganization
+
+REVISION = 'TGI-PHASE-BOUND-PORT-CLASSES-V1'
+
+
+def _sha(data):
+    return hashlib.sha256(data).hexdigest()
+
+
+def _source(event_source, port):
+    return canonical([event_source, port])
+
+
+def _fork_crystals(parent):
+    if type(parent) is not RawOrganization or parent.frames._pending:
+        raise ValueError('Complete predecessor crystal state required')
+    child = RawOrganization()
+    for name in ('_atoms', '_bonds', '_origins', '_contexts', '_sources', '_pending'):
+        setattr(child.frames, name, dict(getattr(parent.frames, name)))
+    child.episodes = dict(parent.episodes)
+    return child
+
+
+class PhaseBoundPortClasses:
+    REVISION = REVISION
+    CLASS_TYPE = OwnedPortClasses
+    EVENT_FACTORY = staticmethod(_event)
+    VERIFY_CLASS = staticmethod(verify_classes)
+
+    def __init__(self, events=(), *, max_search_steps=100000):
+        if type(events) not in (list, tuple) or type(max_search_steps) is not int or max_search_steps < 1:
+            raise ValueError('Ordered raw events and positive search budget required')
+        rows = copy.deepcopy(list(events))
+        native_events = []
+        model = RawOrganization()
+        seen = set()
+        for event in rows:
+            if type(event) is not dict or set(event) != {'source', 'action', 'ports'}:
+                raise ValueError('Original event source, action and port frames required')
+            source, action, ports = event['source'], event['action'], event['ports']
+            if type(source) is not str or not source or source in seen or type(ports) is not dict:
+                raise ValueError('Unique original event source and port map required')
+            seen.add(source)
+            native_events.append(self.EVENT_FACTORY(source, action, ports))
+            for port, pair in sorted(ports.items()):
+                model.observe(_source(source, port), list(pair))
+        if len(model.episodes) > max_search_steps:
+            raise ValueError('INCOMPLETE: source verification budget exhausted')
+        classes = self.CLASS_TYPE(native_events)
+        if not all(model._alive(source) for source in model.episodes):
+            raise ValueError('Original frame crystal is not alive')
+        self._events, self._classes, self._model = rows, classes, model
+        self._events_digest = _sha(canonical(rows).encode('utf8'))
+        self._class_digest = _sha(canonical(classes._certificate).encode('utf8'))
+        self.max_search_steps = max_search_steps
+
+    def _certificate(self):
+        class_certificate = self._classes._certificate
+        if _sha(canonical(self._events).encode('utf8')) != self._events_digest or \
+           _sha(canonical(class_certificate).encode('utf8')) != self._class_digest:
+            raise ValueError('Original action, port event, or class certificate changed')
+        if not self.VERIFY_CLASS(class_certificate['events'], class_certificate):
+            raise ValueError('Original class decision failed independent replay')
+        expected_sources = {_source(event['source'], port)
+                            for event in self._events for port in event['ports']}
+        expected_frames = {canonical([source, index]) for source in expected_sources
+                           for index in range(2)}
+        if (set(self._model.episodes) != expected_sources or
+                set(self._model.frames._sources) != expected_frames or
+                self._model.frames._pending):
+            raise ValueError('Crystal source inventory differs from original ports')
+        if len(expected_sources) > self.max_search_steps:
+            raise ValueError('INCOMPLETE: source verification budget exhausted')
+        # Port response topology does not require a text-pattern organization.
+        # _alive independently checks each original C/L receipt, Ω, ξ, atom,
+        # coordinate, forward bond, and exact NMU traversal before use.
+        bindings = []
+        for event in self._events:
+            for port, pair in sorted(event['ports'].items()):
+                source = _source(event['source'], port)
+                if source not in self._model.episodes or not self._model._alive(source):
+                    raise ValueError('Original crystal source is not alive')
+                frames, receipts = self._model.episodes[source]
+                if tuple(map(decode, frames)) != tuple(pair):
+                    raise ValueError('Port observation disagrees with source crystal')
+                bindings.append({'source': source, 'event_source': event['source'],
+                                 'port': port, 'receipts': [r.as_dict() for r in receipts]})
+        return {'revision': self.REVISION, 'registry': REGISTRY_ID,
+                'class_certificate': class_certificate,
+                'bindings': bindings, 'decision': class_certificate['result']}
+
+    @property
+    def certificate(self):
+        return copy.deepcopy(self._certificate())
+
+    def observe(self, source, action, ports):
+        self._certificate()
+        row = {'source': source, 'action': action, 'ports': copy.deepcopy(ports)}
+        self.EVENT_FACTORY(source, action, row['ports'])
+        if any(event['source'] == source for event in self._events):
+            raise ValueError('Duplicate original event source')
+        classes = self._classes.observe(source, action, row['ports'])
+        model = _fork_crystals(self._model)
+        for port, pair in sorted(row['ports'].items()):
+            model.observe(_source(source, port), list(pair))
+        child = object.__new__(type(self))
+        child._events = copy.deepcopy(self._events) + [row]
+        child._classes, child._model = classes, model
+        child._events_digest = _sha(canonical(child._events).encode('utf8'))
+        child._class_digest = _sha(canonical(classes._certificate).encode('utf8'))
+        child.max_search_steps = self.max_search_steps
+        child._certificate()
+        return child
+
+    def observe_batch(self, events):
+        """Publish one atomic successor while preserving every ordered event phase."""
+        self._certificate()  # Reject altered predecessor before successor creation.
+        if type(events) not in (list, tuple) or not events:
+            raise ValueError('Nonempty ordered event batch required')
+        return type(self)(self._events + copy.deepcopy(list(events)),
+                          max_search_steps=self.max_search_steps)
+
+    def resolve(self, action):
+        certificate = self._certificate()
+        return self._classes.resolve(action) if certificate['decision']['status'] == 'CRYSTAL' else None
+
+    def commit(self, path):
+        certificate = self._certificate()
+        payload = {'revision': self.REVISION, 'registry': REGISTRY_ID,
+                   'events': self._events, 'certificate': certificate}
+        envelope = {'payload': payload, 'sha256': _sha(canonical(payload).encode('utf8'))}
+        data = canonical(envelope).encode('utf8')
+        target = Path(path)
+        temporary = None
+        try:
+            with tempfile.NamedTemporaryFile(mode='wb', dir=target.parent, delete=False) as stream:
+                temporary = Path(stream.name)
+                stream.write(data)
+                stream.flush()
+                os.fsync(stream.fileno())
+            os.replace(temporary, target)
+            temporary = None
+        finally:
+            if temporary is not None and temporary.exists():
+                temporary.unlink()
+        return {'path': str(target), 'sha256': _sha(data), 'bytes': len(data)}
+
+    @classmethod
+    def recover(cls, path, expected_sha256, *, max_search_steps=100000):
+        if type(expected_sha256) is not str or re.fullmatch('[0-9a-f]{64}', expected_sha256) is None:
+            raise ValueError('External checkpoint digest required')
+        data = Path(path).read_bytes()
+        if _sha(data) != expected_sha256:
+            raise ValueError('Checkpoint digest mismatch')
+        envelope = json.loads(data.decode('utf8'), object_pairs_hook=unique_object)
+        if type(envelope) is not dict or set(envelope) != {'payload', 'sha256'}:
+            raise ValueError('Invalid checkpoint envelope')
+        payload = envelope['payload']
+        if (type(payload) is not dict or set(payload) != {'revision', 'registry', 'events', 'certificate'} or
+                payload['revision'] != cls.REVISION or payload['registry'] != REGISTRY_ID or
+                envelope['sha256'] != _sha(canonical(payload).encode('utf8'))):
+            raise ValueError('Invalid checkpoint payload')
+        result = cls(payload['events'], max_search_steps=max_search_steps)
+        if canonical(result.certificate) != canonical(payload['certificate']):
+            raise ValueError('Recomputed source binding differs')
+        return result
+
+
+class PhaseBoundCausalPortClasses(PhaseBoundPortClasses):
+    """Alphabet-invariant response topology with the same source crystal law."""
+    REVISION = 'TGI-PHASE-BOUND-CAUSAL-PORT-CLASSES-V1'
+    CLASS_TYPE = CausalPortClasses
+    EVENT_FACTORY = staticmethod(_causal_event)
+    VERIFY_CLASS = staticmethod(verify_causal_classes)
+
+
+class PhaseBoundResponseIncidenceClasses(PhaseBoundPortClasses):
+    """Multi-NMU sensor response incidence with original frame crystals."""
+    REVISION = 'TGI-PHASE-BOUND-RESPONSE-INCIDENCE-V1'
+    CLASS_TYPE = ResponseIncidenceClasses
+    EVENT_FACTORY = staticmethod(_response_event)
+    VERIFY_CLASS = staticmethod(verify_response_incidence)