tgi-foundation 0.2.0.dev0__py3-none-any.whl

tgi/unlabeled_port_classes.py

@@ -0,0 +1,199 @@
+"""Native chronological formation of unlabeled sensor response classes."""
+import copy
+import hashlib
+import json
+import os
+import re
+import tempfile
+from pathlib import Path
+
+from tgi.frame_engine import canonical, unique_object
+from tgi.identity import REGISTRY_ID, encode
+from tgi.organization import OMEGA_CRIT
+from tgi.intervention_edit_contrast import contrast
+
+REVISION = 'TGI-M1-UNLABELED-PORT-CLASSES-RESEARCH-V2'
+
+
+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:
+        raise ValueError('Original source and action required')
+    if type(ports) is not dict or len(ports) < 3:
+        raise ValueError('At least three original port streams required')
+    rows = {}
+    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')
+        rows[name] = contrast(*pair)
+    return {'source': source, 'action_nmu': list(encode(action)), 'ports': rows}
+
+
+def _apply(stats, members, event, names):
+    action = tuple(event['action_nmu'])
+    changed = all(event['ports'][name]['changed'] for name in members)
+    stable = all(not event['ports'][name]['changed'] for name in members)
+    if changed:
+        context = tuple(tuple(event['ports'][name]['before_nmu']) for name in members)
+        stats['support'].setdefault(action, set()).add(context)
+    elif stable:
+        stats['controls'][action] = stats['controls'].get(action, 0) + 1
+        if any(event['ports'][name]['changed'] for name in names if name not in members):
+            stats['comparator'].add(action)
+
+
+def form(events):
+    if type(events) is not list:
+        raise ValueError('Original chronological event list required')
+    phases = []
+    seen = set()
+    names = None
+    previous_class = None
+    epoch_start = 0
+    traces = {}
+    previous_stats = {}
+    actions_seen = set()
+    for index, event in enumerate(events):
+        if (type(event) is not dict or set(event) != {'source', 'action_nmu', 'ports'} or
+                event['source'] in seen or type(event['ports']) is not dict):
+            raise ValueError('Unique original event required')
+        seen.add(event['source'])
+        current = list(event['ports'])
+        if names is None:
+            names = current
+            traces = {name: () for name in names}
+        if current != names:
+            raise ValueError('Fixed port inventory required')
+        for name in names:
+            row = event['ports'][name]
+            traces[name] += ((row['kind'], tuple(row['positions'])),)
+        grouped = {}
+        for name in names:
+            grouped.setdefault(traces[name], []).append(name)
+        classes = sorted(tuple(group) for group in grouped.values())
+        actions_seen.add(tuple(event['action_nmu']))
+        actions = sorted(actions_seen)
+        cells = []
+        eligible = []
+        current_stats = {}
+        for members in classes:
+            if members in previous_stats:
+                stats = previous_stats[members]
+                _apply(stats, members, event, names)
+            else:
+                stats = {'support': {}, 'controls': {}, 'comparator': set()}
+                for row in events[epoch_start:index + 1]:
+                    _apply(stats, members, row, names)
+            current_stats[members] = stats
+            counts = []
+            for action in actions:
+                omega = len(stats['support'].get(action, ()))
+                controls = stats['controls'].get(action, 0)
+                comparator = any(other != action for other in stats['comparator'])
+                counts.append({'action_nmu': list(action), 'omega': omega,
+                               'controls': controls, 'comparator': comparator})
+                if omega >= OMEGA_CRIT and controls and comparator:
+                    eligible.append((action, members))
+            cells.append({'members': list(members), 'C_L_by_action': counts, 'xi': 0})
+        fractured = previous_class is not None and previous_class not in classes
+        if fractured:
+            result = {'status': 'REVOKED', 'action_nmu': None, 'members': None}
+            previous_class = None
+            epoch_start = index + 1
+            current_stats = {}
+        elif len(eligible) == 1:
+            action, members = eligible[0]
+            result = {'status': 'CRYSTAL', 'action_nmu': list(action), 'members': list(members)}
+            previous_class = members
+            for cell in cells:
+                cell['xi'] = int(tuple(cell['members']) == members)
+        elif previous_class is not None and not any(members == previous_class for _, members in eligible):
+            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_start,
+                       'classes': cells, 'result': result})
+        previous_stats = current_stats
+    result = phases[-1]['result'] if phases else {'status': 'NO_PATH', 'action_nmu': None, 'members': None}
+    return {'revision': REVISION, 'registry': REGISTRY_ID,
+            'events': list(events), 'phases': phases, 'result': result}
+
+
+class OwnedPortClasses:
+    def __init__(self, events=None):
+        from tgi.unlabeled_port_classes_check import verify
+        self._events = copy.deepcopy([] if events is None else events)
+        self._certificate = form(self._events)
+        if not verify(self._events, self._certificate):
+            raise ValueError('Independent original port replay failed')
+
+    @property
+    def certificate(self):
+        return copy.deepcopy(self._certificate)
+
+    def observe(self, source, action, ports):
+        from tgi.unlabeled_port_classes_check import verify
+        if any(row['source'] == source for row in self._events):
+            raise ValueError('Duplicate original source')
+        event = _event(source, action, ports)
+        child = type(self).__new__(type(self))
+        child._events = self._events + [event]
+        child._certificate = form(child._events)
+        if not verify(child._events, child._certificate):
+            raise ValueError('Independent original port replay failed')
+        return child
+
+    def resolve(self, action):
+        result = self._certificate['result']
+        if type(action) is not str or not action:
+            raise ValueError('Original action trigger required')
+        if result['status'] != 'CRYSTAL' or result['action_nmu'] != list(encode(action)):
+            return None
+        return list(result['members'])
+
+    def commit(self, path):
+        from tgi.unlabeled_port_classes_check import verify
+        if not verify(self._events, self._certificate):
+            raise ValueError('Independent complete replay failed')
+        payload = {'revision': REVISION, 'registry': REGISTRY_ID,
+                   'events': self._events, 'certificate': self._certificate}
+        envelope = {'payload': payload, 'sha256': _sha(canonical(payload).encode('utf8'))}
+        data = canonical(envelope).encode('utf8')
+        destination = Path(path)
+        temporary = None
+        try:
+            with tempfile.NamedTemporaryFile(mode='wb', dir=destination.parent, delete=False) as stream:
+                temporary = Path(stream.name)
+                stream.write(data)
+                stream.flush()
+                os.fsync(stream.fileno())
+            os.replace(temporary, destination)
+            temporary = None
+        finally:
+            if temporary is not None and temporary.exists():
+                temporary.unlink()
+        return {'path': str(destination), 'sha256': _sha(data), 'bytes': len(data)}
+
+    @classmethod
+    def recover(cls, path, expected_sha256):
+        from tgi.unlabeled_port_classes_check import verify
+        if type(expected_sha256) is not str or re.fullmatch(r'[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'] != REVISION or payload['registry'] != REGISTRY_ID or
+                _sha(canonical(payload).encode('utf8')) != envelope['sha256'] or
+                not verify(payload['events'], payload['certificate'])):
+            raise ValueError('Invalid original port checkpoint')
+        return cls(payload['events'])

