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

sphynx/_speech_complete_scoring.py

@@ -0,0 +1,218 @@
+"""Remaining native Kido analyses; descriptive cohorts never imply quality."""
+from collections import Counter, defaultdict
+import math
+import re
+import statistics
+
+from ._speech_kido import csv_rows, json_value, number, require
+from ._speech_scoring import timing_summary, normalize, score_transcript
+from ._speech_benchmark_sources import DIMENSIONS, synthesis_record
+from ._speech_benchmark_scoring import evaluate_pt_br_listening
+from ._speech_complete_source import GOOGLE
+
+
+def summary(values, convention='kido.google-linear.v1'):
+    require(all(type(x) in (int,float) and math.isfinite(x) and x>=0 for x in values),'Invalid descriptive measurement')
+    values=sorted(values);n=len(values)
+    if convention=='kido.google-linear.v1':
+        def q(p):
+            k=(n-1)*p;i=int(k)
+            return values[i]+(values[min(i+1,n-1)]-values[i])*(k-i)
+        result=dict(n=n,mean=statistics.mean(values) if n else None,p50=q(.5) if n else None,p95=q(.95) if n else None,convention=convention)
+    else:result=timing_summary(values,convention=convention)
+    mean=result['mean'];sd=statistics.stdev(values) if n>1 else None
+    return dict(result,min=min(values) if n else None,max=max(values) if n else None,
+        sample_stdev=sd,coefficient_of_variation=sd/mean if sd is not None and mean else None,
+        p95_p50_ratio=result['p95']/result['p50'] if result['p50'] else None)
+
+
+def _groups(rows,key):
+    result=defaultdict(list)
+    for row in rows:result[key(row)].append(row)
+    return sorted(result.items(),key=lambda x:str(x[0]))
+
+
+def _seconds(row,key):
+    return number(row.get(key),key,nullable=True)
+
+
+def evaluate_google_direct_api(rows):
+    """Preserve runs, smoke tests, configs, formats, cancellation and concurrency."""
+    results=[]
+    for (scope,profile),group in _groups(rows,lambda x:(x['scope'],x['record'].get('model',x['record'].get('cfg')))):
+        require(isinstance(profile,str),'Google request lacks profile')
+        records=[r['record'] for r in group]
+        def measurements(items):
+            valid=[r for r in items if r['ok']]
+            timings=[_seconds(r,'ttfa')*1000 for r in valid if r.get('ttfa') is not None]
+            onset=[(_seconds(r,'ttfa')+_seconds(r,'lead_silence_s'))*1000 for r in valid
+                if r.get('ttfa') is not None and r.get('lead_silence_s') is not None]
+            return dict(attempts=len(items),ok=sum(r['ok'] for r in items),not_ok=sum(not r['ok'] for r in items),
+                ttfa_ms=summary(timings),ttfa_missing=len(valid)-len(timings),
+                audible_onset_proxy_ms=summary(onset),audible_onset_missing=len(valid)-len(onset),
+                proxy_scope='TTFA plus reported RMS-threshold leading silence; no playback buffer or listener judgment',
+                leading_silence_ms=summary([_seconds(r,'lead_silence_s')*1000 for r in valid if r.get('lead_silence_s') is not None]),
+                reported_audio_duration_s=summary([_seconds(r,'audio_s') for r in valid if r.get('audio_s') is not None]),
+                reported_rtf=summary([_seconds(r,'rtf') for r in valid if r.get('rtf') is not None]),
+                stall_seconds=summary([_seconds(r,'stall_s') for r in valid if r.get('stall_s') is not None]),
+                gap_max_ms=summary([_seconds(r,'gap_max')*1000 for r in valid if r.get('gap_max') is not None]),
+                stall_over_10ms=sum(_seconds(r,'stall_s')>.01 for r in valid if r.get('stall_s') is not None),
+                http_status_counts=dict(Counter(str(r.get('status')) for r in items)))
+        seq=[r for r in records if r['test']=='seq' or r['test'].startswith('seq:')]
+        by_test={test:measurements(g) for test,g in _groups(records,lambda r:r['test'].split(':')[0])}
+        by_text={text:measurements(g) for text,g in _groups(seq,lambda r:r.get('text') or r['test'].split(':',1)[1])}
+        lang=lambda t:'pt-BR' if t in ('short_pt','long_pt','numbers_pt','mixed_pt_en') else 'en'
+        by_language={language:measurements([r for text,items in _groups(seq,lambda r:r.get('text') or r['test'].split(':',1)[1]) if lang(text)==language for r in items]) for language in ('en','pt-BR')}
+        cancellation=[]
+        for r in records:
+            if r['test']!='cancel':continue
+            start,end=_seconds(r,'cancelled_at'),_seconds(r,'t_closed')
+            cancellation.append(dict(cancel_recorded=start is not None,
+                close_after_cancel_ms=(end-start)*1000 if start is not None and end is not None and end>=start else None,
+                clock_valid=start is not None and end is not None and end>=start,
+                observed_ok=r['ok'],server_stopped_work=None,controlled_microphone_barge_in=None))
+        results.append(dict(scope=scope,profile=profile,requests=len(records),sequential=measurements(seq),
+            by_test=by_test,by_text=by_text,by_language=by_language,
+            by_format={str(fmt):measurements(g) for fmt,g in _groups(records,lambda r:r.get('fmt'))},
+            cancellation=cancellation,reported_wav_validation=[{k:r.get(k) for k in
+                ('test','fmt','wav_valid','riff_size_ok','data_size_ok','align_ok','byterate_ok','odd_bytes')} for r in records if 'wav_valid' in r or r['test'].startswith('fmt')],
+            usage_records=[r['usage'] for r in records if 'usage' in r],cost_usd=None,
+            quality_score=None,perceived_latency=None,confidence_interval=None,
+            execution_boundary='historical direct HTTP; never pooled with official/live results'))
+    return results
+
+
+def evaluate_pronunciation_proxy(rows):
+    require(len({r['id'] for r in rows})==len(rows),'Duplicate pronunciation proxy ID')
+    result=[]
+    for row in rows:
+        require(all(isinstance(row.get(k),str) for k in ('id','category','reference','stt_proxy_transcript')),'Invalid pronunciation proxy')
+        result.append(dict(id=row['id'],category=row['category'],reference=row['reference'],
+            stt_proxy_transcript=row['stt_proxy_transcript'],
+            normalized_text_differs=normalize(row['reference'])!=normalize(row['stt_proxy_transcript']),
+            human_review_required=True,human_review_available=False,pronunciation_correct=None,wer_as_pronunciation_quality=None,
+            note='TTS and ASR effects are confounded; written numbers differ from spoken forms; no inferred pronunciation score.'))
+    return result
+
+
+def evaluate_isolated_diagnostics(trials):
+    """All-calls, first measured call per process/wave, slices and repetition."""
+    results=[];convention='kido.isolated-rounded-index.v1'
+    for profile,group in _groups(trials,lambda r:r['candidate']):
+        require(len({(r['line_id'],r['repetition']) for r in group})==len(group),'Duplicate isolated trial')
+        good=[r for r in group if r['success']=='true']
+        def timing(rows):return summary([float(r['ttfa_ms']) for r in rows if r['success']=='true' and r['ttfa_ms']!=''],convention)
+        first=[g[0] for _,g in _groups(group,lambda r:r['repetition'])]
+        first_ids={id(r) for r in first};steady=[r for r in group if id(r) not in first_ids]
+        all_calls=timing(group);first_stat=timing(first);steady_stat=timing(steady)
+        threshold=all_calls['mean']+3*all_calls['sample_stdev'] if all_calls['sample_stdev'] is not None else None
+        tags=sorted({t for r in group for t in re.split('[|,]',r['tags']) if t})
+        results.append(dict(profile=profile,provider=group[0]['provider'],model=group[0]['model'],
+            attempts=len(group),successful=len(good),failed=len(group)-len(good),all_calls_ms=all_calls,
+            request_completion_ms=summary([float(r['duration_ms']) for r in good if r['duration_ms']!=''],convention),
+            request_completion_is_playback_duration=False,
+            first_measured_call_ms=first_stat,steady_state_ms=steady_stat,
+            first_call_delta_mean_ms=first_stat['mean']-steady_stat['mean'] if first_stat['mean'] is not None and steady_stat['mean'] is not None else None,
+            first_call_lines=[r['line_id'] for r in first],schedule_confound='First call is confounded with its scheduled corpus text; not an isolated causal cold-start effect.',
+            by_repetition={str(rep):timing(g) for rep,g in _groups(group,lambda r:r['repetition'])},
+            by_content_slice={tag:timing([r for r in group if tag in re.split('[|,]',r['tags'])]) for tag in tags},
+            outlier_threshold_ms=threshold,outlier_rule='strictly above sample mean + 3 sample standard deviations',
+            outliers=[dict(line_id=r['line_id'],repetition=r['repetition'],ttfa_ms=float(r['ttfa_ms'])) for r in good if threshold is not None and float(r['ttfa_ms'])>threshold],
+            confidence_interval=None,perceived_latency=None))
+    return results
+
+
+def evaluate_listening_diagnostics(observations,references,trials):
+    refs={r['id']:r for r in references};tag_map={r['line_id']:re.split('[|,]',r['tags']) for r in trials}
+    result=[]
+    for (cohort,model),group in _groups([r for r in observations if r['track']=='tts_listening'],lambda r:(r['cohort'],r['model'])):
+        def ratings(rows):
+            values=[refs[r['id']]['overall_quality'] for r in rows];present=[v for v in values if v is not None]
+            return dict(expected=len(values),rated=len(present),pending=len(values)-len(present),
+                mean=statistics.mean(present) if present and len(present)==len(values) else None,
+                observed_subset_mean=statistics.mean(present) if present else None,
+                sample_stdev=statistics.stdev(present) if len(present)>1 else None,
+                distribution={str(v):present.count(v) for v in range(1,6)})
+        tags=sorted({t for r in group for t in tag_map.get(r['case_id'],[])})
+        result.append(dict(cohort=cohort,model=model,overall=ratings(group),
+            by_content_slice={tag:ratings([r for r in group if tag in tag_map.get(r['case_id'],[])]) for tag in tags},
+            historical_raters=1,confidence_interval=None,subrating_dimensions_available=False))
+    return result
+
+
+def evaluate_pt_br_categories(rows):
+    rated=[r for r in rows if all(r['ratings'][d] is not None for d in DIMENSIONS)]
+    return dict(by_category={category:evaluate_pt_br_listening(g) for category,g in _groups(rows,lambda r:r['category'])},
+        complete_rating_vectors=len(rated),identical_four_dimension_vectors=sum(len(set(r['ratings'].values()))==1 for r in rated),
+        independent_dimension_judgments_established=False,historical_raters=1)
+
+
+def evaluate_official_turns(sessions):
+    """Native delivery order and final interruption/recovery joins, without guessed moments."""
+    results=[]
+    for session in sessions:
+        entry=session['identity'];events=session['events'];attempts=[];responses=[];playout={};delivery_response={}
+        for index,event in enumerate(events):
+            d=event.get('data',{})
+            if event.get('type')=='synthesis_complete':
+                r=synthesis_record(event,entry['configured_provider']);r['event_index']=index
+                if r['response_id'] not in responses:responses.append(r['response_id'])
+                r['delivery_ordinal']=responses.index(r['response_id'])+1;attempts.append(r)
+            if event.get('type')=='turn_trace' and isinstance(d.get('delivery_id'),str):
+                if d.get('response_id'):delivery_response[d['delivery_id']]=d['response_id']
+                if d.get('name')=='playout' and d.get('measurement')=='transport_buffer_estimate':
+                    require(type(d.get('interrupted')) is bool,'Invalid official playout flag')
+                    playout[d['delivery_id']]=dict(interrupted=d['interrupted'],complete=d.get('complete'),event_index=index)
+        interruptions=[]
+        for delivery,record in playout.items():
+            if not record['interrupted']:continue
+            response=delivery_response.get(delivery)
+            next_attempt=next((r for r in attempts if r['event_index']>record['event_index'] and r['response_id']!=response),None)
+            interruptions.append(dict(delivery_id=delivery,response_id=response,
+                next_attempt_after_terminal_event=next_attempt,
+                recovery_observed=next_attempt['success'] and next_attempt['provider_matches'] if next_attempt else None,
+                controlled_barge_in=False,cause_known=False))
+        moments=entry.get('moment_map',{})
+        rapid=[]
+        for ordinal in range(7,11):
+            step=[a for a in attempts if a['delivery_ordinal']==ordinal]
+            rapid.append(dict(delivery_ordinal=ordinal,verified_moment_id=moments.get(str(ordinal)),attempts=step,
+                fresh_valid_ttfa_ms=[a['fresh_ttfa_ms'] for a in step if a['fresh_ttfa_ms'] is not None]))
+        results.append(dict(session_id=entry['room_sid'],experiment_id=entry['experiment_id'],provider=entry['configured_provider'],
+            model=entry['configured_model'],runtime_sha=entry['runtime_sha'],attempts=attempts,
+            terminal_playout_deliveries=len(playout),interrupted_deliveries=len(interruptions),interruptions=interruptions,
+            ordinal_window_7_to_10=rapid,scenario_alignment='explicit-native-moment-map' if moments else 'unavailable-do-not-equate-delivery-index-with-scenario',
+            controlled_barge_in_success=None,timing_controlled_stress_result=None,perceived_latency=None))
+    return results
+
+
+def evaluate_stt_diagnostics(analyses):
+    """Recompute strict scores; retain separately supplied sensitivity counts."""
+    results=[]
+    for profile,data in sorted(analyses.items()):
+        rows=data['per_clip'];require(len({r['id'] for r in rows})==len(rows),'Duplicate STT analysis clip')
+        groups={}
+        for tag in sorted({t for r in rows for t in r['tags']}):
+            group=[r for r in rows if tag in r['tags']];scores=[score_transcript(r['reference'],r['hypothesis']) for r in group if isinstance(r.get('hypothesis'),str)]
+            words=sum(s['reference_words'] for s in scores);chars=sum(s['reference_characters'] for s in scores)
+            groups[tag]=dict(clips=len(group),scored=len(scores),strict_wer=sum(s['word_errors'] for s in scores)/words if words and len(scores)==len(group) else None,
+                strict_cer=sum(s['character_errors'] for s in scores)/chars if chars and len(scores)==len(group) else None)
+        parity=[]
+        for row in rows:
+            if not isinstance(row.get('hypothesis'),str):continue
+            score=score_transcript(row['reference'],row['hypothesis'])
+            require(score['word_errors']==row['strict_edit_distance'] and score['reference_words']==row['strict_ref_words'] and
+                score['character_errors']==row['cer_edit_distance'] and score['reference_characters']==row['cer_ref_chars'],'Independent STT strict counts differ')
+            parity.append(row['id'])
+        sensitivity={}
+        for key in ('core','sensitivity'):
+            eligible=[r for r in rows if r.get(key+'_ref_words') is not None and r.get(key+'_edit_distance') is not None]
+            require(all(type(r[key+'_ref_words']) is int and r[key+'_ref_words']>=0 and type(r[key+'_edit_distance']) is int and r[key+'_edit_distance']>=0 for r in eligible),'Invalid supplied sensitivity counts')
+            words=sum(r[key+'_ref_words'] for r in eligible)
+            sensitivity[key]=dict(scored=len(eligible),expected=len(rows),reference_words=words,
+                pooled_wer=sum(r[key+'_edit_distance'] for r in eligible)/words if words and len(eligible)==len(rows) else None,
+                provenance='arithmetic over supplied transformed-text counts; generic transformation code not retained upstream')
+        results.append(dict(profile=profile,strict_parity_clips=len(parity),by_content_slice=groups,supplied_sensitivity=sensitivity,
+            supplied_entity_exactness=data['entity_exactness'],supplied_latency=data['latency'],
+            latency_scope='source transcript delay; no audio-based endpoint accuracy',confidence_interval=None))
+    return results

