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

tgi/actuation_goal_workflow.py

@@ -0,0 +1,159 @@
+"""Owned catalogue-aware selection, retained actual sessions and atomic recovery."""
+from copy import deepcopy
+from hashlib import sha256
+import json,os,re,tempfile
+from pathlib import Path
+from .observed_actuation_runtime import ObservedActuationRuntime,raw
+from .actuation_goal_frontier import certify_actuation_goal_frontier
+from .actuation_goal_frontier_check import verify_actuation_goal_frontier
+from .actuation_sequence_feedback import certify_actuation_sequence_feedback
+from .actuation_sequence_feedback_check import verify_actuation_sequence_feedback,same_state_context
+from .organization import RawOrganization
+from .organization_snapshot import snapshot
+from .organization_inventory_check import verify_organization_inventory
+from .identity import REGISTRY_ID
+from .frame_engine import canonical,unique_object
+from .role_work import RoleSearchBudget
+from .incremental import FormationSearchLimit
+REVISION='TGI-ACTUATION-GOAL-WORKFLOW-V1'
+FIELDS={'origin','frontier','selection_index','records','current','current_plan','current_frontier','feedback'}
+
+def verify_session(s,goal,max_depth,budget):
+    budget.consume()
+    if type(s) is not dict or set(s)!=FIELDS or len(s['origin'])!=9 or len(s['current'])!=9 or type(s['records']) is not list:return False
+    for args in (s['origin'],s['current']):
+        if not verify_organization_inventory(snapshot(args[0])):return False
+    if not verify_actuation_goal_frontier(*s['origin'],goal,s['frontier'],max_depth=max_depth) or not verify_actuation_goal_frontier(*s['current'],goal,s['current_frontier'],max_depth=max_depth):return False
+    if canonical(s['current_frontier']['discovery'])!=canonical(s['current_plan']):return False
+    if s['selection_index'] is None:return not s['records'] and s['feedback'] is None and same_state_context(s['origin'],s['current'],budget)
+    return verify_actuation_sequence_feedback(s['origin'],goal,s['frontier'],s['selection_index'],s['records'],s['current'],s['current_plan'],s['feedback'],max_depth=max_depth)
+
+def verify_sessions(archived,active,goal,max_depth,budget):
+    if type(archived) is not list:return False
+    previous=None
+    for s in [*archived,active]:
+        if not verify_session(s,goal,max_depth,budget) or (previous is not None and not same_state_context(previous,s['origin'],budget)):return False
+        previous=s['current']
+    return True
+
+class ActuationGoalWorkflow:
+    def __init__(self,runtime,goal,*,max_depth=None,max_search_steps=None):
+        b=RoleSearchBudget(max_search_steps)
+        with b.scope():
+            b.consume();self._runtime=deepcopy(runtime);self._goal=deepcopy(goal);self._depth=max_depth;args=self._runtime.context();frontier=certify_actuation_goal_frontier(*args,goal,max_depth=max_depth)
+            self._active={'origin':args,'frontier':frontier,'selection_index':None,'records':[],'current':deepcopy(args),'current_plan':self._runtime.plan(),'current_frontier':deepcopy(frontier),'feedback':None};self._archived=[]
+            if not verify_sessions(self._archived,self._active,self._goal,self._depth,b):raise ValueError('Verified complete native goal workflow required')
+    def frontier(self):return deepcopy(self._active['current_frontier'])
+    def feedback(self):return deepcopy(self._active['feedback'])
+    def runtime(self):return deepcopy(self._runtime)
+    def sessions(self):return deepcopy([*self._archived,self._active])
+    def select(self,index,*,max_search_steps=None):
+        b=RoleSearchBudget(max_search_steps)
+        with b.scope():
+            b.consume()
+            if self._active['selection_index'] is not None or self._active['records']:raise ValueError('Replan before selecting another complete sequence')
+            obj=self.replan() if canonical(self._active['frontier'])!=canonical(self._active['current_frontier']) else deepcopy(self);obj._active['selection_index']=index;obj._active['feedback']=certify_actuation_sequence_feedback(obj._active['origin'],obj._goal,obj._active['frontier'],index,[],obj._active['current'],obj._active['current_plan'],max_depth=obj._depth)
+            if not verify_sessions(obj._archived,obj._active,obj._goal,obj._depth,b):raise ValueError('Independent selected workflow verification failed')
+            return obj
+    def pending(self):
+        s=self._active
+        if s['selection_index'] is None:return {'status':'SELECTION_REQUIRED','action':None,'position':0}
+        f=s['feedback']['result'];position=f['consumed_steps']
+        if f['terminal']:return {'status':f['status'],'action':None,'position':position}
+        choice=s['frontier']['choices'][s['selection_index']];action=choice['actions'][position];p=s['current_plan']
+        status='FRESH_CATALOGUE_REQUIRED' if not p['result']['catalogue_current'] else 'PLANNED_ACTION_UNAVAILABLE' if action not in p['available_actions'] else 'ACTUAL_TRANSITION_READY'
+        return {'status':status,'action':action,'position':position}
+    def _renew(self,runtime):
+        obj=deepcopy(self);obj._runtime=runtime;obj._active['current']=runtime.context();obj._active['current_plan']=runtime.plan();obj._active['current_frontier']=certify_actuation_goal_frontier(*obj._active['current'],obj._goal,max_depth=obj._depth)
+        if obj._active['selection_index'] is not None:obj._active['feedback']=certify_actuation_sequence_feedback(obj._active['origin'],obj._goal,obj._active['frontier'],obj._active['selection_index'],obj._active['records'],obj._active['current'],obj._active['current_plan'],max_depth=obj._depth)
+        return obj
+    def advance(self,acquired,groups,measurements,group_index,*,catalogue=None,catalogue_measurements=None,max_search_steps=None):
+        b=RoleSearchBudget(max_search_steps)
+        with b.scope():
+            b.consume();pending=self.pending()
+            if pending['status']!='ACTUAL_TRANSITION_READY':raise ValueError('Selected, available, current nonterminal action required')
+            args=self._runtime.context();p=self._runtime.plan();index=p['available_actions'].index(pending['action']);context=(*args,p,index,acquired,groups,measurements,group_index);next,c=self._runtime.advance(index,acquired,groups,measurements,group_index,catalogue=catalogue,catalogue_measurements=catalogue_measurements)
+            if next is None:return None,c
+            obj=deepcopy(self);obj._active['records'].append(deepcopy({'context':context,'after':next.context()[0],'certificate':c}));obj=obj._renew(next)
+            if not verify_sessions(obj._archived,obj._active,obj._goal,obj._depth,b):raise ValueError('Independent actual workflow verification failed')
+            return obj,c
+    def refresh_catalogue(self,catalogue,measurements,*,max_search_steps=None):
+        b=RoleSearchBudget(max_search_steps)
+        with b.scope():
+            b.consume();obj=self._renew(self._runtime.refresh_catalogue(catalogue,measurements))
+            if not verify_sessions(obj._archived,obj._active,obj._goal,obj._depth,b):raise ValueError('Independent catalogue refresh verification failed')
+            return obj
+    def replan(self,*,max_search_steps=None):
+        b=RoleSearchBudget(max_search_steps)
+        with b.scope():
+            b.consume();obj=type(self)(self._runtime,self._goal,max_depth=self._depth);obj._archived=deepcopy([*self._archived,self._active])
+            if not verify_sessions(obj._archived,obj._active,obj._goal,obj._depth,b):raise ValueError('Independent retained session verification failed')
+            return obj
+    def commit(self,path,*,max_search_steps=None):
+        b=RoleSearchBudget(max_search_steps)
+        with b.scope():
+            b.consume();archived,active=deepcopy((self._archived,self._active))
+            if not verify_sessions(archived,active,self._goal,self._depth,b):raise ValueError('Complete independently verified workflow required')
+            models=[];known={}
+            def model_id(m):
+                rows=raw(m);key=canonical(rows);b.consume_many(sum(len(f) for row in rows for f in row['frames'])+1)
+                if key not in known:known[key]=len(models);models.append(rows)
+                return {'model':known[key]}
+            def context(args):return [model_id(v) if i in ((0,3,7) if len(args)==9 else (0,3,7,11)) else v for i,v in enumerate(args)]
+            def session(s):return {**s,'origin':context(s['origin']),'current':context(s['current']),'records':[{'context':context(r['context']),'after':model_id(r['after']),'certificate':r['certificate']} for r in s['records']]}
+            saved_archived=[session(s) for s in archived];saved_active=session(active);payload={'revision':REVISION,'registry':REGISTRY_ID,'goal':deepcopy(self._goal),'max_depth':self._depth,'root_origin':context((archived[0] if archived else active)['origin']),'models':models,'archived':saved_archived,'active':saved_active};data=canonical({'payload':payload,'sha256':sha256(canonical(payload).encode()).hexdigest()}).encode('utf8');path=Path(path);temporary=None
+            try:
+                with tempfile.NamedTemporaryFile(mode='wb',prefix='tgi-goal-',dir=path.parent,delete=False) as f:temporary=Path(f.name);f.write(data);f.flush();os.fsync(f.fileno())
+                os.replace(temporary,path);temporary=None
+            finally:
+                if temporary is not None and temporary.exists():temporary.unlink()
+            return {'path':str(path),'sha256':sha256(data).hexdigest(),'bytes':len(data),'revision':REVISION,'raw_inventory_models':len(models),'archived_sessions':len(archived),'actual_records':sum(len(s['records']) for s in [*archived,active])}
+    @classmethod
+    def recover(cls,path,expected_sha256,*,max_search_steps=None):
+        b=RoleSearchBudget(max_search_steps)
+        with b.scope():
+            b.consume();data=Path(path).read_bytes()
+            if not isinstance(expected_sha256,str) or re.fullmatch('[0-9a-f]{64}',expected_sha256) is None or sha256(data).hexdigest()!=expected_sha256:raise ValueError('Original external workflow byte digest required')
+            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 workflow envelope')
+            p=envelope['payload']
+            if type(p) is not dict or set(p)!={'revision','registry','goal','max_depth','root_origin','models','archived','active'} or p['revision']!=REVISION or p['registry']!=REGISTRY_ID or sha256(canonical(p).encode()).hexdigest()!=envelope['sha256']:raise ValueError('Invalid complete workflow payload')
+            if type(p['models']) is not list or not p['models']:raise ValueError('Original raw inventory pool required')
+            models=[];unique=set()
+            for rows in p['models']:
+                if type(rows) is not list or canonical(rows) in unique:raise ValueError('Unique complete raw inventory pool required')
+                unique.add(canonical(rows));m=RawOrganization()
+                for row in rows:
+                    if type(row) is not dict or set(row)!={'source','frames'} or type(row['frames']) is not list:raise ValueError('Original raw episode required')
+                    b.consume_many(sum(len(f) for f in row['frames'])+1);m.observe(row['source'],row['frames'])
+                limits=[];parent=b
+                while parent is not None:
+                    if parent.limit is not None:limits.append(max(0,parent.limit-parent.used))
+                    parent=getattr(parent,'parent',None)
+                try:m.form(max_search_steps=min(limits) if limits else None)
+                except FormationSearchLimit as error:b.consume_many(error.used);b.consume();raise
+                b.consume_many(m.formation_work['search_steps']);models.append(m)
+            used=set()
+            def model(marker):
+                if type(marker) is not dict or set(marker)!={'model'} or type(marker['model']) is not int or not 0<=marker['model']<len(models):raise ValueError('Exact original model slot required')
+                used.add(marker['model']);return models[marker['model']]
+            def context(args,size):
+                if type(args) is not list or len(args)!=size:raise ValueError('Complete original model context required')
+                for i in ((0,3,7) if size==9 else (0,3,7,11)):args[i]=model(args[i])
+                return tuple(args)
+            def session(s):
+                if type(s) is not dict or set(s)!=FIELDS or type(s['records']) is not list:raise ValueError('Complete original session required')
+                s['origin']=context(s['origin'],9);s['current']=context(s['current'],9)
+                for r in s['records']:
+                    if type(r) is not dict or set(r)!={'context','after','certificate'}:raise ValueError('Complete original actual transition required')
+                    r['context']=context(r['context'],15);r['after']=model(r['after'])
+                return s
+            if type(p['archived']) is not list:raise ValueError('Ordered retained sessions required')
+            archived=[session(s) for s in p['archived']];active=session(p['active']);root_origin=context(p['root_origin'],9)
+            first=(archived[0] if archived else active)['origin']
+            if not same_state_context(root_origin,first,b) or canonical(root_origin[8])!=canonical(first[8]) or canonical(raw(root_origin[7]))!=canonical(raw(first[7])):raise ValueError('Original root session binding required')
+            if used!=set(range(len(models))) or not verify_sessions(archived,active,p['goal'],p['max_depth'],b):raise ValueError('Independent full workflow recovery verification failed')
+            obj=cls.__new__(cls);obj._goal=p['goal'];obj._depth=p['max_depth'];obj._archived=archived;obj._active=active;runtime=ObservedActuationRuntime.__new__(ObservedActuationRuntime);runtime._args=tuple(active['current']);runtime._plan=active['current_plan'];runtime._transaction=None
+            for s in [*archived,active]:
+                for r in s['records']:runtime._transaction=(tuple(r['context']),r['after'],r['certificate'])
+            obj._runtime=runtime;return obj