tgi/unlabeled_port_classes_check.py

@@ -0,0 +1,113 @@
+"""Independent complete chronological replay of class and epoch certificates."""
+from tgi.frame_engine import canonical
+from tgi.identity import REGISTRY_ID, decode
+from tgi.organization import OMEGA_CRIT
+from tgi.intervention_edit_contrast_check import verify as valid_contrast
+
+REVISION = 'TGI-M1-UNLABELED-PORT-CLASSES-RESEARCH-V2'
+
+
+def _measure(data, members, row, names):
+    action = tuple(row['action_nmu'])
+    stable = all(row['ports'][port]['kind'] == 'STABLE' for port in members)
+    changed = all(row['ports'][port]['kind'] != 'STABLE' for port in members)
+    if changed:
+        key = tuple(tuple(row['ports'][port]['before_nmu']) for port in members)
+        data['contexts'].setdefault(action, set()).add(key)
+    if stable:
+        data['controls'][action] = data['controls'].get(action, 0) + 1
+        if any(row['ports'][port]['kind'] != 'STABLE' for port in names if port not in members):
+            data['separators'].add(action)
+
+
+def verify(events, certificate):
+    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
+        seen = set()
+        traces = {}
+        actions = set()
+        epoch_rows = []
+        old_groups = {}
+        prior_crystal = None
+        epoch_start = 0
+        result = {'status': 'NO_PATH', 'action_nmu': None, 'members': None}
+        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):
+                return False
+            seen.add(event['source'])
+            decode(event['action_nmu'])
+            current_names = list(event['ports'])
+            if (len(current_names) < 3 or current_names != sorted(current_names) or
+                    any(type(name) is not str or not name for name in current_names)):
+                return False
+            if names is None:
+                names = current_names
+                traces = {name: [] for name in names}
+            elif current_names != names:
+                return False
+            for name in names:
+                contrast = event['ports'][name]
+                if not valid_contrast(contrast):
+                    return False
+                traces[name].append((contrast['kind'], tuple(contrast['positions'])))
+            epoch_rows.append(event)
+            actions.add(tuple(event['action_nmu']))
+            partition = {}
+            for name in names:
+                partition.setdefault(tuple(traces[name]), []).append(name)
+            groups = sorted(tuple(members) for members in partition.values())
+            new_groups = {}
+            cells = []
+            winners = []
+            for members in groups:
+                if members in old_groups:
+                    data = old_groups[members]
+                    _measure(data, members, event, names)
+                else:
+                    data = {'contexts': {}, 'controls': {}, 'separators': set()}
+                    for row in epoch_rows:
+                        _measure(data, members, row, names)
+                new_groups[members] = data
+                counts = []
+                for action in sorted(actions):
+                    omega = len(data['contexts'].get(action, ()))
+                    controls = data['controls'].get(action, 0)
+                    comparison = any(other != action for other in data['separators'])
+                    counts.append({'action_nmu': list(action), 'omega': omega,
+                                   'controls': controls, 'comparator': comparison})
+                    if omega >= OMEGA_CRIT and controls and comparison:
+                        winners.append((action, members))
+                cells.append({'members': list(members), 'C_L_by_action': counts, 'xi': 0})
+            if prior_crystal is not None and prior_crystal not in groups:
+                result = {'status': 'REVOKED', 'action_nmu': None, 'members': None}
+                prior_crystal = None
+                epoch_start = index + 1
+                epoch_rows = []
+                new_groups = {}
+            elif len(winners) == 1:
+                action, members = winners[0]
+                result = {'status': 'CRYSTAL', 'action_nmu': list(action), 'members': list(members)}
+                prior_crystal = members
+                for cell in cells:
+                    cell['xi'] = int(tuple(cell['members']) == members)
+            elif prior_crystal is not None and not any(members == prior_crystal for _, members in winners):
+                result = {'status': 'REVOKED', 'action_nmu': None, 'members': None}
+            else:
+                result = {'status': 'NO_PATH', 'action_nmu': None, 'members': None}
+            expected = {'event_index': index, 'source': event['source'],
+                        'epoch_start': epoch_start, 'classes': cells, 'result': result}
+            if canonical(certificate['phases'][index]) != canonical(expected):
+                return False
+            old_groups = new_groups
+        return canonical(certificate['result']) == canonical(result)
+    except (ValueError, TypeError, KeyError, IndexError, AttributeError):
+        return False