sphynx/_speech_complete_source.py

@@ -0,0 +1,118 @@
+"""Complete, inert Kido source census. Private evidence is never packaged."""
+from pathlib import Path
+import ast
+import hashlib
+import subprocess
+
+from ._speech_kido import digest, encoded, json_value, normalize_kido, require, SpeechEvidenceError
+from ._speech_benchmark_sources import SOURCE_COMMIT, PT, PRON, SWITCH, normalize_sources
+from .speech_evidence import _plain, _read
+
+SOURCE_PIN = '95f2a5872f3256d407479dc62b8daf2cf63d585accc72be81b3b3b61cf89a26e'
+SCHEMA = 'sphynx.speech.kido-complete.source.v1'
+GOOGLE = 'results/exploratory/google-gemini-tts/'
+PROXY = 'results/exploratory/pronunciation-v1-cartesia-only/'
+
+
+def selected(path):
+    p = Path(path)
+    if any(x.startswith('.') for x in p.parts):
+        return False
+    if p.suffix in {'.md', '.py', '.go'}:
+        return True
+    if path.startswith((PRON+'sessions/', SWITCH+'sessions/')):
+        return path.endswith(('/session.json', '/metadata.json', '/agent_config.json')) or (
+            '/events/chunk_' in path and '/record/' not in path and path.endswith('.jsonl')) or (
+            path.startswith(SWITCH) and '/record/transcript/chunk_' in path and path.endswith('.jsonl'))
+    return (path.startswith('harness/corpus/') and p.suffix == '.json' or
+        path.startswith('configs/') and path.count('/') == 1 and p.suffix == '.json' or
+        path.startswith(('provenance/run-jsons/', 'provenance/manifests/', 'scripts/manifests/')) and p.suffix == '.json' or
+        path == 'provenance/audio-evidence-manifest.csv' or
+        path.startswith('results/human-eval/') and p.suffix in {'.json', '.csv'} or
+        path.startswith('results/isolated/official-v1/') and p.suffix == '.csv' or
+        path.startswith('results/live-agent/official-v1/raw-events/') and p.suffix in {'.json', '.jsonl'} or
+        path.startswith('results/live-agent/official-v1/analysis/') and p.suffix == '.csv' or
+        path.startswith(PT) and p.suffix in {'.json', '.csv'} or
+        path.startswith(PRON+'listening-review/') and p.suffix == '.csv' or
+        path.startswith(SWITCH+'track-c-code-switching/') and p.suffix == '.json' or
+        path.startswith((GOOGLE, PROXY)) and p.suffix == '.json' or
+        path.startswith('results/exploratory/cartesia-ink-2-stt/hands-on') and path.endswith(('corpus.json', 'raw_results.json', 'final_analysis.json')) or
+        path.startswith('results/exploratory/cartesia-ink-2-stt/turn-detection') and path.endswith(('turn_events_raw.json', 'pause_clips_manifest.json')))
+
+
+def inventory(data):
+    require(0 < len(data) <= 2000 and sum(map(len, data.values())) <= 64*1024*1024, 'Invalid complete source census')
+    require(all(selected(p) and len(b) <= 16*1024*1024 for p,b in data.items()), 'Invalid complete source file')
+    return dict(schema_version=SCHEMA, source_commit=SOURCE_COMMIT,
+        files={p:dict(sha256=digest(b), size_bytes=len(b)) for p,b in sorted(data.items())})
+
+
+def source_bytes(root):
+    root = Path(root).absolute(); _plain(root)
+    data = {p.relative_to(root).as_posix():_read(root,p.relative_to(root).as_posix())
+        for p in sorted(root.rglob('*')) if p.is_file() and selected(p.relative_to(root).as_posix())}
+    lock = inventory(data)
+    require(digest(encoded(lock)) == SOURCE_PIN, 'Complete source differs from reviewed committed bytes')
+    return lock, data
+
+
+def git_bytes(repository):
+    root = Path(repository).absolute(); _plain(root)
+    try:
+        names = subprocess.check_output(['git','ls-tree','-r','--name-only',SOURCE_COMMIT], cwd=root, timeout=30).decode().splitlines()
+        paths = sorted(p for p in names if selected(p))
+        raw = subprocess.check_output(['git','cat-file','--batch'], cwd=root,
+            input=''.join(SOURCE_COMMIT+':'+p+'\n' for p in paths).encode(), timeout=60)
+    except (OSError, subprocess.SubprocessError, UnicodeError):
+        raise SpeechEvidenceError('Unable to read committed complete source') from None
+    cursor=0; data={}
+    for p in paths:
+        end=raw.find(b'\n',cursor); require(end>=cursor,'Missing Git blob header')
+        header=raw[cursor:end].split(); require(len(header)==3 and header[1]==b'blob','Missing committed source blob')
+        size=int(header[2]); require(0<=size<=16*1024*1024,'Oversized source blob')
+        start=end+1; b=raw[start:start+size]; cursor=start+size+1
+        require(len(b)==size and raw[cursor-1:cursor]==b'\n' and
+            hashlib.sha1(b'blob '+str(size).encode()+b'\0'+b).hexdigest().encode()==header[0], 'Git blob identity mismatch')
+        data[p]=b
+    lock=inventory(data)
+    require(cursor==len(raw) and digest(encoded(lock))==SOURCE_PIN,'Complete Git source differs from reviewed source')
+    return lock,data
+
+
+def literal_assignment(raw, name):
+    tree=ast.parse(raw.decode('utf-8'))
+    values=[ast.literal_eval(n.value) for n in tree.body if isinstance(n,ast.Assign)
+        and any(isinstance(t,ast.Name) and t.id==name for t in n.targets)]
+    require(len(values)==1,'Missing or duplicated inert source constant')
+    return values[0]
+
+
+def normalize(data):
+    observations,references,audit=normalize_kido(data)
+    google=[]
+    for filename,scope in [('full.json','A'),('compare_full.json','B'),('smoke.json','smoke-A'),('compare_smoke.json','smoke-B')]:
+        rows=json_value(data[GOOGLE+'raw-results/'+filename]); require(type(rows) is list,'Invalid Google trial census')
+        for i,row in enumerate(rows):
+            require(type(row) is dict and type(row.get('ok')) is bool and isinstance(row.get('test'),str),'Invalid Google request record')
+            google.append(dict(id='google:'+scope+':'+str(i+1),scope=scope,source_index=i+1,record=row))
+    proxy=json_value(data[PROXY+'pronunciation_results.json'])
+    require(type(proxy) is list and len({r['id'] for r in proxy})==len(proxy),'Invalid proxy census')
+    texts=literal_assignment(data[GOOGLE+'code/bench.py'],'TEXTS')
+    require(type(texts) is dict and all(isinstance(k,str) and isinstance(v,str) for k,v in texts.items()),'Invalid Google text corpus')
+    multilingual=json_value(data['harness/corpus/multilingual-extension-v1.json'])
+    require(len(multilingual['lines'])==len(multilingual['languages'])*multilingual['lines_per_language']
+        and len({r['id'] for r in multilingual['lines']})==len(multilingual['lines']),'Invalid multilingual corpus')
+    sessions=[]
+    for entry in json_value(data['scripts/manifests/official-v1-live-sessions.json']):
+        prefix='results/live-agent/official-v1/raw-events/'+entry['room_sid']+'-events-chunk_'
+        events=[json_value(line) for p in sorted(data) if p.startswith(prefix) for line in data[p].splitlines() if line.strip()]
+        sessions.append(dict(identity=entry,events=events))
+    snapshot=data['results/live-agent/official-v1/live-eval-11-moment-config-snapshot-2026-09-22.md'].decode('utf-8')
+    import re
+    script=[dict(id='moment:'+m[0],text=m[2].strip('"'),language='pt-BR' if m[0]=='10' else 'en',title=m[1])
+        for m in re.findall(r'^\| ([0-9]+) \| ([^|]+) \| (.+) \|$',snapshot,re.M)]
+    require(len(script)==11,'Missing frozen eleven-moment script')
+    return dict(saved=dict(observations=observations,references=references,audit=audit),benchmarks=normalize_sources(data),official_script=script,
+        google=google,google_texts=texts,proxy=proxy,multilingual=multilingual,official_sessions=sessions,
+        stt_analyses={folder:json_value(data['results/exploratory/cartesia-ink-2-stt/'+folder+'/final_analysis.json']) for folder in ('hands-on-v1','hands-on-ink2-v1')},
+        source_documents={p:digest(b) for p,b in data.items() if p.endswith('.md')})