tgi/actuation_sequence_feedback.py

@@ -0,0 +1,41 @@
+"""Original choice, actual available-command records and coherent sequence outcome."""
+from copy import deepcopy
+from .actuation_goal_frontier_check import verify_actuation_goal_frontier
+from .measured_actuation_transition_check import verify_measured_actuation_transition
+from .observed_actuation_discovery_check import verify_observed_actuation_discovery
+from .observed_actuation_runtime import raw
+from .joint_goal_traversal import _seed_routes
+from .frame_engine import canonical
+from .role_work import RoleSearchBudget
+
+def same_state_context(a,b,budget):
+    budget.consume()
+    return len(a)>=7 and len(b)>=7 and all(canonical(raw(a[i]))==canonical(raw(b[i])) for i in (0,3)) and canonical([a[1],a[2],a[4],a[5],a[6]])==canonical([b[1],b[2],b[4],b[5],b[6]])
+
+def certify_actuation_sequence_feedback(origin,goal,frontier,selection_index,records,current,current_plan,*,max_depth=None,max_search_steps=None):
+    budget=RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        budget.consume()
+        if len(origin)!=9 or len(current)!=9 or not verify_actuation_goal_frontier(*origin,goal,frontier,max_depth=max_depth):raise ValueError('Original verified available-command frontier required')
+        if type(selection_index) is not int or not 0<=selection_index<len(frontier['choices']):raise ValueError('Original exact choice index required')
+        if not verify_observed_actuation_discovery(*current,current_plan):raise ValueError('Verified current actual state/capability plan required')
+        choice=frontier['choices'][selection_index];previous=origin;steps=[];status='SELECTED_SEQUENCE_PENDING';terminal=False
+        if not choice['actions']:status='GOAL_ALREADY_ACTUALLY_OBSERVED';terminal=True
+        for position,record in enumerate(records):
+            budget.consume()
+            if terminal or position>=len(choice['actions']) or type(record) is not dict or set(record)!={'context','after','certificate'}:raise ValueError('No extra, malformed or post-terminal record')
+            context=record['context'];after=record['after'];c=record['certificate']
+            if len(context)!=15 or not same_state_context(context,previous,budget) or not verify_measured_actuation_transition(*context,after,c) or not c['result']['experience_admitted']:raise ValueError('Complete linked actual transition required')
+            edge=frontier['edges'][choice['edges'][position]];before=frontier['nodes'][edge['source']]['state']
+            if canonical(context[9]['state_certificate']['state'])!=canonical(before) or c['selected_action']!=choice['actions'][position] or c['selected_action']!=edge['action']:raise ValueError('Original selected before state and command required')
+            expected=frontier['nodes'][edge['successor']]['state'] if edge['supported'] else None;actual=c['result']['actual_state'];route='UNRESOLVED' if expected is None else 'MATCHED' if actual==expected else 'CONTRADICTED'
+            if expected is None:status='FRONTIER_EXPERIENCE_ACTUALLY_VERIFIED';terminal=True
+            elif route!='MATCHED' or c['result']['prediction_outcome']!='MATCHED' or canonical(c['predicted_state'])!=canonical(expected):status='ACTUAL_EVIDENCE_REPLAN_REQUIRED';terminal=True
+            elif position+1==len(choice['actions']):status='SUPPORTED_GOAL_ACTUALLY_VERIFIED' if choice['kind']=='SUPPORTED_GOAL' else 'SUPPORTED_PREFIX_ACTUALLY_VERIFIED';terminal=True
+            else:status='SUPPORTED_PREFIX_PROGRESS_VERIFIED'
+            steps.append({'position':position,'edge':choice['edges'][position],'selected_action':c['selected_action'],'projected_after':deepcopy(expected),'current_prediction':deepcopy(c['predicted_state']),'actual_state':deepcopy(actual),'route_outcome':route,'current_prediction_outcome':c['result']['prediction_outcome'],'actual_lineage_routes':_seed_routes(c['next_state'],budget),'transition':deepcopy(c)})
+            h=c['history'];anchor=h.get('acquired_group_indices',list(range(len(context[1]),len(context[1])+len(context[12]))))[context[14]];previous=(after,h['groups'],h['measurements'],after,h['groups'],h['measurements'],anchor)
+        if not same_state_context(current,previous,budget):raise ValueError('Original complete last actual successor required')
+        state=current_plan['state_certificate'];observed=state['result']['status']=='JOINT_STATE_READY' and all(state['state'][p]==v for p,v in goal.items());verified=terminal and status in ('GOAL_ALREADY_ACTUALLY_OBSERVED','SUPPORTED_GOAL_ACTUALLY_VERIFIED','SUPPORTED_PREFIX_ACTUALLY_VERIFIED')
+        result={'status':status,'consumed_steps':len(steps),'remaining_steps':len(choice['actions'])-len(steps),'terminal':terminal,'selected_supported_path_actually_verified':verified,'actual_goal_observed':bool(observed),'catalogue_current':current_plan['result']['catalogue_current']}
+        return {'policy':'actuation_sequence_feedback_v1','frontier':deepcopy(frontier),'selection_index':selection_index,'current_discovery':deepcopy(current_plan),'steps':steps,'result':result}