tgi/unobserved_action_selection.py

@@ -0,0 +1,47 @@
+"""Source-complete acquisition coverage choice before a separator is observable."""
+from copy import deepcopy
+from hashlib import sha256
+from tgi.frame_engine import canonical
+from tgi.identity import encode
+from tgi.role_work import RoleSearchBudget
+from tgi.guarded_word_goal_frontier_check import verify_guarded_word_goal_frontier
+from tgi.guarded_word_goal_workflow import GuardedWordGoalWorkflow
+
+def certify_unobserved_action_selection(*args,frontier,max_search_steps=None):
+ b=RoleSearchBudget(max_search_steps)
+ with b.scope():
+  b.consume();frontier=deepcopy(frontier)
+  if not verify_guarded_word_goal_frontier(*args,goal=frontier['goal'],certificate=frontier,max_depth=frontier['max_depth']):raise ValueError('Complete original current task frontier required')
+  d=frontier['discovery'];coverage=[];bindings=[]
+  for action in d['available_actions']:
+   witnesses=[]
+   for li,item in enumerate(d['laws']):
+    if item['action']!=action:continue
+    c=item['certificate'];c=c['law'] if c['policy']=='observation_context_laws_v1' else c;matching=[]
+    for ri,row in enumerate(c['rows']):
+     b.consume()
+     if row['cells'][item['port']]['frames'][1]==action:matching.append(ri)
+    witnesses.append({'law_index':li,'port':item['port'],'matching_original_rows':matching})
+   unobserved=bool(witnesses) and len(witnesses)==len(d['state_certificate']['ports']) and all(not w['matching_original_rows'] for w in witnesses)
+   coverage.append({'action':action,'action_ids':list(encode(action)),'source_coverage':witnesses,'unobserved':unobserved})
+   indexes=[]
+   for ci,choice in enumerate(frontier['choices']):
+    b.consume()
+    if unobserved and choice['kind']=='FRONTIER_EXPERIENCE' and choice['actions']==[action] and len(choice['edges'])==1 and frontier['frontier']['edges'][choice['edges'][0]]['source']==0:indexes.append(ci)
+   if unobserved:bindings.append({'action':action,'choice_indexes':indexes})
+  ready=d['result']['catalogue_current'] and d['state_certificate']['result']['status']=='JOINT_STATE_READY'
+  eligible=[row for row in bindings if len(row['choice_indexes'])==1];unique=ready and len(bindings)==1 and len(eligible)==1
+  status='UNIQUE_UNOBSERVED_ACTION_SELECTION_READY' if unique else 'UNOBSERVED_ACTION_ALTERNATIVES_RETAINED' if bindings else 'NO_CURRENT_UNOBSERVED_ACTION'
+  return {'policy':'unobserved_action_selection_v1','frontier_sha256':sha256(canonical(frontier).encode()).hexdigest(),'coverage':coverage,'bindings':bindings,'result':{'status':status,'selected_action':eligible[0]['action'] if unique else None,'selected_choice_index':eligible[0]['choice_indexes'][0] if unique else None,'effect_predicted':False,'separation_claimed':False}}
+
+def select_unique_unobserved_action(workflow,*,max_search_steps=None):
+ from tgi.unobserved_action_selection_check import verify_unobserved_action_selection
+ b=RoleSearchBudget(max_search_steps)
+ with b.scope():
+  b.consume()
+  if type(workflow) is not GuardedWordGoalWorkflow or workflow.pending()['status']!='SELECTION_REQUIRED':raise ValueError('Owned unselected current workflow required')
+  args=workflow.context();f=workflow.frontier();c=certify_unobserved_action_selection(*args,frontier=f)
+  if not verify_unobserved_action_selection(*args,frontier=f,certificate=c) or c['result']['status']!='UNIQUE_UNOBSERVED_ACTION_SELECTION_READY':raise ValueError('Unique independently checked current acquisition obligation required')
+  result=workflow.select(c['result']['selected_choice_index'])
+  if result.pending()['action']!=c['result']['selected_action']:raise ValueError('Actual selection binding mismatch')
+  return result,c

