sable-sphynx 0.7.0.dev0__py3-none-any.whl

sphynx/_rag_diagnostics_contracts.py

@@ -0,0 +1,186 @@
+"""Validate the local language-neutral case/trace boundary before grading."""
+from __future__ import annotations
+
+import json
+import math
+import copy
+from pathlib import Path
+
+from ._rag_diagnostics_common import STAGES, digest
+
+
+class ContractError(ValueError):
+    pass
+
+
+def require(condition, message):
+    if not condition:
+        raise ContractError(message)
+
+
+def unique_ids(values, name):
+    require(type(values) is list and all(type(v) is str and 0 < len(v) <= 180 for v in values), name+' must be an ID list')
+    require(len(values) == len(set(values)), name+' has duplicate IDs')
+    return set(values)
+
+
+def optional_bool(value, name):
+    require(value is None or type(value) is bool, name+' must be boolean or null')
+
+
+def _json_domain(value, depth=0, ancestors=None):
+    """Reject non-JSON objects, nonfinite numbers and recursive direct inputs."""
+    require(depth <= 64, 'Dataset nesting exceeds the local 64-level limit')
+    if value is None or type(value) in (str, bool, int):
+        return
+    if type(value) is float:
+        require(math.isfinite(value), 'Dataset numbers must be finite')
+        return
+    require(type(value) in (dict, list), 'Dataset values must be JSON objects, lists or scalar values')
+    ancestors = set() if ancestors is None else ancestors
+    identity = id(value)
+    require(identity not in ancestors, 'Dataset must not contain recursive values')
+    ancestors.add(identity)
+    if type(value) is dict:
+        require(all(type(key) is str for key in value), 'JSON object keys must be strings')
+        children = value.values()
+    else:
+        children = value
+    for child in children:
+        _json_domain(child, depth+1, ancestors)
+    ancestors.remove(identity)
+
+
+def case_input_digest(case):
+    """Bind a semantic review to exact public candidate inputs, not just IDs."""
+    return digest({key: case[key] for key in ('id', 'question', 'documents')})
+
+
+def validate_dataset(data):
+    _json_domain(data)
+    require(type(data) is dict and data.get('schema_version') == 'sphynx.rag-diagnostics.dataset.v1', 'Unsupported dataset schema')
+    require(type(data.get('release')) is str and data['release'], 'Dataset release is required')
+    require(type(data.get('suites')) is list and 0 < len(data['suites']) <= 5000, 'Expected 1–5000 suites')
+    require(all(type(s) is dict for s in data['suites']), 'Each suite must be an object')
+    suite_ids=unique_ids([s.get('id') for s in data['suites']], 'suite IDs')
+    require(type(data.get('cases')) is list and 0 < len(data['cases']) <= 5000, 'Expected 1–5000 cases')
+    require(all(type(c) is dict for c in data['cases']), 'Each case must be an object')
+    unique_ids([c.get('id') for c in data['cases']], 'case IDs')
+    for case in data['cases']:
+        name=case['id']
+        require(case.get('suite_id') in suite_ids, name+': unknown suite')
+        require(type(case.get('cluster_id')) is str and case['cluster_id'], name+': independent cluster identity required')
+        require(type(case.get('question')) is str and 0 < len(case['question']) <= 20000, name+': question required')
+        docs=case.get('documents')
+        require(type(docs) is list and len(docs) <= 10000, name+': invalid documents')
+        require(all(type(d) is dict for d in docs), name+': each document must be an object')
+        ids=unique_ids([d.get('id') for d in docs], name+' document IDs')
+        require(all(type(d.get('text')) is str for d in docs), name+': document text required')
+        refs=case.get('references')
+        require(type(refs) is dict, name+': protected references required')
+        reviews=refs.get('reviews', {})
+        require(type(reviews) is dict and set(reviews) <= {'baseline','candidate'}, name+': invalid review variants')
+        optional_bool(refs.get('corpus_answerable'), name+' corpus answerability')
+        qrels=refs.get('qrels')
+        require(qrels is None or (type(qrels) is dict and set(qrels) <= ids and all(type(g) is int and 0 <= g <= 100 for g in qrels.values())), name+': invalid qrels')
+        for required,mapping in [('required_atoms','atom_support'),('required_relations','relation_support')]:
+            needed=refs.get(required)
+            if needed is not None:
+                unique_ids(needed, name+' '+required)
+            support=refs.get(mapping)
+            if support is not None:
+                require(type(support) is dict, name+': invalid '+mapping)
+                for key,values in support.items():
+                    require(type(key) is str and key, name+': invalid support key')
+                    require(unique_ids(values, name+' support') <= ids, name+': support references unknown documents')
+        traces=case.get('traces')
+        require(type(traces) is dict and set(traces)=={'baseline','candidate'}, name+': paired traces required')
+        for variant,trace in traces.items():
+            require(type(trace) is dict and trace.get('execution_mode') in ('synthetic_replay','recorded_replay'), name+': replay mode required')
+            require(type(trace.get('id')) is str and trace['id'], name+': trace identity required')
+            stages=trace.get('stages')
+            require(type(stages) is dict and set(stages)==set(STAGES), name+': explicit stage lists/nulls required')
+            previous=None
+            for stage in STAGES:
+                values=stages[stage]
+                if values is None:
+                    continue
+                found=unique_ids(values, name+' '+stage)
+                require(found <= ids, name+': stage references unknown document')
+                if previous is not None:
+                    require(found <= previous, name+': stage cannot invent documents after upstream selection')
+                previous=found
+            response=trace.get('response')
+            require(type(response) is dict and response.get('status') in ('ok','error','timeout'), name+': response status required')
+            require(type(response.get('text')) is str, name+': response text required')
+            optional_bool(response.get('abstained'), name+' abstained')
+            ops=trace.get('operational')
+            require(type(ops) is dict and ops.get('origin') in ('synthetic','component_reported','attested'), name+': telemetry origin required')
+            require(ops.get('origin')!='attested', name+': SDK cannot validate telemetry attestation')
+            for key in ('latency_ms','cost_usd','tokens'):
+                value=ops.get(key)
+                require(value is None or (type(value) in (int,float) and math.isfinite(value) and value>=0), name+': invalid telemetry '+key)
+                if key=='tokens' and value is not None:
+                    require(type(value) is int, name+': tokens must be integer')
+            review=reviews.get(variant)
+            if review is None:
+                continue
+            require(type(review) is dict and review.get('trace_digest')==digest(trace), name+': stale or mismatched review')
+            require(review.get('case_input_digest')==case_input_digest(case), name+': stale or mismatched review case inputs')
+            provenance=review.get('provenance')
+            require(type(provenance) is dict and provenance.get('kind') in ('synthetic','human_adjudicated') and type(provenance.get('reviewer')) is str and provenance['reviewer'].strip(), name+': review provenance required')
+            require(trace['execution_mode']!='synthetic_replay' or provenance['kind']=='synthetic', name+': synthetic trace requires synthetic review provenance')
+            for field in ('answer_correct','answer_relevant','abstention_expected'):
+                optional_bool(review.get(field), name+' '+field)
+            suff=review.get('context_sufficiency',{})
+            require(type(suff) is dict and set(suff) <= {'retrieved','selected','prompt'}, name+': invalid sufficiency stages')
+            for stage,value in suff.items():
+                optional_bool(value, name+' sufficient '+stage)
+                require(value is None or stages[stage] is not None, name+': cannot judge missing context')
+            require(type(review.get('claims_exhaustive')) is bool and type(review.get('claims')) is list, name+': claim audit state required')
+            claims=review['claims']
+            require(all(type(c) is dict for c in claims), name+': each reviewed claim must be an object')
+            unique_ids([c.get('id') for c in claims], name+' claim IDs')
+            prompt=set(stages['prompt'] or [])
+            for claim in claims:
+                require(type(claim.get('text')) is str and claim['text'], name+': claim text required')
+                for field in ('supported_by_context','correct','joint_citation_support'):
+                    optional_bool(claim.get(field), name+' claim '+field)
+                require(type(claim.get('requires_citation')) is bool, name+': citation requirement required')
+                cited=unique_ids(claim.get('cited_ids'), name+' cited IDs')
+                require(cited <= ids, name+': citation ID does not exist')
+                # A dangling/out-of-prompt citation is an observed citation validity
+                # failure, not an assertion of semantic support.
+                if claim.get('joint_citation_support') is True:
+                    require(cited and cited <= prompt, name+': supported citation leaves handed context')
+                unique_ids(claim.get('reference_atoms'), name+' expressed reference atoms')
+                if refs.get('required_atoms') is not None:
+                    require(set(claim['reference_atoms']) <= set(refs['required_atoms']), name+': unknown expressed reference atom')
+                for field in ('individual_support','leave_one_out_support'):
+                    judgments=claim.get(field)
+                    require(type(judgments) is dict and set(judgments) <= cited, name+': invalid citation judgments')
+                    for value in judgments.values():
+                        optional_bool(value, name+' citation judgment')
+    return data
+
+
+def load_dataset(path):
+    raw=Path(path).read_bytes()
+    require(len(raw)<=20_000_000, 'Dataset exceeds 20MB local limit')
+    def pairs(items):
+        out={}
+        for key,value in items:
+            require(key not in out, 'Duplicate JSON object key: '+key)
+            out[key]=value
+        return out
+    try:
+        data=json.loads(raw,object_pairs_hook=pairs,parse_constant=lambda value: (_ for _ in ()).throw(ContractError('Nonfinite JSON number')))
+    except (json.JSONDecodeError, UnicodeDecodeError, RecursionError) as error:
+        raise ContractError('Invalid or excessively nested JSON dataset') from error
+    return validate_dataset(data)
+
+
+def candidate_view(case):
+    """Protected labels are never part of a candidate payload."""
+    return copy.deepcopy({'id':case['id'],'question':case['question'],
+                          'documents':[{key:doc[key] for key in ('id','text')} for doc in case['documents']]})