tgi/actuation_sequence_feedback_check.py

@@ -0,0 +1,43 @@
+"""Original choice, actual available-command records and coherent sequence outcome."""
+from .actuation_goal_frontier_check import verify_actuation_goal_frontier
+from .measured_actuation_transition_check import verify_measured_actuation_transition
+from .observed_actuation_discovery_check import verify_observed_actuation_discovery
+from .observed_actuation_runtime import raw
+from .joint_goal_traversal_check import _initial_owners
+from .frame_engine import canonical
+from .role_work import RoleSearchBudget
+
+def same_state_context(a,b,budget):
+    budget.consume()
+    return len(a)>=7 and len(b)>=7 and all(canonical(raw(a[i]))==canonical(raw(b[i])) for i in (0,3)) and canonical([a[1],a[2],a[4],a[5],a[6]])==canonical([b[1],b[2],b[4],b[5],b[6]])
+
+def verify_actuation_sequence_feedback(origin,goal,frontier,selection_index,records,current,current_plan,certificate,*,max_depth=None,max_search_steps=None):
+    budget=RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        try:
+            budget.consume()
+            if len(origin)!=9 or len(current)!=9 or not verify_actuation_goal_frontier(*origin,goal,frontier,max_depth=max_depth):raise ValueError('Original verified available-command frontier required')
+            if type(selection_index) is not int or not 0<=selection_index<len(frontier['choices']):raise ValueError('Original exact choice index required')
+            if not verify_observed_actuation_discovery(*current,current_plan):raise ValueError('Verified current actual state/capability plan required')
+            choice=frontier['choices'][selection_index];previous=origin;steps=[];status='SELECTED_SEQUENCE_PENDING';terminal=False
+            if not choice['actions']:status='GOAL_ALREADY_ACTUALLY_OBSERVED';terminal=True
+            for position,record in enumerate(records):
+                budget.consume()
+                if terminal or position>=len(choice['actions']) or type(record) is not dict or set(record)!={'context','after','certificate'}:raise ValueError('No extra, malformed or post-terminal record')
+                context=record['context'];after=record['after'];c=record['certificate']
+                if len(context)!=15 or not same_state_context(context,previous,budget) or not verify_measured_actuation_transition(*context,after,c) or not c['result']['experience_admitted']:raise ValueError('Complete linked actual transition required')
+                edge=frontier['edges'][choice['edges'][position]];before=frontier['nodes'][edge['source']]['state']
+                if canonical(context[9]['state_certificate']['state'])!=canonical(before) or c['selected_action']!=choice['actions'][position] or c['selected_action']!=edge['action']:raise ValueError('Original selected before state and command required')
+                expected=frontier['nodes'][edge['successor']]['state'] if edge['supported'] else None;actual=c['result']['actual_state'];route='UNRESOLVED' if expected is None else 'MATCHED' if actual==expected else 'CONTRADICTED'
+                if expected is None:status='FRONTIER_EXPERIENCE_ACTUALLY_VERIFIED';terminal=True
+                elif route!='MATCHED' or c['result']['prediction_outcome']!='MATCHED' or canonical(c['predicted_state'])!=canonical(expected):status='ACTUAL_EVIDENCE_REPLAN_REQUIRED';terminal=True
+                elif position+1==len(choice['actions']):status='SUPPORTED_GOAL_ACTUALLY_VERIFIED' if choice['kind']=='SUPPORTED_GOAL' else 'SUPPORTED_PREFIX_ACTUALLY_VERIFIED';terminal=True
+                else:status='SUPPORTED_PREFIX_PROGRESS_VERIFIED'
+                steps.append({'position':position,'edge':choice['edges'][position],'selected_action':c['selected_action'],'projected_after':expected,'current_prediction':c['predicted_state'],'actual_state':actual,'route_outcome':route,'current_prediction_outcome':c['result']['prediction_outcome'],'actual_lineage_routes':_initial_owners(c['next_state'],budget),'transition':c})
+                h=c['history'];anchor=h.get('acquired_group_indices',list(range(len(context[1]),len(context[1])+len(context[12]))))[context[14]];previous=(after,h['groups'],h['measurements'],after,h['groups'],h['measurements'],anchor)
+            if not same_state_context(current,previous,budget):raise ValueError('Original complete last actual successor required')
+            state=current_plan['state_certificate'];observed=state['result']['status']=='JOINT_STATE_READY' and all(state['state'][p]==v for p,v in goal.items());verified=terminal and status in ('GOAL_ALREADY_ACTUALLY_OBSERVED','SUPPORTED_GOAL_ACTUALLY_VERIFIED','SUPPORTED_PREFIX_ACTUALLY_VERIFIED')
+            result={'status':status,'consumed_steps':len(steps),'remaining_steps':len(choice['actions'])-len(steps),'terminal':terminal,'selected_supported_path_actually_verified':verified,'actual_goal_observed':bool(observed),'catalogue_current':current_plan['result']['catalogue_current']}
+            expected_certificate={'policy':'actuation_sequence_feedback_v1','frontier':frontier,'selection_index':selection_index,'current_discovery':current_plan,'steps':steps,'result':result}
+            return canonical(certificate)==canonical(expected_certificate)
+        except (ValueError,TypeError,KeyError,IndexError,AttributeError):return False