tgi/unobserved_action_selection_check.py

@@ -0,0 +1,40 @@
+"""Independent complete original-row coverage and owned frontier selection verifier."""
+from hashlib import sha256
+from tgi.frame_engine import canonical
+from tgi.identity import encode
+from tgi.role_work import RoleSearchBudget
+from tgi.guarded_word_goal_frontier_check import verify_guarded_word_goal_frontier
+
+def verify_unobserved_action_selection(*args,frontier,certificate,max_search_steps=None):
+ b=RoleSearchBudget(max_search_steps)
+ with b.scope():
+  b.consume()
+  try:
+   if type(certificate) is not dict or set(certificate)!={'policy','frontier_sha256','coverage','bindings','result'} or certificate['policy']!='unobserved_action_selection_v1':return False
+   if not verify_guarded_word_goal_frontier(*args,goal=frontier['goal'],certificate=frontier,max_depth=frontier['max_depth']):return False
+   if certificate['frontier_sha256']!=sha256(canonical(frontier).encode()).hexdigest():return False
+   discovery=frontier['discovery'];coverage=[];bindings=[]
+   for action in discovery['available_actions']:
+    sources=[]
+    for li in range(len(discovery['laws'])):
+     law=discovery['laws'][li]
+     if law['action']!=action:continue
+     c=law['certificate'];c=c['law'] if c['policy']=='observation_context_laws_v1' else c;indexes=[]
+     for ri in range(len(c['rows'])):
+      b.consume()
+      if c['rows'][ri]['cells'][law['port']]['frames'][1]==action:indexes.append(ri)
+     sources.append({'law_index':li,'port':law['port'],'matching_original_rows':indexes})
+    missing=len(sources)==len(discovery['state_certificate']['ports']) and bool(sources) and not any(row['matching_original_rows'] for row in sources)
+    coverage.append({'action':action,'action_ids':list(encode(action)),'source_coverage':sources,'unobserved':missing})
+    choices=[]
+    for ci in range(len(frontier['choices'])):
+     b.consume();choice=frontier['choices'][ci]
+     if not missing or choice['kind']!='FRONTIER_EXPERIENCE' or choice['actions']!=[action] or len(choice['edges'])!=1:continue
+     if frontier['frontier']['edges'][choice['edges'][0]]['source']==0:choices.append(ci)
+    if missing:bindings.append({'action':action,'choice_indexes':choices})
+   eligible=[row for row in bindings if len(row['choice_indexes'])==1]
+   unique=discovery['result']['catalogue_current'] and discovery['state_certificate']['result']['status']=='JOINT_STATE_READY' and len(bindings)==1 and len(eligible)==1
+   status='UNIQUE_UNOBSERVED_ACTION_SELECTION_READY' if unique else 'UNOBSERVED_ACTION_ALTERNATIVES_RETAINED' if bindings else 'NO_CURRENT_UNOBSERVED_ACTION'
+   expected={'status':status,'selected_action':eligible[0]['action'] if unique else None,'selected_choice_index':eligible[0]['choice_indexes'][0] if unique else None,'effect_predicted':False,'separation_claimed':False}
+   return canonical(certificate['coverage'])==canonical(coverage) and canonical(certificate['bindings'])==canonical(bindings) and canonical(certificate['result'])==canonical(expected)
+  except (ValueError,KeyError,TypeError,IndexError,AttributeError):return False

