morphtree 2.1.0__py3-none-win_amd64.whl

morphtree/_experimental/component_cache_v2.py

@@ -0,0 +1,263 @@
+"""Version 2 research cache; preserves v1 source and fixes Pure backend spelling.
+
+The caller must build identity from actual ordered inputs. A complete result is
+immutable; uncertain jobs require reconciliation. OS leases prevent equal-key
+concurrent computations. This is not a remote/untrusted model execution service.
+"""
+from __future__ import annotations
+from contextlib import contextmanager
+from dataclasses import dataclass
+import hashlib,json,math,os,re,time,uuid,sys
+from pathlib import Path,PurePosixPath
+from .runtime_io import artifact_path
+from .processes import exclusive_lock,LockBusy
+ROOT=None
+CODE_ROOT=None
+
+MAX_RECORD=2*1024**2
+def canonical(v):
+ text=json.dumps(v,sort_keys=True,separators=(',',':'),allow_nan=False)
+ if len(text.encode('utf-8'))>MAX_RECORD:raise ValueError('Bounded identity/receipt required')
+ return text
+def digest(v):return hashlib.sha256(canonical(v).encode('utf-8')).hexdigest()
+def sha(path):return hashlib.sha256(Path(path).read_bytes()).hexdigest()
+def _hash(h):
+ if not isinstance(h,str) or not re.fullmatch('[a-f0-9]{64}',h):raise ValueError('SHA256 required')
+ return h
+def source_path(locator):
+ if not isinstance(locator,str) or ':' in locator or '\\' in locator:raise ValueError('Project-relative source required')
+ p=PurePosixPath(locator)
+ if p.is_absolute() or '..' in p.parts or not p.parts:raise ValueError('Unsafe source locator')
+ path=(CODE_ROOT.parent if p.parts[0]=='morphtree' else ROOT).joinpath(*p.parts)
+ for a in (path,*path.parents):
+  if a in (ROOT,CODE_ROOT.parent):break
+  if a.is_symlink() or a.exists() and getattr(a.lstat(),'st_file_attributes',0)&0x400:raise ValueError('No source reparse traversal')
+ if not path.is_file():raise ValueError('Missing source')
+ return path
+def _numeric(v):
+ if v is None:return 'MISSING'
+ if isinstance(v,bool) or not isinstance(v,(int,float)):raise ValueError('Explicit numeric encoded TRAIN values required')
+ f=float(v)
+ if math.isinf(f):raise ValueError('Infinite TRAIN values forbidden')
+ return 'MISSING' if math.isnan(f) else f.hex()
+
+@dataclass(frozen=True)
+class FitRequest:
+ text:str
+ @property
+ def key(self):return hashlib.sha256(self.text.encode('utf-8')).hexdigest()
+ def value(self):return json.loads(self.text)
+
+def learning_request(train,indices,*,protocol,split_sha256,preprocessing,task,family,structure,params,config,objective,seed,backend,dependencies,sources):
+ """Freeze actual rows and all declared learner dependencies by value.
+
+ Container weights/length, wall deadline and logical candidate name do not alter
+ an atomic completed fit. Learning tree/sample budget does; interrupted work is
+ never a cache hit. Protocol/split mismatches are intentionally conservative.
+ """
+ if type(train) is not dict or set(train)!={'role','ids','X','y'} or train['role']!='TRAIN':raise ValueError('TRAIN-only cache input')
+ X,y,ids=train['X'],train['y'],train['ids']
+ if not 1<=len(X)<=65536 or len(y)!=len(X) or len(ids)!=len(X) or len(set(ids))!=len(ids):raise ValueError('Aligned unique TRAIN rows required')
+ if any(not isinstance(x,(str,int)) or isinstance(x,bool) for x in ids):raise ValueError('Opaque row identifiers required')
+ width=len(X[0])
+ if not 1<=width<=128 or any(len(row)!=width for row in X):raise ValueError('Bounded rectangular numeric TRAIN required')
+ if task not in ('binary','regression','multiclass') or family not in ('boost','bag') or backend not in ('pure','numpy'):raise ValueError('Explicit native component context')
+ if not indices or any(type(i) is not int or not 0<=i<len(X) for i in indices):raise ValueError('Ordered actual sample indices required')
+ if type(seed) is not int or config.get('seed')!=seed or type(params.get('n_estimators')) is not int or params['n_estimators']<1:raise ValueError('Actual seed/tree budget required')
+ if family=='bag' and (params['n_estimators']!=1 or params.get('learning_rate')!=1.):raise ValueError('Bag identity describes one reset member, not its container')
+ if preprocessing.get('fit_role')!='TRAIN' or set(protocol)!={'path','sha256'} or not sources or not objective or not dependencies:raise ValueError('Full provenance required')
+ from dataclasses import asdict
+ from morphtree import HyperParams,AlgorithmGenome,MorphTreeConfig
+ if set(params)!=set(asdict(HyperParams())) or set(config)!=set(asdict(MorphTreeConfig())) or set(structure)!=set(AlgorithmGenome().to_dict()):raise ValueError('Complete native params/config/genome required')
+ HyperParams(**params);AlgorithmGenome(**structure);MorphTreeConfig(**config)
+ if config['tuner']!='none' or config['enable_tuning'] or config['enable_morphing'] or config['refit_full'] or config['memory_enabled']:raise ValueError('Fixed state-free component fitting only')
+ _hash(protocol['sha256']);_hash(split_sha256)
+ values=[[ _numeric(v) for v in row] for row in X];targets=[_numeric(v) for v in y]
+ # Hash the full actual input and effective ordered sample, not just array dimensions.
+ h=hashlib.sha256()
+ for row,label,ident in zip(values,targets,ids):h.update((canonical([row,label,ident])+'\n').encode('utf-8'))
+ sampled=hashlib.sha256()
+ for i in indices:sampled.update((canonical([values[i],targets[i],ids[i]])+'\n').encode('utf-8'))
+ value={'schema':'native-component-learning-v1','protocol':protocol,'split_sha256':split_sha256,'role':'TRAIN','TRAIN_sha256':h.hexdigest(),
+        'effective_sample_sha256':sampled.hexdigest(),'indices':list(indices),'rows':len(X),'features':width,'preprocessing':preprocessing,
+        'task':task,'family':family,'structure':structure,'params':params,'config':config,'objective':objective,'seed':seed,'backend':backend,
+        'dependencies':dependencies,'sources':sources,'learning_budget':{'trees':params['n_estimators'],'sample_rows':len(indices)}}
+ required={'morphtree/'+p.name for p in CODE_ROOT.glob('*.py')}
+ if not required:raise ValueError('Missing actual installed native module set')
+ if not required<=set(sources):raise ValueError('Pin every consolidated learner module')
+ for n,h in sources.items():_hash(h);source_path(n)
+ return FitRequest(canonical(value))
+
+def check_context(request):
+ if type(request) is not FitRequest:raise ValueError('Canonical FitRequest required')
+ v=request.value();p=v['protocol']
+ if sha(source_path(p['path']))!=p['sha256']:raise ValueError('Changed protocol')
+ for n,h in v['sources'].items():
+  if sha(source_path(n))!=h:raise ValueError('Changed learner dependency')
+ return v
+
+def _write(path,value):
+ path=artifact_path(path);text=canonical(value)+'\n'
+ with path.open('x',encoding='utf-8') as f:f.write(text);f.flush();os.fsync(f.fileno())
+def _read(path):
+ path=artifact_path(path)
+ if path.stat().st_size>MAX_RECORD:raise ValueError('Oversize cache record')
+ return json.loads(path.read_text('utf-8'))
+
+def check_model(path,value):
+ from .execution_v2 import validate_model
+ validate_model(path,value)
+
+class PendingComponent(RuntimeError):pass
+class ComputeBudgetExhausted(RuntimeError):pass
+
+class ComponentStore:
+ def __init__(self,folder,*,max_compute_jobs=0,seconds=180):
+  self.root=artifact_path(folder);self.root.mkdir(exist_ok=True)
+  if type(max_compute_jobs) is not int or max_compute_jobs<0 or not 0<seconds<=600:raise ValueError('Finite cache policy required')
+  with exclusive_lock(artifact_path(self.root/'metadata-lock')):
+   p=artifact_path(self.root/'POLICY.json')
+   if not p.exists():_write(p,{'schema':'native-component-store-v1','max_compute_jobs':max_compute_jobs,'seconds':seconds,'expires_unix':time.time()+seconds})
+   self.policy=_read(p)
+   if self.policy['max_compute_jobs']!=max_compute_jobs or self.policy['seconds']!=seconds:raise ValueError('Cache policy cannot reset budget/deadline')
+  self.keys=artifact_path(self.root/'components');self.keys.mkdir(exist_ok=True)
+ def _active(self,*,reuse_only=False):
+  if (self.root/'STOP').exists() or not reuse_only and time.time()>=self.policy['expires_unix']:raise ComputeBudgetExhausted('Cache computation expiry/STOP; no self-renewal')
+ def event(self,kind,**fields):
+  # Callers never acquire a component lock while holding this short journal lease.
+  for attempt in range(20):
+   try:
+    with exclusive_lock(artifact_path(self.root/'journal-lock')):
+     p=artifact_path(self.root/'EVENTS.jsonl')
+     with p.open('a',encoding='utf-8') as f:f.write(canonical({'event':kind,'UTC_unix':time.time(),**fields})+'\n');f.flush();os.fsync(f.fileno())
+    return
+   except LockBusy:
+    if attempt==19:raise
+    time.sleep(min(.01*(attempt+1),.1))
+ def _result(self,request,folder):
+  row=_read(folder/'COMPLETE.json')
+  if row['key']!=request.key or row['request']!=request.value():raise ValueError('Cache identity mismatch')
+  ref=row['artifact'];path=artifact_path(ROOT/ref['path'])
+  if path.stat().st_size!=ref['bytes'] or sha(path)!=ref['sha256']:raise ValueError('Changed completed component')
+  for proof in row['proof']:
+   if sha(source_path(proof['path']))!=proof['sha256']:raise ValueError('Changed completion provenance')
+  return row
+ def import_completed(self,request,model,*,expected_sha256,proof):
+  """Explicit verified historical admission; this performs no learning job."""
+  self._active();v=check_context(request);model=artifact_path(model);_hash(expected_sha256)
+  if not proof or sha(model)!=expected_sha256 or model.stat().st_size>16*1024**2:raise ValueError('Verified bounded artifact required')
+  for row in proof:
+   if sha(source_path(row['path']))!=_hash(row['sha256']):raise ValueError('Bad completion evidence')
+  check_model(model,v)
+  folder=artifact_path(self.keys/request.key)
+  with exclusive_lock(folder):
+   if (folder/'COMPLETE.json').exists():return self._result(request,folder)
+   if (folder/'INTENT.json').exists():raise PendingComponent('Reconcile interrupted learning before import')
+   record={'key':request.key,'request':v,'artifact':{'path':model.relative_to(ROOT).as_posix(),'sha256':expected_sha256,'bytes':model.stat().st_size},'proof':proof,'origin':'VERIFIED_HISTORICAL_IMPORT','compute_jobs':0}
+   _write(folder/'COMPLETE.json',record);self.event('IMPORTED_COMPLETED',key=request.key)
+   return record
+ @contextmanager
+ def claim(self,request,*,logical_id):
+  self._active(reuse_only=True);check_context(request)
+  if not isinstance(logical_id,str) or not 1<=len(logical_id)<=200:raise ValueError('Bounded logical request ID')
+  self.event('LOGICAL_REQUEST',key=request.key,logical_id=logical_id)
+  folder=artifact_path(self.keys/request.key)
+  try:
+   with exclusive_lock(folder):
+    if (folder/'COMPLETE.json').exists():
+     result=self._result(request,folder);self.event('CACHE_HIT',key=request.key,logical_id=logical_id);yield Lease(self,request,folder,result);return
+    self._active()
+    if (folder/'INTENT.json').exists():raise PendingComponent('Uncommitted attempt must not replay')
+    with exclusive_lock(artifact_path(self.root/'metadata-lock')):
+     used=sum(1 for _ in self.keys.glob('*/INTENT.json'))
+     if used>=self.policy['max_compute_jobs']:raise ComputeBudgetExhausted('No compute job budget')
+     _write(folder/'INTENT.json',{'key':request.key,'request':request.value(),'owner_pid':os.getpid(),'logical_id':logical_id})
+    self.event('COMPUTE_JOB_RESERVED',key=request.key,logical_id=logical_id)
+    lease=Lease(self,request,folder,None);yield lease
+    if lease.result is None:raise PendingComponent('Job incomplete; intent retained')
+  except LockBusy:
+   self.event('IN_FLIGHT_REFUSED',key=request.key,logical_id=logical_id);raise
+ def counts(self):
+  rows=[json.loads(x) for x in (self.root/'EVENTS.jsonl').read_text('utf-8').splitlines()] if (self.root/'EVENTS.jsonl').exists() else []
+  return {n:sum(x['event']==n for x in rows) for n in ('LOGICAL_REQUEST','CACHE_HIT','COMPUTE_JOB_RESERVED','IMPORTED_COMPLETED','IN_FLIGHT_REFUSED','NATIVE_FIT_STARTED','NATIVE_FIT_COMPLETED')}
+
+class Lease:
+ def __init__(self,store,request,folder,result):self.store,self.request,self.folder,self.result=store,request,folder,result
+ @property
+ def hit(self):return self.result is not None
+ def commit(self,model,*,expected_sha256,proof):
+  if self.result is not None:raise ValueError('Completed lease is immutable')
+  self.store._active();check_context(self.request);path=artifact_path(model)
+  if not path.is_relative_to(self.folder) or path.stat().st_size>16*1024**2 or sha(path)!=_hash(expected_sha256) or not proof:raise ValueError('Owned complete artifact/provenance required')
+  for ref in proof:
+   if sha(source_path(ref['path']))!=_hash(ref['sha256']):raise ValueError('Changed provenance')
+  check_model(path,self.request.value())
+  _write(self.folder/'COMPLETE.json',{'key':self.request.key,'request':self.request.value(),'artifact':{'path':path.relative_to(ROOT).as_posix(),'sha256':expected_sha256,'bytes':path.stat().st_size},'proof':proof,'origin':'COMPUTED_UNDER_EXCLUSIVE_LEASE','compute_jobs':1})
+  self.result=self.store._result(self.request,self.folder);self.store.event('COMPUTE_JOB_COMPLETED',key=self.request.key)
+
+def native_binary_component(store,train,indices,*,logical_id,context):
+ """One component adapter. A hit returns before estimator construction/fit.
+
+ Current qualification covers verified hit/no-budget/role paths only. A future
+ fit-capable campaign must independently qualify the miss branch and environment.
+ """
+ request=learning_request(train,indices,**context);v=request.value()
+ if v['task']!='binary' or v['objective']!='binary_logistic_Newton':raise ValueError('This adapter qualifies binary fixed-objective components only')
+ with store.claim(request,logical_id=logical_id) as lease:
+  reused=lease.hit
+  if not lease.hit:
+   if not v['dependencies'].get('qualified_fit_environment_sha256'):raise ValueError('Fresh qualified fit environment required')
+   from morphtree import MorphTreeClassifier,AlgorithmGenome,HyperParams,MorphTreeConfig
+   model=MorphTreeClassifier(genome=AlgorithmGenome(**v['structure']),params=HyperParams(**v['params']),config=MorphTreeConfig(**v['config']),backend=v['backend'])
+   store.event('NATIVE_FIT_STARTED',key=request.key)
+   model.fit([train['X'][i] for i in indices],[train['y'][i] for i in indices],cancel=lambda:(store._active() or False))
+   path=artifact_path(lease.folder/'model.mtree');model.save_model(path)
+   lease.commit(path,expected_sha256=sha(path),proof=[v['protocol']]);store.event('NATIVE_FIT_COMPLETED',key=request.key)
+  from morphtree import load_model
+  return load_model(ROOT/lease.result['artifact']['path'],backend='pure'),{'key':request.key,'artifact':lease.result['artifact'],'reused':reused}
+
+def configure(root,package):
+ global ROOT,CODE_ROOT
+ ROOT=Path(root).resolve();CODE_ROOT=Path(package).resolve()
+ if not ROOT.is_dir() or not CODE_ROOT.is_dir():raise ValueError('Explicit existing roots')
+def native_sources():
+ return {'morphtree/'+p.relative_to(CODE_ROOT).as_posix():sha(p) for p in CODE_ROOT.rglob('*.py')}
+
+class MultitaskStore(ComponentStore):
+
+    def events(self):
+        p = self.root / 'EVENTS.jsonl'
+        if not p.exists():
+            return []
+        raw = p.read_bytes()
+        if raw and (not raw.endswith(b'\n')):
+            raise ValueError('Partial journal tail requires reconciliation')
+        rows = []
+        previous = '0' * 64
+        for i, line in enumerate(raw.splitlines()):
+            row = json.loads(line)
+            body = {k: v for k, v in row.items() if k != 'sha256'}
+            if row.get('sequence') != i + 1 or row.get('previous') != previous or row.get('sha256') != digest(body):
+                raise ValueError('Corrupt execution journal')
+            previous = row['sha256']
+            rows.append(row)
+        return rows
+
+    def event(self, kind, **fields):
+        with exclusive_lock(artifact_path(self.root / 'journal-lock')):
+            rows = self.events()
+            body = {'sequence': len(rows) + 1, 'previous': rows[-1]['sha256'] if rows else '0' * 64, 'event': kind, 'UTC_unix': time.time(), **fields}
+            row = {**body, 'sha256': digest(body)}
+            with (self.root / 'EVENTS.jsonl').open('a', encoding='utf8') as f:
+                f.write(json.dumps(row, sort_keys=True, allow_nan=False) + '\n')
+                f.flush()
+                os.fsync(f.fileno())
+
+    def _result(self, request, folder):
+        row = super()._result(request, folder)
+        validate_native(artifact_path(row['artifact']['path']), request)
+        return row
+
+def validate_native(path,request):
+ from .execution_v2 import validate_model
+ return validate_model(path,request.value())