tgi/ask_certificate.py

@@ -0,0 +1,74 @@
+"""Complete prefix-scope certificate for raw stored-context search."""
+from .identity import encode,decode
+from .frame_engine import canonical
+from .organization_snapshot import snapshot
+from .organization_check import verify_resolution,verify_refusal,_verify_refusal_view
+
+
+def certify_ask(engine, raw):
+    encode(raw)
+    if not raw:raise ValueError('Empty query')
+    view=snapshot(engine)
+    lengths={len(h.pattern)-2 for h in view.organizations.values()}
+    lengths.update(len(h.pattern)-2 for h,_ in view.rejected_organizations.values())
+    prefixes={():[]} if 0 in lengths else {}
+    for sid,(frames,_) in view.episodes.items():
+        for count in lengths:
+            if 0<count<=len(frames):prefixes.setdefault(tuple(decode(f) for f in frames[:count]),[]).append(sid)
+    rows=[];outputs=set();uncertain=False;broken=False
+    for prefix,sources in sorted(prefixes.items()):
+        r=view.resolve(prefix+(raw,))
+        if r['status']!='NO_PATH':
+            live=[sid for sid in sources if view._alive(sid)]
+            if sources and not live:broken=True
+            else:
+                broken |= r['status']=='INCOMPLETE'
+                uncertain |= r['status']=='AMBIGUOUS'
+                if r['status']=='RESOLVED':outputs.add(tuple(r['output']))
+        if r['status']=='RESOLVED':r={k:r[k] for k in ('status','output','proofs')}
+        rows.append({'prefix':list(prefix),'sources':sorted(sources),'resolution':r})
+    status='INCOMPLETE' if broken else 'CONFLICT' if len(outputs)>1 else 'AMBIGUOUS' if uncertain else 'RESOLVED' if outputs else 'NO_PATH'
+    result={'status':status,'output':list(next(iter(outputs))) if status=='RESOLVED' else [],'candidates':[list(x) for x in sorted(outputs)]}
+    return {'query':raw,'result':result,'search':rows}
+
+
+def _verify_ask_certificate_view(engine, certificate):
+    from .organization_snapshot import _Snapshot
+    try:
+        if type(engine) is not _Snapshot or engine._dirty or set(certificate)!={'query','result','search'}:return False
+        raw=certificate['query'];encode(raw)
+        if not raw:return False
+        sizes=set()
+        for h in engine.organizations.values():sizes.add(len(h.pattern)-2)
+        for h,_ in engine.rejected_organizations.values():sizes.add(len(h.pattern)-2)
+        scope={():set()} if 0 in sizes else {}
+        for sid,(frames,_) in engine.episodes.items():
+            for n in sizes:
+                if 0<n<=len(frames):scope.setdefault(tuple(decode(f) for f in frames[:n]),set()).add(sid)
+        rows=certificate['search']
+        if len(rows)!=len(scope):return False
+        outputs=set();uncertain=False
+        for row,(prefix,sources) in zip(rows,sorted(scope.items())):
+            if set(row)!={'prefix','sources','resolution'}:return False
+            if canonical(row['prefix'])!=canonical(list(prefix)) or canonical(row['sources'])!=canonical(sorted(sources)):return False
+            if not all(engine._alive(sid) for sid in sources):return False
+            r=row['resolution'];status=r['status'];trigger=list(prefix)+[raw]
+            if status=='RESOLVED':
+                if set(r)!={'status','output','proofs'} or not verify_resolution(engine,trigger,r):return False
+                outputs.add(tuple(r['output']))
+            elif status in ('NO_PATH','AMBIGUOUS'):
+                if not _verify_refusal_view(engine,trigger,r):return False
+                uncertain |= status=='AMBIGUOUS'
+            else:return False
+        status='CONFLICT' if len(outputs)>1 else 'AMBIGUOUS' if uncertain else 'RESOLVED' if outputs else 'NO_PATH'
+        expected={'status':status,'output':list(next(iter(outputs))) if status=='RESOLVED' else [],'candidates':[list(x) for x in sorted(outputs)]}
+        return canonical(certificate['result'])==canonical(expected)
+    except (KeyError,IndexError,TypeError,ValueError,AttributeError):return False
+
+
+def verify_ask_certificate(engine, certificate):
+    """Fresh public evidence boundary; never reuse a caller's cached admission."""
+    try:
+        return _verify_ask_certificate_view(snapshot(engine), certificate)
+    except (KeyError, IndexError, TypeError, ValueError, AttributeError):
+        return False