tgi/verification.py

@@ -0,0 +1,98 @@
+"""Instrumented verification with complete-or-unverified matcher work."""
+from .incremental import SearchBudget, FormationSearchLimit, ACTIVE_SEARCH_BUDGET
+from .organization_check import verify_resolution, verify_refusal
+from .organization_snapshot import snapshot
+
+
+class _VerificationBudget(SearchBudget):
+    def __init__(self,limit,parent):
+        super().__init__(limit);self.parent=parent
+
+    def match_step(self):
+        # Preflight the child before charging any ancestor. Ancestors perform
+        # the same preflight, so rejected work is charged nowhere in the chain.
+        if self.limit is not None and self.used>=self.limit:
+            raise FormationSearchLimit(self.limit,self.used)
+        if self.parent is not None:self.parent.match_step()
+        super().match_step()
+
+
+def check_resolution(engine,prefix,result,*,terminal_only=False,max_match_steps=None):
+    budget=_VerificationBudget(max_match_steps,ACTIVE_SEARCH_BUDGET.get())
+    report={"status":"NOT_VERIFIED","verified":False,"match_steps":0,"max_match_steps":max_match_steps}
+    try:
+        with budget.scope():
+            if engine._dirty:return report
+            kind=result.get("status")
+            if kind not in ("RESOLVED","NO_PATH","AMBIGUOUS"):return report
+            frozen=snapshot(engine)
+            checker=verify_resolution if kind=="RESOLVED" else verify_refusal
+            verified=checker(frozen,prefix,result,terminal_only=terminal_only)
+            report.update(status="VERIFIED" if verified else "NOT_VERIFIED",verified=verified)
+    except FormationSearchLimit as error:
+        report.update(status="WORK_LIMIT",verified=False,exhausted_limit=error.limit)
+    except (KeyError,IndexError,TypeError,ValueError,AttributeError):
+        report.update(status="NOT_VERIFIED",verified=False)
+    finally:
+        report["match_steps"]=budget.matcher_used
+    return report
+
+
+def check_ask_certificate(engine, certificate, *, max_match_steps=None):
+    """Check complete search scope; exhausted work never proves absence."""
+    from .ask_certificate import verify_ask_certificate
+    budget = _VerificationBudget(max_match_steps, ACTIVE_SEARCH_BUDGET.get())
+    report = {"status": "NOT_VERIFIED", "verified": False,
+              "match_steps": 0, "max_match_steps": max_match_steps}
+    try:
+        with budget.scope():
+            if engine._dirty:
+                return report
+            verified = verify_ask_certificate(engine, certificate)
+            report.update(status="VERIFIED" if verified else "NOT_VERIFIED",
+                          verified=verified)
+    except FormationSearchLimit as error:
+        report.update(status="WORK_LIMIT", verified=False,
+                      exhausted_limit=error.limit)
+    except (KeyError, IndexError, TypeError, ValueError, AttributeError):
+        report.update(status="NOT_VERIFIED", verified=False)
+    finally:
+        report["match_steps"] = budget.matcher_used
+    return report
+
+
+class TemporalCandidateLimit(FormationSearchLimit):
+    """Separate work unit: pool candidate or Cartesian tuple examination."""
+
+
+class _TemporalCandidateBudget(SearchBudget):
+    def __init__(self,limit,parent):
+        super().__init__(limit);self.parent=parent
+
+    def consume(self):
+        if self.limit is not None and self.used>=self.limit:
+            raise TemporalCandidateLimit(self.limit,self.used)
+        if self.parent is not None:self.parent.consume()
+        super().consume()
+
+
+def check_recent_certificate(engine,certificate,*,max_match_steps=None,max_candidates=None):
+    """Verify temporal completeness under independent matcher/candidate ceilings."""
+    from .recent_observation import verify_recent_at,ACTIVE_TEMPORAL_CANDIDATES
+    matches=_VerificationBudget(max_match_steps,ACTIVE_SEARCH_BUDGET.get())
+    candidates=_TemporalCandidateBudget(max_candidates,ACTIVE_TEMPORAL_CANDIDATES.get())
+    report={'status':'NOT_VERIFIED','verified':False,'match_steps':0,'candidate_steps':0,
+            'max_match_steps':max_match_steps,'max_candidates':max_candidates}
+    token=ACTIVE_TEMPORAL_CANDIDATES.set(candidates)
+    try:
+        with matches.scope():
+            verified=verify_recent_at(engine,certificate)
+            report.update(status='VERIFIED' if verified else 'NOT_VERIFIED',verified=verified)
+    except TemporalCandidateLimit as error:
+        report.update(status='WORK_LIMIT',verified=False,exhausted_kind='candidates',exhausted_limit=error.limit)
+    except FormationSearchLimit as error:
+        report.update(status='WORK_LIMIT',verified=False,exhausted_kind='matcher',exhausted_limit=error.limit)
+    finally:
+        ACTIVE_TEMPORAL_CANDIDATES.reset(token)
+        report.update(match_steps=matches.matcher_used,candidate_steps=candidates.used)
+    return report