sphynx/_speech_kido.py

@@ -0,0 +1,294 @@
+"""Parse a pinned Kido source export as inert data. Never import source code."""
+from __future__ import annotations
+
+import csv
+import hashlib
+import io
+import json
+import math
+import re
+
+
+class SpeechEvidenceError(ValueError):
+    """Speech input bytes, identities, or saved evidence are invalid."""
+
+
+def require(condition, message):
+    if not condition:
+        raise SpeechEvidenceError(message)
+
+
+def digest(raw):
+    return hashlib.sha256(raw).hexdigest()
+
+
+def encoded(value):
+    return (json.dumps(value, ensure_ascii=False, sort_keys=True,
+                       separators=(",", ":"), allow_nan=False) + "\n").encode("utf-8")
+
+
+def json_value(raw):
+    def pairs(items):
+        result = {}
+        for key, value in items:
+            require(key not in result, "duplicate speech JSON field")
+            result[key] = value
+        return result
+    def finite(value):
+        result = float(value)
+        require(math.isfinite(result), "nonfinite speech JSON number")
+        return result
+    try:
+        return json.loads(raw.decode("utf-8"), object_pairs_hook=pairs, parse_float=finite,
+                          parse_constant=lambda _: require(False, "nonfinite speech JSON"))
+    except (ValueError, UnicodeError, RecursionError) as exc:
+        if isinstance(exc, SpeechEvidenceError):
+            raise
+        raise SpeechEvidenceError("invalid speech JSON") from None
+
+
+def csv_rows(raw):
+    reader = csv.DictReader(io.StringIO(raw.decode("utf-8-sig"), newline=""))
+    names = reader.fieldnames
+    require(names and len(set(names)) == len(names), "missing or duplicate speech CSV headers")
+    rows = list(reader)
+    require(all(None not in row and None not in row.values() for row in rows), "malformed speech CSV row")
+    return rows
+
+
+def number(value, label, *, nullable=False):
+    if value is None and nullable:
+        return None
+    require(type(value) in (int, float) and math.isfinite(value) and value >= 0,
+            label + " must be finite and nonnegative")
+    return value
+
+
+def _float(value, label):
+    try:
+        return number(float(value), label)
+    except (ValueError, OverflowError):
+        raise SpeechEvidenceError(label + " must be numeric") from None
+
+
+def _integer(value, label):
+    require(isinstance(value, str) and re.fullmatch(r"0|[1-9][0-9]*", value), label + " must be an integer")
+    return int(value)
+
+
+def _bool(value):
+    require(value in ("true", "false"), "speech success must be true or false")
+    return value == "true"
+
+
+def reconstruct_transcript(events):
+    """Final segments carry their own spacing. Never join them with spaces."""
+    require(isinstance(events, list), "STT events must be an ordered list")
+    segments = []
+    last = -1
+    for event in events:
+        require(isinstance(event, dict) and isinstance(event.get("msg"), dict), "invalid STT event")
+        when = number(event.get("t"), "STT event timestamp")
+        require(when >= last, "STT events are out of order")
+        last = when
+        msg = event["msg"]
+        if event.get("type") == "transcript":
+            require(type(msg.get("is_final")) is bool and isinstance(msg.get("text"), str),
+                    "invalid STT transcript event")
+            if msg["is_final"]:
+                segments.append(msg["text"])
+    return "".join(segments).strip() if segments else None
+
+
+def provider_gate(provider, records):
+    """Compatibility gate from the frozen parser; not full model verification."""
+    successes = [r for r in records if r["success"]]
+    observed = {r["observed_provider"] for r in successes if r["observed_provider"]}
+    fallback = any(r["observed_provider"] and r["observed_provider"] != provider for r in records)
+    confirmed = bool(records) and observed == {provider}
+    any_error = any(r["error_present"] for r in records)
+    return {"provider_confirmed": confirmed, "fallback_observed": fallback,
+            "any_synthesis_error": any_error,
+            "legacy_provider_gate": confirmed and not fallback and not any_error and bool(successes)}
+
+
+def normalize_kido(files):
+    """Return normalized observations, protected references, and intake audit."""
+    observations, references = [], []
+    trials_path = "results/isolated/official-v1/combined/trials.csv"
+    raw_trials = files[trials_path]
+    trials = csv_rows(raw_trials)
+    legacy = json_value(files["provenance/manifests/combined-manifest.json"])
+    n = legacy["observed_total_trials"]
+    require(type(n) is int and 0 < n <= len(trials), "invalid historical trial census")
+    # The original dataset is an exact byte prefix. Prove it; never waive a hash.
+    prefix = b"".join(raw_trials.splitlines(keepends=True)[:n + 1])
+    require(digest(prefix) == legacy["combined_trials_csv_sha256"],
+            "historical TTS prefix no longer matches its manifest")
+    configs = {}
+    for path, raw in files.items():
+        if path.startswith("configs/") and path.count("/") == 1 and path.endswith(".json"):
+            config = json_value(raw)
+            for candidate in config["candidates"]:
+                key = candidate["name"]
+                require(key not in configs, "duplicate configured speech candidate")
+                configs[key] = (candidate, {line["id"]: line for line in config["lines"]})
+    seen = set()
+    config_identity_verified = 0
+    for index, row in enumerate(trials):
+        name, rep = row["candidate"], _integer(row["repetition"], "repetition")
+        require(name in configs, "TTS trial has no pinned configuration")
+        candidate, lines = configs[name]
+        require(row["line_id"] in lines and rep > 0, "TTS trial has no eligible corpus line")
+        require(all(row[k] == candidate[k] for k in ("provider", "model", "voice_id")),
+                "TTS trial differs from configured identity")
+        key = (name, row["line_id"], rep)
+        require(key not in seen, "duplicate isolated TTS trial")
+        seen.add(key)
+        success = _bool(row["success"])
+        count = _integer(row["bytes"], "audio bytes")
+        require(not success or (count > 0 and not row["failure_reason"]), "successful TTS trial lacks audio or has a failure")
+        line = lines[row["line_id"]]
+        if index < n:
+            cohort = "core-five-20260921"
+            receipt_path = f"provenance/run-jsons/wave-{rep}-{row['provider']}.run.json"
+            require(receipt_path in files, "missing original TTS run receipt")
+            receipt = json_value(files[receipt_path])
+            require(receipt["rep_start"] == rep and receipt["scheduled_trials"] == len(lines)
+                    and receipt["candidates"] == [candidate], "TTS run receipt differs from trials")
+            config_path = next(p for p in files if p.startswith("configs/") and p.endswith(".json")
+                               and json_value(files[p]).get("candidates") == [candidate])
+            config_matches = digest(files[config_path]) == receipt["corpus_sha256"]
+            config_identity_verified += config_matches
+            source_status = ("original_run_receipt_and_config_verified" if config_matches else
+                             "original_run_receipt_present_config_bytes_unverified")
+        else:
+            cohort = "google-extension" if row["provider"] == "google" else "eleven-v4-extension"
+            source_status = "repository_bytes_pinned_original_run_receipt_unavailable"
+        observations.append({"id": f"isolated/{name}/{row['line_id']}/{rep}", "track": "tts_isolated",
+            "cohort": cohort, "model": row["model"], "provider": row["provider"],
+            "voice_id": row["voice_id"], "case_id": row["line_id"], "repetition": rep,
+            "cluster_id": row["line_id"], "input_text": line["text"], "language": line.get("language", "en"),
+            "success": success, "failure_reason": row["failure_reason"], "audio_bytes": count,
+            "ttfa_ms": _float(row["ttfa_ms"], "isolated TTFA") if success else None,
+            "request_completion_ms": _float(row["duration_ms"], "request completion") if success else None,
+            "audio_duration_ms": None, "audio_available": False,
+            "execution_source_status": source_status, "source_row": index + 1})
+    # Check every eligible case/repetition exists. No success-only or provider-only census.
+    for name, (_, lines) in configs.items():
+        require({key for key in seen if key[0] == name} ==
+                {(name, line, rep) for line in lines for rep in range(1, 6)}, "isolated TTS census is incomplete")
+
+    for folder, model in (("hands-on-v1", "ink-preview"), ("hands-on-ink2-v1", "ink-2")):
+        base = "results/exploratory/cartesia-ink-2-stt/" + folder + "/"
+        corpus = json_value(files[base + "corpus.json"])
+        lines = {line["id"]: line for line in corpus["lines"]}
+        rows = json_value(files[base + "raw_results.json"])
+        require(len(rows) == len(lines) and {r["clip_id"] for r in rows} == set(lines), "STT census is incomplete or duplicated")
+        for row in rows:
+            hypothesis = reconstruct_transcript(row["events"])
+            success = row["status"] == "success"
+            require(not success or hypothesis is not None, "successful STT trace has no final transcript")
+            start = number(row["stream_start_epoch"], "STT stream start")
+            sent = number(row["last_audio_sent_epoch"], "STT last chunk")
+            require(sent >= start, "STT send clock is reversed")
+            first = number(row["first_transcript_epoch"], "STT first transcript", nullable=True)
+            final = number(row["final_transcript_epoch"], "STT final transcript", nullable=True)
+            require(first is None or first >= start, "STT first-text clock is reversed")
+            require(final is None or final >= sent, "STT final-text clock is reversed")
+            case = row["clip_id"]
+            identity = f"stt/{model}/{case}"
+            observations.append({"id": identity, "track": "stt_recognition", "cohort": "synthetic-english-20",
+                "model": model, "provider": "cartesia", "case_id": case, "cluster_id": case,
+                "success": success, "hypothesis": hypothesis if success else None,
+                "events": row["events"], "stored_final_text": row.get("final_text"),
+                "reconstruction": "exact-final-segment-concatenation.v1",
+                "first_text_ms": (first - start) * 1000 if success and first is not None else None,
+                "final_text_ms": (final - sent) * 1000 if success and final is not None else None,
+                "clock_domain": "source-client-monotonic-relative", "audio_available": False})
+            references.append({"id": identity, "reference": lines[case]["text"],
+                               "provenance": "synthetic-script-not-human-audio-review", "language": "en"})
+
+    mapping_rows = json_value(files["results/human-eval/mapping.json"])["mapping"]
+    mapping = {r["blind_sample_id"]: r for r in mapping_rows}
+    require(len(mapping) == len(mapping_rows), "duplicate blind sample mapping")
+    scores = csv_rows(files["results/human-eval/scores.csv"])
+    require(len(scores) == len(mapping) and {r["blind_sample_id"] for r in scores} == set(mapping),
+            "blind rating census is incomplete or duplicated")
+    for row in scores:
+        sample = mapping[row["blind_sample_id"]]
+        require(row["corpus_line_id"] == sample["corpus_line_id"], "rating and mapping case differ")
+        score = _float(row["overall_quality_1_5"], "overall rating") if row["overall_quality_1_5"] else None
+        require(score is None or (score.is_integer() and 1 <= score <= 5), "rating outside integer 1-5 scale")
+        identity = "listening/" + row["blind_sample_id"]
+        observations.append({"id": identity, "track": "tts_listening", "cohort": "single-rater-repetition-3",
+            "model": sample["model"], "provider": sample["provider"], "case_id": sample["corpus_line_id"],
+            "cluster_id": sample["corpus_line_id"], "sample_id": row["blind_sample_id"],
+            "audio_available": False})
+        references.append({"id": identity, "overall_quality": score, "review_status": "rated" if score is not None else "pending",
+            "provenance": "historical-single-rater-overall-only", "naturalness": None, "perceived_waiting": None})
+
+    sessions = json_value(files["scripts/manifests/official-v1-live-sessions.json"])
+    require(len({s["room_sid"] for s in sessions}) == len(sessions), "duplicate speech session")
+    for session in sessions:
+        prefix = "results/live-agent/official-v1/raw-events/" + session["room_sid"]
+        metadata = json_value(files[prefix + "-metadata.json"]) if prefix + "-metadata.json" in files else {}
+        chunk_paths = sorted(p for p in files if p.startswith(prefix + "-events-chunk_") and p.endswith(".jsonl"))
+        require(chunk_paths, "missing live event chunks")
+        chunk_numbers = [int(re.search(r"chunk_(\d+)\.jsonl$", p).group(1)) for p in chunk_paths]
+        require(chunk_numbers == list(range(chunk_numbers[0], chunk_numbers[0] + len(chunk_numbers))), "gap in live event chunks")
+        events = [json_value(line) for path in chunk_paths for line in files[path].splitlines() if line.strip()]
+        event_ids = [e["id"] for e in events if e.get("id")]
+        require(len(event_ids) == len(set(event_ids)), "duplicate live event ID")
+        records, attempts = [], {}
+        for event in events:
+            if event.get("type") != "synthesis_complete":
+                continue
+            data = event["data"]
+            require(all(type(data.get(k)) is bool for k in ("complete", "cancelled", "cache_hit")), "missing live synthesis flags")
+            response = data.get("response_id") or ""
+            require(response, "live synthesis has no response ID")
+            attempts[response] = attempts.get(response, 0) + 1
+            audio_bytes = data.get("produced_audio_bytes")
+            require(type(audio_bytes) is int and audio_bytes >= 0, "invalid live audio bytes")
+            error = data.get("error") or ""
+            require(isinstance(error, str), "invalid live error")
+            success = data["complete"] and not data["cancelled"] and not error and audio_bytes > 0
+            start = number(data.get("started_at"), "live synthesis start", nullable=True)
+            first = number(data.get("first_audio_at"), "live first audio", nullable=True)
+            end = number(data.get("ended_at"), "live synthesis end", nullable=True)
+            clock_ok = start is not None and first is not None and end is not None and start <= first <= end
+            row = {"id": f"live/{session['room_sid']}/{response}/{attempts[response]}", "track": "tts_live",
+                "cohort": session["experiment_id"] + ("/substitute-agent-v4" if session["configured_model"] in ("eleven_v4", "eleven_v4_turbo") else "/original-agent"),
+                "session_id": session["room_sid"], "cluster_id": session["room_sid"],
+                "case_id": event.get("turn_id") or response, "attempt": attempts[response],
+                "model": session["configured_model"], "provider": session["configured_provider"],
+                "declared_voice_id": session["configured_voice_id"],
+                "observed_provider": data.get("provider") or None, "observed_model": data.get("model") or None,
+                "observed_voice_id": data.get("voice_id") or None,
+                "runtime_sha_declared": session["runtime_sha"], "runtime_sha_observed": metadata.get("git_sha"),
+                "session_metadata_present": bool(metadata),
+                "success": success, "cancelled": data["cancelled"], "cache_hit": data["cache_hit"],
+                "error_present": bool(error), "audio_bytes": audio_bytes,
+                "ttfa_ms": (first - start) * 1000 if success and clock_ok else None,
+                "clock_status": "ordered" if clock_ok else "unavailable_or_reversed",
+                "audio_available": False}
+            records.append(row)
+        observations.extend(records)
+        gate = provider_gate(session["configured_provider"], records)
+        # One census record even when a session never produced synthesis evidence.
+        observations.append({"id": "session/" + session["room_sid"], "track": "tts_live_session",
+            "cohort": session["experiment_id"] + ("/substitute-agent-v4" if session["configured_model"] in ("eleven_v4", "eleven_v4_turbo") else "/original-agent"),
+            "model": session["configured_model"], "provider": session["configured_provider"],
+            "case_id": session["room_sid"], "cluster_id": session["room_sid"],
+            "session_metadata_present": bool(metadata), "attempts": len(records), **gate})
+    require(len({r["id"] for r in observations}) == len(observations), "duplicate normalized speech observation")
+    audit = {"historical_manifest_matches_current_csv": digest(raw_trials) == legacy["combined_trials_csv_sha256"],
+        "historical_prefix_verified": True, "historical_prefix_trials": n, "current_trials": len(trials),
+        "extension_trials": len(trials) - n,
+        "extension_original_run_receipts": "unavailable",
+        "original_configuration_identity_verified_trials": config_identity_verified,
+        "original_configuration_identity_unverified_trials": n - config_identity_verified,
+        "audio_assets_copied": False, "capture_completeness": "historical-export-no-global-loss-counter",
+        "perceived_latency_available": False, "human_review": "existing-single-rater-only"}
+    return observations, references, audit