tgi/bands.py

@@ -0,0 +1,59 @@
+"""8 C + 8 L disjoint ownership of character-clock constraint blocks.
+
+This is the declared TGI candidate, not a copy of the VEYRA MULTIPITA cell.
+"""
+from dataclasses import dataclass
+from .exact_field import Field
+
+
+@dataclass(frozen=True)
+class Block:
+    start: int
+    stop: int
+    field: Field
+
+
+class Bands:
+    def __init__(self):
+        self.clock = 0
+        self._banks = [None]*16
+        self.merges = [0]*16
+
+    def tick(self, field=Field()):
+        carry = Block(self.clock,self.clock+1,field)
+        self.clock += 1
+        for index in range(16):
+            old = self._banks[index]
+            if old is None:
+                self._banks[index] = carry
+                return
+            if old.stop != carry.start:
+                raise RuntimeError("Noncontiguous band ownership")
+            carry = Block(old.start,carry.stop,old.field.merge(carry.field))
+            self.merges[index] += 1
+            if index == 15:
+                self._banks[index] = carry
+                return
+            self._banks[index] = None
+
+    def feed(self, identities, final_field):
+        if not identities:
+            raise ValueError("A measurement frame must have character events")
+        for i in range(len(identities)):
+            self.tick(final_field if i == len(identities)-1 else Field())
+
+    def field(self, excluded=()):
+        result = Field()
+        for i,block in enumerate(self._banks):
+            if block is not None and i not in excluded:
+                result = result.merge(block.field)
+        return result
+
+    def blocks(self):
+        return tuple((i,block) for i,block in enumerate(self._banks) if block is not None)
+
+    def inspect(self):
+        return [{"owner":("C"+str(i)) if i<8 else ("L"+str(i-8)),
+                 "index":i,"start":b.start,"stop":b.stop,
+                 "rows":len(b.field.rows),"omega":b.field.omega,"phase":b.field.phase}
+                for i,b in self.blocks()]