tgi/witness_function.py

@@ -0,0 +1,62 @@
+"""Conditional functional consensus over all measured candidate spans."""
+from .identity import encode,decode
+from .frame_engine import canonical
+from .organization_snapshot import snapshot
+from .role_work import RoleSearchBudget
+from .acquisition_witness import certify_acquisition_witness,verify_acquisition_witness
+from .response_eligibility import certify_response_eligibility
+from .functional_transition import certify_functional_eligibility,certify_functional_readout
+from .functional_transition_check import verify_functional_eligibility,_verify_functional_readout_contents
+
+from .witness_response import _root_index
+
+def certify_witness_function(model,measurements,root,query,*,max_search_steps=None):
+    budget=RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        view=snapshot(model);w=certify_acquisition_witness(view,measurements);i=_root_index(w['measurements'],root,query);neighbors=set()
+        for pair in w['pairs']:
+            budget.consume()
+            if i in (pair['left'],pair['right']):neighbors.add(pair['right'] if pair['left']==i else pair['left'])
+        eligibility=certify_functional_eligibility(view,certify_response_eligibility(view))
+        branches=[]
+        for j in sorted(neighbors):
+            budget.consume();r=w['measurements'][j];context=decode(tuple(w['occurrences'][j]['identities']))
+            branches.append({'measurement':dict(r),'response':certify_functional_readout(view,eligibility,[context,query])})
+        alternatives=sorted({x for b in branches for x in b['response']['result']['output']});complete=bool(branches) and all(b['response']['result']['status'] in ('OBSERVED_RESPONSE','CONDITIONAL_FUNCTION') for b in branches)
+        observed_conflict=any(b['response']['result']['basis']=='observed_conflict' for b in branches)
+        status='NO_CANDIDATES' if not branches else 'CONFLICT' if len(alternatives)>1 or observed_conflict else 'CONDITIONAL_FUNCTION_CONSENSUS' if complete and len(alternatives)==1 else 'UNRESOLVED'
+        return {'policy':'witness_function_response_v1','root':dict(root),'query':query,'witness':w,'branches':branches,'result':{'status':status,'output':alternatives if status=='CONDITIONAL_FUNCTION_CONSENSUS' else [],'alternatives':alternatives}}
+
+def verify_witness_function(model,measurements,root,query,certificate,*,max_search_steps=None):
+    budget=RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        try:
+            view=snapshot(model)
+            if set(certificate)!={'policy','root','query','witness','branches','result'} or certificate['policy']!='witness_function_response_v1':return False
+            if canonical(certificate['root'])!=canonical(root) or certificate['query']!=query:return False
+            if not verify_acquisition_witness(view,measurements,certificate['witness']):return False
+            records=certificate['witness']['measurements'];i=_root_index(records,root,query);r=records[i];selected=[]
+            for j,other in enumerate(records):
+                budget.consume()
+                if other['source']!=r['source'] and other['clock']==r['clock'] and other['lower']<=r['upper'] and r['lower']<=other['upper']:selected.append(other)
+            branches=certificate['branches']
+            if not isinstance(branches,list) or len(branches)!=len(selected):return False
+            values=set();all_agree=True;conflict=False;verified_eligibility=None
+            for other,b in zip(selected,branches):
+                budget.consume()
+                if set(b)!={'measurement','response'} or canonical(b['measurement'])!=canonical(other):return False
+                raw=view.episodes[other['source']][0][other['frame']][other['start']:other['stop']]
+                eligibility=b['response']['eligibility']
+                if verified_eligibility is None:
+                    if not verify_functional_eligibility(view,eligibility):return False
+                    verified_eligibility=canonical(eligibility)
+                elif canonical(eligibility)!=verified_eligibility:return False
+                if b['response']['readout']['prefix']!=[decode(raw),query] or not _verify_functional_readout_contents(view,b['response']):return False
+                values.update(b['response']['result']['output']);all_agree &= b['response']['result']['status'] in ('OBSERVED_RESPONSE','CONDITIONAL_FUNCTION')
+                conflict |= b['response']['result']['basis']=='observed_conflict'
+            status='UNRESOLVED';output=[]
+            if not selected:status='NO_CANDIDATES'
+            elif len(values)>1 or conflict:status='CONFLICT'
+            elif all_agree and len(values)==1:status='CONDITIONAL_FUNCTION_CONSENSUS';output=sorted(values)
+            return canonical(certificate['result'])==canonical({'status':status,'output':output,'alternatives':sorted(values)})
+        except (ValueError,TypeError,KeyError,IndexError,AttributeError):return False