morphtree/_experimental/evolution_report.py

@@ -0,0 +1,307 @@
+"""One read-only projection of the existing component journal, not a journal.
+
+Packaged with the experimental orchestrator only. Callbacks must reopen native
+artifacts/proofs and reproduce predictions; a summary flag is never evidence.
+Historical reports are inputs to an optional consistency check, never authority.
+"""
+import copy
+import hashlib
+import json
+import math
+
+
+def _digest(value):
+    return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(',', ':'),
+                                     allow_nan=False).encode('utf8')).hexdigest()
+
+
+def verified_evolution_report(rows, *, packets, verify_packet, verify_oof,
+                              program, metric, final_packet, mode,
+                              claimed=None, finalization=None,budget_recovery=None):
+    """Fail closed on contradictions; UNKNOWN remains explicit in partial traces.
+
+    No authority, fitting, file mutation or second ledger is created. Canonical
+    events below are views referencing exact source sequence/hash/timestamp.
+    A missing historical timestamp is UNKNOWN, never the reconciliation time.
+    """
+    if mode not in ('LIVE', 'FIXTURE', 'PREFIT', 'PUBLIC_USER') or len(rows)>10000:
+        raise ValueError('Bounded explicit evidence mode required')
+    previous='0'*64
+    for i,r in enumerate(rows,1):
+        body={k:v for k,v in r.items() if k!='sha256'}
+        if r.get('sequence')!=i or r.get('previous')!=previous or r.get('sha256')!=_digest(body):
+            raise ValueError('Broken canonical journal chain')
+        if type(r.get('UTC_unix')) not in (int,float) or not math.isfinite(r['UTC_unix']):
+            raise ValueError('Invalid event timestamp')
+        previous=r['sha256']
+    events=[];forms={};contexts={};current=None;frozen=None;steps=[]
+    starts={};ends={};trials={};trial_ends={};pending=None;artifact_keys=set();diagnoses=[]
+    trial_numbers=set();created_trials={};budget_stop=None;interrupted_steps=[]
+    def emit(kind,r,*,parent=None,status='COMPLETED',**values):
+        events.append(dict(id='view:'+str(r['sequence'])+':'+kind,kind=kind,
+            parent=parent,timestamp=r['UTC_unix'],status=status,
+            provenance={'sequence':r['sequence'],'sha256':r['sha256']},**values))
+    def checked(name):
+        if name not in packets:raise ValueError('Unverifiable program packet')
+        p=packets[name]
+        if p['id']!=name:raise ValueError('Changed packet identity')
+        proof=verify_packet(copy.deepcopy(p))
+        if proof['packet_sha256']!=_digest(p):raise ValueError('Artifact differs from program packet')
+        pred=proof['prediction'];loss=metric(p,pred)
+        artifact_keys.update(proof['component_keys'])
+        if not math.isfinite(loss):raise ValueError('Nonfinite SEARCH loss')
+        return {'packet':copy.deepcopy(p),'program':program(p),'SEARCH_primary':loss,
+                'TRAIN_primary':proof.get('TRAIN_primary','UNKNOWN'),
+                'artifacts':proof['artifacts'],'component_keys':list(proof['component_keys']),
+                'prediction_sha256':_digest(pred)}
+    for r in rows:
+        k=r['event'];v=r.get('value',{});op=v.get('operation')
+        if k in ('NATIVE_FIT_STARTED','NATIVE_FIT_COMPLETED'):
+            target=starts if k.endswith('STARTED') else ends;key=r['key']
+            if key in target:raise ValueError('Duplicate physical fit event')
+            if target is ends and (key not in starts or starts[key]['phase']!=r['phase']):
+                raise ValueError('Completion without corresponding physical start')
+            target[key]=r;emit('FIT_STARTED' if target is starts else 'FIT_COMPLETED',r,
+                status='STARTED' if target is starts else 'COMPLETED',component=key,phase=r['phase'])
+        elif k=='NUMERIC_TRIAL_INTENT':
+            # Existing producer reserves before Optuna.ask(), so its intent has
+            # no Optuna number yet. Keep the reservation distinct from the
+            # number later returned by tell; never invent an executed trial.
+            n=r['sequence']
+            if n in trials or frozen is None:raise ValueError('Trial duplicated or before freeze')
+            trials[n]=r;emit('NUMERIC_TUNING_STARTED',r,status='STARTED',real=r['real'],
+                            reservation_sequence=n,number=r.get('number','UNKNOWN_UNTIL_ASK'))
+        elif k=='NUMERIC_TRIAL_ASKED' and mode=='PUBLIC_USER':
+            eligible=[n for n in trials if n not in created_trials and n not in trial_ends]
+            if len(eligible)!=1 or type(r.get('number')) is not int or type(r.get('real')) is not bool:
+                raise ValueError('Created user trial without a unique reservation')
+            n=eligible[0]
+            if r['real']!=trials[n]['real'] or r['number'] in {x['number'] for x in created_trials.values()}:
+                raise ValueError('Changed driver evidence or repeated user trial number')
+            created_trials[n]=r
+            emit('NUMERIC_TRIAL_CREATED',r,number=r['number'],real=r['real'],reservation_sequence=n)
+        elif k=='NUMERIC_TRIAL_COMPLETED':
+            eligible=[n for n in trials if n not in trial_ends]
+            if len(eligible)!=1 or r['number'] in trial_numbers:
+                raise ValueError('Trial completion without matching intent')
+            n=eligible[0]
+            if mode=='PUBLIC_USER' and (n not in created_trials or created_trials[n]['number']!=r['number']):
+                raise ValueError('Completion before an actual returned user trial')
+            if r['real']!=trials[n]['real'] or trials[n].get('number',r['number'])!=r['number']:
+                raise ValueError('Trial number or evidence changed')
+            trial_numbers.add(r['number'])
+            trial_ends[n]=r
+        elif k=='OOF_CONTEXT_PRODUCED':
+            proof=verify_oof(copy.deepcopy(r))
+            if (proof['context']!=r['context'] or proof['parent']!=r['parent']
+                    or proof['components']!=r['components'] or proof['mode']!=mode):
+                raise ValueError('OOF artifacts/provenance differ')
+            if r['context'] in contexts:raise ValueError('Duplicate OOF acquisition')
+            contexts[r['context']]=proof
+            artifact_keys.update(proof['component_keys'])
+            emit('OOF_COMPLETED',r,parent=r['parent'],components=proof['components'],
+                 evidence=proof['evidence'],artifacts=proof['artifacts'])
+        elif k=='OOF_CONTEXT_REUSED':
+            if r['context'] not in contexts or r['physical_fits']!=0:
+                raise ValueError('Unverifiable reused OOF context')
+        elif op=='learning_completed':
+            name=v['id']
+            if name in forms:raise ValueError('Duplicate completed program')
+            forms[name]=checked(name);emit('PROGRAM_CREATED',r,program=forms[name]['program'],packet=name)
+            if 'packet' in v and v['packet']!=packets[name]:raise ValueError('Executed packet differs')
+        elif op=='family_selection' and v['status']=='COMPLETED':
+            name=v['retained']
+            if name not in forms:raise ValueError('Parent not executed')
+            # Verify the actual metric, including initial family comparison.
+            if v['loss']!=forms[name]['SEARCH_primary']:raise ValueError('Stale family metric')
+            if any(f['SEARCH_primary']<forms[name]['SEARCH_primary'] for f in forms.values()):
+                raise ValueError('Lost initial verified SEARCH anchor')
+            current=name;emit('PROGRAM_SELECTED_AS_PARENT',r,parent=name,program=forms[name]['program'])
+        elif op=='diagnosis_completed':
+            if current is None:current=v['parent']
+            p=packets.get(current);ctx=contexts.get(v['context_sha256'])
+            if (p is None or v['parent']!=current or ctx is None
+                    or v['parent_packet_sha256']!=_digest(p)
+                    or ctx['parent']!=_digest(p) or ctx['program_sha256']!=_digest(program(p))):
+                raise ValueError('Unverified completed diagnosis')
+            diagnoses.append(v['context_sha256'])
+            emit('DIAGNOSIS_COMPLETED',r,parent=current,evidence=ctx['evidence'],context=v['context_sha256'])
+        elif op=='evolution_intent':
+            if current is None:current=v['parent']  # single-family path; checked below
+            if current not in forms or pending is not None or frozen is not None:
+                raise ValueError('Invalid mutation ordering')
+            p=packets[current];ctx=contexts.get(v['diagnostic_context_sha256'])
+            if (v['parent']!=current or v['parent_packet_sha256']!=_digest(p)
+                    or v['parent_program_sha256']!=_digest(program(p)) or ctx is None
+                    or ctx['parent']!=_digest(p) or ctx['program_sha256']!=_digest(program(p))):
+                raise ValueError('Wrong parent or diagnostic provenance')
+            child=v['child_program'];program_packet={'task':child['task'],'family':child['family'],
+                                                     'recipe':{'genome':child['genome']}}
+            if program(program_packet)!=child:raise ValueError('Declared instructions differ from dispatch')
+            changed=[g for g,val in p['recipe']['genome'].items() if child['genome'][g]!=val]
+            if changed!=[v['gene']] or child['family']!=p['family'] or v['numeric_parameters_sha256']!=_digest(p['params']):
+                raise ValueError('Not a single typed structural transformation')
+            pending=copy.deepcopy(v)
+            if v['diagnostic_context_sha256'] not in diagnoses:
+                # Historical journal has no separate diagnosis-complete record.
+                # This proposal proves one consumption; the timestamp is its
+                # recorded upper bound, not an invented diagnosis finish time.
+                emit('DIAGNOSIS_COMPLETED',r,parent=current,evidence=ctx['evidence'],
+                     context=v['diagnostic_context_sha256'],timestamp_semantics='PROPOSAL_BOUND_UPPER_BOUND')
+            emit('MUTATION_PROPOSED',r,parent=current,program=child,gene=v['gene'])
+        elif op=='search_budget_stopped':
+            if (mode!='PUBLIC_USER' or v.get('retained') not in forms
+                    or v.get('stage') not in ('FAMILY','EVOLUTION','NUMERIC')):
+                raise ValueError('Unverified typed public budget stop')
+            if current is None:current=v['retained']
+            if v['retained']!=current:raise ValueError('Budget stop lost the verified current anchor')
+            budget_stop=copy.deepcopy(v)
+            emit('SEARCH_STOPPED_BUDGET',r,parent=current,details=budget_stop,status='STOPPED_BUDGET')
+        elif op=='evolution_interrupted':
+            if (pending is None or budget_stop is None or budget_stop['stage']!='EVOLUTION'
+                    or v.get('reason')!='TYPED_SEARCH_BUDGET'
+                    or v.get('index')!=pending['index'] or v.get('parent')!=current
+                    or v.get('retained')!=current or v.get('decision')!='RESTORE_VERIFIED_PARENT'):
+                raise ValueError('Invalid incomplete mutation recovery')
+            interrupted_steps.append({'index':pending['index'],'parent':current,
+                                      'status':'INTERRUPTED_NOT_ADOPTED','retained':current})
+            emit('MUTATION_INTERRUPTED',r,parent=current,status='INTERRUPTED_NOT_ADOPTED')
+            pending=None
+        elif op=='numeric_budget_skipped':
+            if frozen is None or budget_stop is None or v.get('retained')!=current:
+                raise ValueError('Unverified numerical budget skip')
+            emit('NUMERIC_TUNING_SKIPPED',r,parent=current,reason='SEARCH_BUDGET')
+        elif op=='evolution_selection' and v['status']=='COMPLETED':
+            if pending is None or v['parent']!=current or v['candidate'] not in forms:
+                raise ValueError('Child without a verified parent')
+            child=checked(v['candidate']);parent=forms[current];cp=child['packet'];pp=parent['packet']
+            if (child['program']!=pending['child_program'] or cp['params']!=pp['params']
+                    or cp['learning_identity']!=pp['learning_identity']
+                    or cp['recipe']['classes']!=pp['recipe']['classes']
+                    or cp['recipe']['encoder']!=pp['recipe']['encoder']):
+                raise ValueError('Executed child differs from nominated program/data/numbers')
+            decision='ACCEPT' if child['SEARCH_primary']<parent['SEARCH_primary'] else 'ROLLBACK'
+            retained=v['candidate'] if decision=='ACCEPT' else current
+            if v['decision']!=decision or v['retained']!=retained:
+                raise ValueError('False acceptance/rejection or retained anchor')
+            emit('MUTATED_PROGRAM_EXECUTED',r,parent=current,packet=cp['id'],program=child['program'])
+            emit('CANDIDATE_EVALUATED',r,parent=current,SEARCH_parent=parent['SEARCH_primary'],
+                 SEARCH_candidate=child['SEARCH_primary'])
+            emit('MUTATION_ACCEPTED' if decision=='ACCEPT' else 'MUTATION_REJECTED',r,parent=current,child=cp['id'])
+            if decision=='ROLLBACK':emit('ROLLBACK_COMPLETED',r,parent=current,retained=retained)
+            steps.append(dict(index=pending['index'],parent=current,child=cp['id'],
+                parent_program=parent['program'],child_program=child['program'],decision=decision,
+                retained=retained,SEARCH_parent=parent['SEARCH_primary'],SEARCH_candidate=child['SEARCH_primary'],
+                SEARCH_retained=forms[retained]['SEARCH_primary'],execution=pending['execution']))
+            current=retained;pending=None
+        elif op=='evolution_complete':
+            if current is None:current=v['retained']
+            if current not in forms or v['retained']!=current or v['program']!=forms[current]['program'] or pending:
+                raise ValueError('Unverifiable terminal program')
+        elif op=='structure_frozen' and 'packet' in v:
+            p=v['packet']
+            if current is None:current=p['id']
+            if current not in forms or p!=packets[current] or pending:raise ValueError('Incompatible frozen anchor')
+            if frozen is not None and frozen!=p:raise ValueError('Changed frozen program')
+            frozen=copy.deepcopy(p);emit('PROGRAM_FROZEN',r,parent=current,program=program(p),params=p['params'])
+            if v.get('numeric_budget')==0:emit('NUMERIC_TUNING_SKIPPED',r,parent=current,reason='ZERO_ADMITTED_NUMERIC_BUDGET')
+        elif op=='numeric_selection' and v.get('status')=='COMPLETED':
+            if frozen is None or v['retained'] not in forms:raise ValueError('Unverified numeric selection')
+            chosen=checked(v['retained'])
+            if (chosen['program']!=program(frozen)
+                    or chosen['packet']['learning_identity']!=frozen['learning_identity']
+                    or chosen['SEARCH_primary']>forms[current]['SEARCH_primary']):
+                raise ValueError('Numeric phase changed structure/data or lost verified anchor')
+            current=v['retained']
+    if (frozen is None or current!=final_packet['id'] or final_packet!=packets[current]
+            or program(final_packet)!=program(frozen)):
+        raise ValueError('Final model is not the frozen verified anchor')
+    # Reopen selected weights again after traversal; verifier must bind payload.
+    final=checked(current)
+    stop=next((r['value']['stop'] for r in reversed(rows) if r['event']=='ORCHESTRATION'
+               and r['value'].get('operation')=='evolution_complete'),'UNKNOWN')
+    counts={'physical_fits_started':len(starts),'physical_fits_completed':len(ends),
+        'incomplete_native_fits':len(starts.keys()-ends.keys()),
+        'scalar_trees_started':sum(r['scalar_trees'] for r in starts.values()),
+        'OOF_components':sum(p['components'] for p in contexts.values()),
+        'OOF_physical_fits_completed':sum(r['phase']=='OOF' for r in ends.values()),
+        'OOF_contexts_acquired':len(contexts),
+        'OOF_contexts_reused':sum(r['event']=='OOF_CONTEXT_REUSED' for r in rows),
+        'explicit_diagnosis_completions':len(diagnoses),
+        'cache_hits':sum(r['event']=='CACHE_HIT' for r in rows),
+        'real_trials_started':sum(r['real'] for r in trials.values()),
+        'real_trials_completed':sum(r['real'] and r['state']=='COMPLETE' for r in trial_ends.values()),
+        'simulated_trials_started':sum(not r['real'] for r in trials.values())}
+    if mode=='PUBLIC_USER':
+        counts['trial_reservations']=len(trials)
+        counts['real_trials_created']=sum(r['real'] for r in created_trials.values())
+        counts['simulated_trials_created']=sum(not r['real'] for r in created_trials.values())
+    hits={r['key'] for r in rows if r['event']=='CACHE_HIT'}
+    fixture_keys={r['key'] for r in rows if r['event']=='FIXTURE_COMPLETED'}
+    unassigned=(set(ends)|hits|fixture_keys)-artifact_keys
+    interrupted=set(starts)-set(ends);unadopted={}
+    if unassigned or interrupted:
+        if mode!='PUBLIC_USER' or budget_stop is None or not callable(budget_recovery):
+            raise ValueError('Physical/cache/fixture accounting does not match verified artifacts')
+        unadopted=budget_recovery(unassigned|interrupted)
+        if type(unadopted) is not dict or set(unadopted)!=(unassigned|interrupted):
+            raise ValueError('Every unadopted component needs explicit artifact/intent verification')
+        for key,p in unadopted.items():
+            if (p.get('key')!=key or type(p.get('committed')) is not bool
+                    or p.get('used_in_final_model') is not False
+                    or not isinstance(p.get('intent_sha256'),str) or len(p['intent_sha256'])!=64
+                    or p['committed'] and not isinstance(p.get('artifact'),dict)):
+                raise ValueError('Invalid unadopted component evidence')
+            p['native_completed']=key in ends
+            p['status']='COMMITTED_NOT_ADOPTED' if p['committed'] else 'NATIVE_COMPLETE_NOT_COMMITTED' if key in ends else 'INTERRUPTED_NOT_ADOPTED'
+    if artifact_keys-(set(ends)|hits|fixture_keys):
+        raise ValueError('Reported component has no physical/cache/fixture evidence')
+    def interval_union(keys):
+        intervals=sorted((starts[k]['UTC_unix'],ends[k]['UTC_unix']) for k in keys if k in starts and k in ends)
+        total=0.;last=None
+        for a,b in intervals:
+            if b<a:raise ValueError('Native completion precedes start')
+            total+=max(0.,b-max(a,last if last is not None else a));last=max(b,last if last is not None else b)
+        return total
+    for f in forms.values():
+        f['native_logged_wall_union_seconds']=interval_union(f['component_keys'])
+        f['native_physical_fits']=sum(k in ends for k in f['component_keys'])
+        f['cost_scope']='NATIVE_EVENT_WINDOWS_ONLY_NOT_COMPLETE_SEARCH_OR_BENCHMARK'
+    # checked() reopens final weights; annotate its same scoped native costs.
+    final.update({k:forms[current][k] for k in ('native_logged_wall_union_seconds','native_physical_fits','cost_scope')})
+    if mode in ('LIVE','PUBLIC_USER') and counts['OOF_components']!=counts['OOF_physical_fits_completed']:
+        # Cache-reused components must be explicitly distinguished by the proof.
+        cached=sum(p.get('cache_components',0) for p in contexts.values())
+        orphan_oof=sum(k in unadopted and r['phase']=='OOF' for k,r in ends.items())
+        if counts['OOF_components']!=counts['OOF_physical_fits_completed']-orphan_oof+cached:
+            raise ValueError('OOF component/native accounting contradiction')
+    status='MODEL_READY_EXPORT_NOT_VERIFIED'
+    if finalization is not None:
+        # Verification occurs in the existing postfit safe-loader/V3/standalone
+        # path or a read-only replay, never inferred from a report boolean.
+        f=finalization(copy.deepcopy(final_packet))
+        if f['packet_sha256']!=_digest(final_packet) or f['weights_sha256']!=final_packet['artifact_sha256']:
+            raise ValueError('Finalized weights differ from retained program')
+        source=next((r for r in reversed(rows) if r['event']=='WORKFLOW_COMPLETED'),None)
+        if source is not None:
+            if source['model']!=f['model']:raise ValueError('Final artifact differs from workflow')
+            emit('MODEL_FINALIZED',source,parent=current,artifacts=f)
+            status='COMPLETED_VERIFIED_EXPORT'
+    out={'schema':'comp010-verified-evolution-report-v1','status':status,'evidence':mode,
+        'journal_head_sha256':previous,'events':events,'forms':forms,'steps':steps,
+        'counts':counts,'stop':stop,'final':final,'diagnosis_executed':bool(contexts),
+        'diagnostic_utility':'INCONCLUSIVE','performance_qualified':False,
+        'OOF_acquisition_method_seconds':sum(p['seconds'] for p in contexts.values()),
+        'cost_scope':'INCLUSIVE_OPERATIONAL_METHOD_ONLY_EXCLUDES_OUTER_ADMISSION_AND_REVERIFICATION',
+        'CPU':'UNKNOWN','peak_RSS':'UNKNOWN','global_optimum_claim':False}
+    if budget_stop is not None:
+        out['budget_recovery']={'schema':'product006-verified-budget-recovery-v1',
+            'stop':budget_stop,'unadopted_components':unadopted,
+            'interrupted_steps':interrupted_steps,'phase_completion':'PARTIAL_BUDGET_VALID_ANCHOR_RETURNED',
+            'not_claimed':'No completed mutation/OOF/trial inferred from partial physical work'}
+    if claimed is not None:
+        # Optional validation is exact; legacy summaries require an explicit
+        # discrepancy overlay and must never be silently accepted as verified.
+        for key in ('counts','steps','final','diagnosis_executed','journal_head_sha256'):
+            if claimed.get(key)!=out[key]:raise ValueError('Stale or contradictory report: '+key)
+    return out