tgi/capacity_graph.py

@@ -0,0 +1,70 @@
+"""Neutral matching/cover bounds; no semantic pairing selection."""
+from tgi.role_work import RoleSearchBudget
+
+def certify_capacity_graph(left,right,edges,*,max_search_steps=None):
+    budget=RoleSearchBudget(max_search_steps)
+    with budget.scope():
+        left=sorted(left);right=sorted(right);l=set(left);r=set(right)
+        if len(left)!=len(l) or len(right)!=len(r):raise ValueError('Duplicate vertex')
+        adjacent={a:set() for a in left}
+        for pair in edges:
+            budget.consume()
+            if len(pair)!=2 or pair[0] not in l or pair[1] not in r:raise ValueError('Invalid edge')
+            adjacent[pair[0]].add(pair[1])
+        adjacent={a:sorted(bs) for a,bs in adjacent.items()};mate={};matched={}
+        for root in left:
+            budget.consume();stack=[(root,iter(adjacent[root]))];seen=set();parent={};free=None
+            while stack and free is None:
+                budget.consume();a,it=stack[-1]
+                try:b=next(it)
+                except StopIteration:stack.pop();continue
+                if b in seen:continue
+                seen.add(b);parent[b]=a
+                if b not in mate:free=b;break
+                child=mate[b];stack.append((child,iter(adjacent[child])))
+            while free is not None:
+                budget.consume();a=parent[free];previous=matched.get(a);matched[a]=free;mate[free]=a;free=previous
+        zl=l-set(matched);zr=set();pending=list(zl)
+        while pending:
+            budget.consume();a=pending.pop()
+            for b in adjacent[a]:
+                budget.consume()
+                if matched.get(a)==b or b in zr:continue
+                zr.add(b)
+                if b in mate and mate[b] not in zl:zl.add(mate[b]);pending.append(mate[b])
+        return dict(capacity=len(mate),matching=[list(p) for p in sorted(matched.items())],cover_left=sorted(l-zl),cover_right=sorted(zr))
+
+
+def verify_capacity_graph(left,right,edges,c,*,max_search_steps=None):
+    budget=RoleSearchBudget(max_search_steps)
+    with budget.scope():
+      try:
+        if not isinstance(c,dict) or set(c)!={'capacity','matching','cover_left','cover_right'} or type(c['capacity']) is not int:return False
+        l=set(left);r=set(right)
+        if len(l)!=len(left) or len(r)!=len(right):return False
+        e=set()
+        for pair in edges:
+            budget.consume()
+            if len(pair)!=2 or pair[0] not in l or pair[1] not in r:return False
+            e.add(tuple(pair))
+        seen_left=set();seen_right=set()
+        for pair in c['matching']:
+            budget.consume()
+            if len(pair)!=2 or tuple(pair) not in e:return False
+            a,b=pair
+            if a in seen_left or b in seen_right:return False
+            seen_left.add(a);seen_right.add(b)
+        cover=[]
+        for vertices,allowed in ((c['cover_left'],l),(c['cover_right'],r)):
+            values=set()
+            for v in vertices:
+                budget.consume()
+                if v not in allowed or v in values:return False
+                values.add(v)
+            cover.append(values)
+        if len(c['matching'])!=c['capacity'] or c['capacity']!=sum(map(len,cover)):return False
+        for a,b in e:
+            budget.consume()
+            if a not in cover[0] and b not in cover[1]:return False
+        return True
+      except (ValueError,TypeError,KeyError,IndexError):return False