tgi/witness_probe.py

@@ -0,0 +1,50 @@
+"""Complete conditional probe planning over measured candidate occurrences."""
+from .identity import decode
+from .frame_engine import canonical
+from .organization_snapshot import snapshot
+from .role_work import RoleSearchBudget
+from .acquisition_witness import certify_acquisition_witness,verify_acquisition_witness
+from .witness_response import _measured_root_index
+from .witness_function import certify_witness_function,verify_witness_function
+
+def certify_witness_probe(model,measurements,root,*,max_search_steps=None):
+    budget=RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        view=snapshot(model);w=certify_acquisition_witness(view,measurements);_measured_root_index(w['measurements'],root);rows=[];admitted=[]
+        queries=sorted({decode(frames[-2]) for frames,_ in view.episodes.values() if len(frames)>=3})
+        for query in queries:
+            budget.consume();c=certify_witness_function(view,measurements,root,query);groups={};complete=True
+            for i,b in enumerate(c['branches']):
+                r=b['response']['result'];complete &= r['status'] in ('CONDITIONAL_FUNCTION','OBSERVED_RESPONSE')
+                if r['output']:groups.setdefault(tuple(r['output']),[]).append(i)
+            count=len(c['branches']);separates=count>1 and complete and all(len(ids)<count for ids in groups.values())
+            rows.append({'query':query,'certificate':c,'groups':[{'response':list(v),'branches':ids} for v,ids in sorted(groups.items())],'separates':separates})
+            if separates:admitted.append(query)
+        return {'policy':'measured_probe_plan_v1','root':dict(root),'witness':w,'requests':rows,'result':{'status':'SEPARATING' if admitted else 'NO_SEPARATOR','requests':admitted}}
+
+def verify_witness_probe(model,measurements,root,certificate,*,max_search_steps=None):
+    budget=RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        try:
+            view=snapshot(model)
+            if set(certificate)!={'policy','root','witness','requests','result'} or certificate['policy']!='measured_probe_plan_v1' or canonical(certificate['root'])!=canonical(root):return False
+            w=certificate['witness']
+            if not verify_acquisition_witness(view,measurements,w):return False
+            _measured_root_index(w['measurements'],root)
+            queries=sorted(set(decode(frames[-2]) for frames,_ in view.episodes.values() if len(frames)>=3));rows=certificate['requests']
+            if not isinstance(rows,list) or len(rows)!=len(queries):return False
+            admitted=[]
+            for query,row in zip(queries,rows):
+                budget.consume()
+                if set(row)!={'query','certificate','groups','separates'} or row['query']!=query:return False
+                c=row['certificate']
+                if canonical(c['witness'])!=canonical(w) or not verify_witness_function(view,measurements,root,query,c):return False
+                answers=[];complete=bool(c['branches'])
+                for b in c['branches']:
+                    r=b['response']['result'];complete &= r['status'] in ('CONDITIONAL_FUNCTION','OBSERVED_RESPONSE');answers.append(r['output'])
+                values=sorted({tuple(a) for a in answers if a});groups=[{'response':list(v),'branches':[i for i,a in enumerate(answers) if tuple(a)==v]} for v in values]
+                separates=len(answers)>1 and complete and len(values)>1 and all(len(g['branches'])<len(answers) for g in groups)
+                if canonical(row['groups'])!=canonical(groups) or type(row['separates']) is not bool or row['separates']!=separates:return False
+                if separates:admitted.append(query)
+            return canonical(certificate['result'])==canonical({'status':'SEPARATING' if admitted else 'NO_SEPARATOR','requests':admitted})
+        except (KeyError,IndexError,TypeError,ValueError,AttributeError):return False