sphynx/_rag_diagnostics_engine.py

@@ -0,0 +1,243 @@
+"""Grade saved traces and compare compatible cases. Never executes candidates."""
+from __future__ import annotations
+
+from collections import Counter, defaultdict
+from datetime import datetime, timezone
+import random
+import statistics
+
+from ._rag_diagnostics_common import digest, metric
+from ._rag_diagnostics_contracts import validate_dataset
+from ._rag_diagnostics_ranking import ranking_metrics, evidence_metrics
+from ._rag_diagnostics_semantic import semantic_metrics
+
+
+def operational_metrics(case,trace):
+    rows=[]
+    ops=trace['operational']
+    for name,unit in [('latency_ms','ms'),('cost_usd','USD'),('tokens','tokens')]:
+        value=ops.get(name)
+        row=metric('operational.recorded_'+name,case['id'],'operational',value,
+                   grader_type=ops['origin']+'_telemetry',unit=unit,direction='lower',
+                   reason='Saved '+ops['origin']+' telemetry; replay grading duration is not model execution time')
+        rows.append(row)
+    rows.append(metric('operational.failure',case['id'],'operational',float(trace['response']['status']!='ok'),numerator=int(trace['response']['status']!='ok'),denominator=1,direction='lower'))
+    rows.append(metric('operational.timeout',case['id'],'operational',float(trace['response']['status']=='timeout'),numerator=int(trace['response']['status']=='timeout'),denominator=1,direction='lower'))
+    return rows
+
+
+def metric_key(row):
+    return row['stage']+'|'+row['metric_id']
+
+
+def diagnose(case,trace,rows,review):
+    values={row['metric_id']:row['value'] for row in rows}
+    evidence={row['stage']:row['value'] for row in rows if row['metric_id']=='evidence.atom_recall'}
+    first_loss=None;prior_unknown=False
+    for stage in ('indexed','retrieved','reranked','selected','prompt'):
+        value=evidence.get(stage)
+        if value is None:
+            prior_unknown=True
+        elif value<1:
+            first_loss=stage;break
+    result={'first_observed_evidence_loss':first_loss,'earlier_stages_unknown':prior_unknown,
+            'interpretation':'Observational localization over saved traces; no causal intervention was executed.'}
+    status=trace['response']['status']
+    source=case['references'].get('corpus_answerable')
+    sufficient=review.get('context_sufficiency',{}).get('prompt') if review else None
+    correct=values.get('generation.answer_correctness')
+    faithful=values.get('generation.faithfulness')
+    cited=values.get('citation.completeness')
+    citation_precision=values.get('citation.necessity_precision')
+    citation_failed=any(value is not None and value<1 for value in (cited,citation_precision))
+    if status!='ok':label='runtime_'+status
+    elif source is None:label='unknown_source_answerability'
+    elif source is False:
+        if trace['response']['abstained'] is True:
+            if values.get('outcome.grounded_task_success')==1:
+                label='appropriate_abstention'
+            elif not review or review.get('claims_exhaustive') is not True:
+                label='unknown_claim_support'
+            elif any(claim.get('supported_by_context') is False for claim in review['claims']):
+                label='unsupported_abstention'
+            elif any(claim.get('supported_by_context') is None for claim in review['claims']):
+                label='unknown_claim_support'
+            elif citation_failed:
+                label='citation_failure'
+            else:
+                label='incomplete_abstention_evidence' if values.get('outcome.grounded_task_success') is None else 'abstention_policy_failure'
+        else:
+            label='source_gap'
+    elif sufficient is None:label='unknown_context_sufficiency'
+    elif sufficient is False:
+        label='correct_with_insufficient_context' if correct==1 else 'insufficient_delivered_context'
+    elif correct is None:label='unknown_answer_correctness'
+    elif correct==0:label='incorrect_despite_sufficient_context'
+    elif values.get('generation.response_relevance')==0:label='answer_not_relevant'
+    elif faithful is None:label='unknown_claim_support'
+    elif faithful<1:label='unsupported_answer'
+    elif citation_failed:label='citation_failure'
+    elif values.get('outcome.grounded_task_success')==1:label='grounded_success'
+    else:label='incomplete_success_evidence'
+    result['outcome']=label
+    return result
+
+
+def grade_case(case,variant,cutoff):
+    trace=case['traces'][variant]
+    review=case['references'].get('reviews',{}).get(variant)
+    rows=ranking_metrics(case,trace,cutoff)+evidence_metrics(case,trace)+semantic_metrics(case,trace,review)+operational_metrics(case,trace)
+    for row in rows:
+        row['label_provenance']=review.get('provenance') if row['grader_type']!='deterministic' and review else {'kind':'synthetic' if trace['execution_mode']=='synthetic_replay' else 'owner_supplied_reference'}
+    return {'case_id':case['id'],'suite_id':case['suite_id'],'cluster_id':case['cluster_id'],
+            'variant':variant,'trace_id':trace['id'],'trace_digest':digest(trace),
+            'execution_mode':trace['execution_mode'],'metrics':rows,
+            'diagnosis':diagnose(case,trace,rows,review)}
+
+
+def aggregate(rows):
+    grouped=defaultdict(list)
+    for case in rows:
+        for row in case['metrics']:grouped[metric_key(row)].append(row)
+    results={}
+    for key,records in grouped.items():
+        available=[r for r in records if r['value'] is not None]
+        excluded=[r for r in records if r['status']=='unavailable_zero_population']
+        missing=len(records)-len(available)-len(excluded)
+        observed=statistics.fmean(r['value'] for r in available) if available else None
+        sample=records[0]
+        results[key]={'metric_id':sample['metric_id'],'stage':sample['stage'],'direction':sample['direction'],'unit':sample['unit'],
+                      'value':observed if not missing else None,'observed_value':observed,
+                      'scored_cases':len(available),'eligible_cases':len(records)-len(excluded),
+                      'missing_cases':missing,'not_applicable_cases':len(excluded),'complete':not missing,
+                      'aggregation':'macro mean of case metrics; diagnostic cohort only',
+                      'reason_counts':dict(Counter(r['reason'] for r in records if r['reason']))}
+    return results
+
+
+def _conditional(cases,variant,name,eligible,score):
+    n=0;total=0;missing=0;unknown_eligibility=0
+    for case in cases:
+        trace=case['traces'][variant];review=case['references'].get('reviews',{}).get(variant)
+        selected=eligible(case,trace,review)
+        if selected is None:unknown_eligibility+=1;continue
+        if not selected:continue
+        total+=1
+        value=score(case,trace,review)
+        if value is None:missing+=1
+        else:n+=value
+    observed_denominator=total-missing
+    observed=n/observed_denominator if observed_denominator else None
+    complete=not missing and not unknown_eligibility
+    return {'metric_id':name,'value':observed if complete else None,'observed_value':observed,
+            'numerator':n,'denominator':total,'scored_cases':observed_denominator,
+            'missing_cases':missing,'unknown_eligibility_cases':unknown_eligibility,
+            'complete':complete,'status':'available' if complete and total else 'unavailable_incomplete_or_zero_population'}
+
+
+def conditional_metrics(cases,variant):
+    def suff(review,stage='prompt'):
+        return review.get('context_sufficiency',{}).get(stage) if review else None
+    def correct(case,trace,review):
+        if not review or trace['response']['status']!='ok' or trace['response']['abstained'] is None:return None
+        return 0 if trace['response']['abstained'] is True else review.get('answer_correct')
+    def unsupported(case,trace,review):
+        if trace['response']['status']!='ok':return None
+        if not review or review.get('claims_exhaustive') is not True or trace['stages']['prompt'] is None:return None
+        claims=review.get('claims',[])
+        if not claims:return 0 if trace['response']['abstained'] is True else None
+        if any(c.get('supported_by_context') is False for c in claims):return 1
+        if any(c.get('supported_by_context') is None for c in claims):return None
+        return 0
+    return [
+        _conditional(cases,variant,'context.retrieval_sufficiency_recall',lambda c,t,r:c['references'].get('corpus_answerable'),lambda c,t,r:suff(r,'retrieved')),
+        _conditional(cases,variant,'generation.success_given_sufficient_context',lambda c,t,r:suff(r),correct),
+        _conditional(cases,variant,'generation.unsupported_answer_given_insufficient_context',lambda c,t,r:None if suff(r) is None else not suff(r),unsupported),
+        _conditional(cases,variant,'outcome.abstention_recall',lambda c,t,r:r.get('abstention_expected') if r else None,lambda c,t,r:t['response']['abstained'] if t['response']['status']=='ok' else None),
+    ]
+
+
+def paired_comparisons(cases,left,right,samples=1000,seed=17,*,allow_bootstrap=True,interval_scope=None):
+    by_left={r['case_id']:r for r in left};by_right={r['case_id']:r for r in right}
+    a=aggregate(left);b=aggregate(right);results=[]
+    for key in a:
+        pairs=[];excluded=0
+        for case in cases:
+            ar=next(r for r in by_left[case['id']]['metrics'] if metric_key(r)==key)
+            br=next(r for r in by_right[case['id']]['metrics'] if metric_key(r)==key)
+            if ar['value'] is not None and br['value'] is not None:
+                pairs.append({'case_id':case['id'],'cluster_id':case['cluster_id'],
+                              'baseline':ar['value'],'candidate':br['value'],'delta':br['value']-ar['value']})
+            elif ar['status']=='unavailable_zero_population' and br['status']=='unavailable_zero_population':excluded+=1
+        clusters=defaultdict(list)
+        for pair in pairs:clusters[pair['cluster_id']].append(pair['delta'])
+        keys=sorted(clusters);rng=random.Random(seed);draws=[]
+        if allow_bootstrap and len(keys)>=2 and samples:
+            for _ in range(samples):
+                chosen=[d for group in rng.choices(keys,k=len(keys)) for d in clusters[group]]
+                draws.append(statistics.fmean(chosen))
+            draws.sort()
+        interval=[draws[int(.025*(len(draws)-1))],draws[int(.975*(len(draws)-1))]] if draws else None
+        missing_pairs=len(cases)-len(pairs)-excluded
+        observed_delta=statistics.fmean(p['delta'] for p in pairs) if pairs else None
+        task_outcome=a[key]['metric_id'] in ('outcome.task_success','outcome.grounded_task_success')
+        row={'key':key,**a[key],'baseline':a[key],'candidate':b[key],
+             'paired_delta':observed_delta if not missing_pairs else None,
+             'observed_subset_delta':observed_delta,
+             'paired_cases':len(pairs),'excluded_zero_population_pairs':excluded,
+             'missing_pairs':missing_pairs,'eligible_pairs':len(cases)-excluded,
+             'paired_complete':not missing_pairs,'independent_clusters':len(keys),
+             'development_cluster_bootstrap_95':interval if not missing_pairs else None,
+             'observed_subset_bootstrap_95':interval,'bootstrap_samples':samples if allow_bootstrap else 0,
+             'requested_bootstrap_samples':samples,'seed':seed,'bootstrap_allowed':allow_bootstrap,
+             'interval_scope':interval_scope or 'Synthetic diagnostic illustration; not population performance evidence. Primary paired claims require all eligible pairs.',
+             'observed_subset_scope':'Only complete pairs are included; missing eligible pairs can bias this diagnostic subset.',
+             'improved_cases':[p['case_id'] for p in pairs if p['delta']*(1 if a[key]['direction']=='higher' else -1)>0],
+             'worsened_cases':[p['case_id'] for p in pairs if p['delta']*(1 if a[key]['direction']=='higher' else -1)<0],
+             'task_rescued_cases':[p['case_id'] for p in pairs if task_outcome and p['baseline']==0 and p['candidate']==1],
+             'task_regressed_cases':[p['case_id'] for p in pairs if task_outcome and p['baseline']==1 and p['candidate']==0]}
+        results.append(row)
+    return results
+
+
+def evaluate(data,cutoff=3,bootstrap_samples=500):
+    validate_dataset(data)
+    if type(bootstrap_samples) is not int or not 0<=bootstrap_samples<=5000:raise ValueError('bootstrap_samples must be 0–5000')
+    cases=data['cases'];baseline=[grade_case(c,'baseline',cutoff) for c in cases];candidate=[grade_case(c,'candidate',cutoff) for c in cases]
+    all_rows=baseline+candidate
+    modes={trace['execution_mode'] for case in cases for trace in case['traces'].values()}
+    all_synthetic=modes=={'synthetic_replay'}
+    provenance=data.get('provenance') if type(data.get('provenance')) is dict else {}
+    independence_declared=provenance.get('independent_clusters_verified') is True
+    allow_bootstrap=all_synthetic or independence_declared
+    if all_synthetic:
+        cohort='synthetic diagnostic cases; not representative production traffic'
+        interval_scope='Synthetic diagnostic illustration; not population performance evidence. Primary paired claims require all eligible pairs.'
+        independence_basis='Synthetic fixture clusters; arithmetic illustration only.'
+    elif not allow_bootstrap:
+        cohort='mixed synthetic and recorded replay diagnostics' if len(modes)>1 else 'recorded replay diagnostics; representativeness not verified'
+        interval_scope='Cluster independence is unknown for recorded traces; no bootstrap interval is computed.'
+        independence_basis='No explicit independent-cluster declaration; inference disabled.'
+    else:
+        cohort='mixed synthetic and recorded replay diagnostics' if len(modes)>1 else 'recorded replay diagnostics; representativeness not verified'
+        interval_scope='Independent clusters are caller asserted, not verified. Development diagnostic interval only; not validated population performance evidence. Primary paired claims require all eligible pairs.'
+        independence_basis='Caller asserted independent_clusters_verified=true; the prototype does not verify this assertion.'
+    return {'schema_version':'sphynx.rag-diagnostics.report.v1','metric_version':'sphynx.rag-diagnostics.metric.v1',
+            'generated_at':datetime.now(timezone.utc).isoformat(),'dataset_release':data['release'],
+            'dataset_digest':digest(data),'source':'local saved-trace grading; no candidate execution',
+            'cohort':cohort,'execution_modes':sorted(modes),
+            'bootstrap_independence':{'allowed':allow_bootstrap,'basis':independence_basis,'performance_inference_validated':False},
+            'cutoff':cutoff,'case_count':len(cases),'suite_count':len(data['suites']),
+            'metric_definition_count':len({r['metric_id'] for c in all_rows for r in c['metrics']}),
+            'stage_metric_view_count':len(aggregate(baseline)),
+            'suites':data['suites'],'cases':cases,'case_results':all_rows,
+            'aggregates':{'baseline':aggregate(baseline),'candidate':aggregate(candidate)},
+            'conditional':{v:conditional_metrics(cases,v) for v in ('baseline','candidate')},
+            'comparisons':paired_comparisons(cases,baseline,candidate,bootstrap_samples,
+                                            allow_bootstrap=allow_bootstrap,interval_scope=interval_scope),
+            'diagnosis_counts':{v:dict(Counter(r['diagnosis']['outcome'] for r in (baseline if v=='baseline' else candidate))) for v in ('baseline','candidate')},
+            'limitations':['Semantic judgments are supplied synthetic/adjudicated labels, not automated judges.',
+                          'No imported public benchmark or customer performance claim follows from these fixtures.',
+                          'Unjudged documents remain unknown; known-qrel ranking uses zero gain without removing their ranks.',
+                          'First observed evidence loss is descriptive, not proof of causality.',
+                          'Recorded telemetry is separate from replay grading time; no verified cost accounting.']}