tgi/closed_actuation_goal_frontier.py

@@ -0,0 +1,13 @@
+"""Quantified closure determines full-route depth; actual experience stays native."""
+from copy import deepcopy
+from .structural_append_closure import certify_structural_append_closure
+from .actuation_goal_frontier import certify_actuation_goal_frontier
+from .role_work import RoleSearchBudget
+
+def certify_closed_actuation_goal_frontier(*args,goal,max_depth=None,max_search_steps=None):
+ b=RoleSearchBudget(max_search_steps)
+ with b.scope():
+  b.consume()
+  if max_depth is not None and (type(max_depth) is not int or max_depth<0):raise ValueError('Original declared depth required')
+  closure=certify_structural_append_closure(*args,goal=goal);r=closure['result'];distance=r['shortest_supported_goal_length'];effective=max_depth if max_depth is not None else distance if distance is not None else 1;origin='DECLARED_SEARCH_DEPTH' if max_depth is not None else 'QUANTIFIED_SHORTEST_GOAL_BOUND' if distance is not None else 'ACTUAL_EXPERIENCE_LAYER_AFTER_CLOSURE';frontier=certify_actuation_goal_frontier(*args,goal,max_depth=effective);status=frontier['result']['status'] if frontier['result']['status'] in ('GOAL_ALREADY_OBSERVED','SUPPORTED_GOAL_READY') else r['status'] if distance is None else frontier['result']['status']
+  return {'policy':'closed_actuation_goal_frontier_v1','goal':deepcopy(goal),'max_depth':max_depth,'effective_depth':effective,'depth_origin':origin,'closure':closure,'frontier':frontier,'discovery':deepcopy(frontier['discovery']),'choices':deepcopy(frontier['choices']),'result':{'status':status,'closure_status':r['status'],'native_frontier_status':frontier['result']['status'],'choice_count':len(frontier['choices']),'quantified_append_system_complete':r['quantified_append_system_complete']}}

tgi/closed_actuation_goal_frontier_check.py

@@ -0,0 +1,19 @@
+"""Independent binding of quantified closure, route depth and actual frontier."""
+from .structural_append_closure_check import verify_structural_append_closure
+from .actuation_goal_frontier_check import verify_actuation_goal_frontier
+from .frame_engine import canonical
+from .role_work import RoleSearchBudget
+
+def verify_closed_actuation_goal_frontier(*args,goal,certificate,max_depth=None,max_search_steps=None):
+ b=RoleSearchBudget(max_search_steps)
+ with b.scope():
+  try:
+   b.consume();c=certificate
+   if type(c) is not dict or set(c)!={'policy','goal','max_depth','effective_depth','depth_origin','closure','frontier','discovery','choices','result'} or c['policy']!='closed_actuation_goal_frontier_v1' or canonical(c['goal'])!=canonical(goal) or type(max_depth) is bool or (max_depth is not None and (type(max_depth) is not int or max_depth<0)) or type(c['max_depth']) is not type(max_depth) or c['max_depth']!=max_depth:return False
+   if not verify_structural_append_closure(*args,goal=goal,certificate=c['closure']):return False
+   r=c['closure']['result'];distance=r['shortest_supported_goal_length'];effective=max_depth if max_depth is not None else distance if distance is not None else 1;origin='DECLARED_SEARCH_DEPTH' if max_depth is not None else 'QUANTIFIED_SHORTEST_GOAL_BOUND' if distance is not None else 'ACTUAL_EXPERIENCE_LAYER_AFTER_CLOSURE'
+   if type(c['effective_depth']) is not int or c['effective_depth']!=effective or c['depth_origin']!=origin or not verify_actuation_goal_frontier(*args,goal,c['frontier'],max_depth=effective):return False
+   if canonical(c['discovery'])!=canonical(c['frontier']['discovery']) or canonical(c['closure']['discovery'])!=canonical(c['discovery']) or canonical(c['choices'])!=canonical(c['frontier']['choices']):return False
+   status=c['frontier']['result']['status'] if c['frontier']['result']['status'] in ('GOAL_ALREADY_OBSERVED','SUPPORTED_GOAL_READY') else r['status'] if distance is None else c['frontier']['result']['status']
+   return canonical(c['result'])==canonical({'status':status,'closure_status':r['status'],'native_frontier_status':c['frontier']['result']['status'],'choice_count':len(c['frontier']['choices']),'quantified_append_system_complete':r['quantified_append_system_complete']})
+  except (ValueError,TypeError,IndexError,KeyError,AttributeError):return False