#!/usr/bin/env python3
"""Run from a machine with T3 dependencies installed. Usage: measure.py CHECKOUT OUTPUT PORT [SAMPLES].
Synthetic, offline projection seeding is necessary: no app command creates historical usage-limit failures.
Only the actual t3 serve process performs measured recovery sweeps. No query or application code is patched.
"""
import os,sys,json,time,sqlite3,subprocess,statistics,platform,urllib.request
from pathlib import Path
checkout=Path(sys.argv[1]); out=Path(sys.argv[2]); port=int(sys.argv[3]); samples=int(sys.argv[4]) if len(sys.argv)>4 else 25
out.mkdir(parents=True,exist_ok=False); home=out/'home'; dbpath=home/'userdata/statev2.sqlite'; settings=home/'userdata/settings.json'; trace=home/'userdata/logs/server.trace.ndjson'
sha=subprocess.check_output(['git','rev-parse','HEAD'],cwd=checkout,text=True).strip()
log=open(out/'private-server.log','w'); proc=None

def start():
 global proc
 proc=subprocess.Popen(['node','apps/server/src/bin.ts','serve','--host','127.0.0.1','--port',str(port),'--base-dir',str(home),'--no-browser'],cwd=checkout,env={**os.environ,'T3CODE_DEV_SEED':'0','T3CODE_TRACE_MAX_BYTES':'100000000'},stdout=log,stderr=log)
 deadline=time.monotonic()+90
 while time.monotonic()<deadline:
  if proc.poll() is not None: raise RuntimeError('Server exited; inspect private-server.log')
  try:
   urllib.request.urlopen(f'http://127.0.0.1:{port}/api/health',timeout=1)
  except urllib.error.HTTPError: pass
  except OSError: pass
  if dbpath.exists():
   try:
    c=sqlite3.connect(dbpath); n=c.execute("SELECT count(*) FROM sqlite_master WHERE name='orchestration_v2_projection_threads_active_shell_idx'").fetchone()[0]; c.close()
    if n and 'pairing' in (out/'private-server.log').read_text().lower(): return
   except sqlite3.Error: pass
  time.sleep(.2)
 raise RuntimeError('Server startup timeout')
def stop():
 global proc
 if proc and proc.poll() is None:
  proc.terminate()
  try: proc.wait(timeout=15)
  except subprocess.TimeoutExpired: proc.kill();proc.wait()
 proc=None

def spans():
 if not trace.exists(): return []
 rows=[]
 for line in trace.read_text().splitlines():
  try: r=json.loads(line)
  except ValueError:continue
  if r.get('name')=='ProjectionStore.getLimitRecoveryCandidates': rows.append(r)
 return rows

def sweep(value):
 old=len(spans()); settings.write_text(json.dumps({'autoResumeLimitedThreads':True,'snoozeLimitedThreads':value,'enableProviderUpdateChecks':False,'autoSettleAfterDays':None,'autoSettleOnMerge':False}))
 deadline=time.monotonic()+25
 while time.monotonic()<deadline:
  rows=spans()
  if len(rows)>old:
   r=rows[-1]
   if r['exit']['_tag']!='Success': raise RuntimeError('Recovery query failed')
   return r['durationMs']
  time.sleep(.1)
 raise RuntimeError('No recovery span after settings toggle')

def seed():
 c=sqlite3.connect(dbpath); stamp='2026-01-01T00:00:00.000Z'; reset='2099-01-01T00:00:00.000Z'
 model={'instanceId':'codex','model':'gpt-5.4'}
 c.execute('BEGIN')
 for i in range(4000):
  tid=f'fixture-thread-{i:04}'; archived=stamp if i==3 else None
  t=dict(id=tid,projectId='fixture-project',title=f'Synthetic history {i}',createdBy='user',creationSource='web',providerInstanceId='codex',modelSelection=model,runtimeMode='full-access',interactionMode='default',branch=None,worktreePath=None,activeProviderThreadId=None,lineage=dict(parentThreadId=None,relationshipToParent=None,rootThreadId=tid),forkedFrom=None,autoSettleDisabledAt=stamp,createdAt=stamp,updatedAt=stamp,archivedAt=archived,settledOverride='settled' if i==4 else None,settledAt=None,lastVisitedAt=None,deletedAt=None)
  c.execute('INSERT INTO orchestration_v2_projection_threads(thread_id,project_id,title,default_provider,runtime_mode,interaction_mode,created_at,updated_at,archived_at,payload_json,provider_instance_id) VALUES(?,?,?,?,?,?,?,?,?,?,?)',(tid,'fixture-project',t['title'],'codex','full-access','default',stamp,stamp,archived,json.dumps(t),'codex'))
  for j in range(1,16):
   rid=f'{tid}-run-{j:02}'; nid=f'{rid}-root'; status='failed' if j>=6 else 'completed'
   if i==6 and j==15: status='completed'
   r=dict(id=rid,threadId=tid,ordinal=j,providerInstanceId='codex',modelSelection=model,providerThreadId=None,userMessageId=f'{rid}-message',rootNodeId=nid,activeAttemptId=None,status=status,requestedAt=stamp,startedAt=stamp,completedAt=stamp,checkpointId=None,contextHandoffId=None)
   c.execute('INSERT INTO orchestration_v2_projection_runs(run_id,thread_id,ordinal,provider,status,requested_at,completed_at,payload_json,provider_instance_id) VALUES(?,?,?,?,?,?,?,?,?)',(rid,tid,j,'codex',status,stamp,stamp,json.dumps(r),'codex'))
   for k in range(2):
    error=j>=6 and k==0; usage=error and ((i<392 and j==6) or (i<8 and j==15)); iid=f'{rid}-item-{k}'
    item=dict(id=iid,threadId=tid,runId=rid,nodeId=nid,providerThreadId=None,providerTurnId=None,nativeItemRef=None,parentItemId=None,ordinal=j*2+k,status='failed' if error else 'completed',title='Synthetic failure' if error else 'Synthetic note',startedAt=stamp,completedAt=stamp,updatedAt=stamp,type='error' if error else 'reasoning')
    if error: item['failure']=dict(class_='usage_limit' if usage else 'provider_error',message='Synthetic failure '+('x'*1536),code=None,retryable=None,resetAt='2025-12-31T00:00:00.000Z' if i==5 else reset); item['failure']['class']=item['failure'].pop('class_')
    else: item['text']='Synthetic note'
    if i==7 and j==15 and error: item['nodeId']=nid+'-child'
    c.execute('INSERT INTO orchestration_v2_projection_turn_items(turn_item_id,thread_id,run_id,node_id,ordinal,type,status,updated_at,payload_json) VALUES(?,?,?,?,?,?,?,?,?)',(iid,tid,rid,item['nodeId'],j*2+k,item['type'],item['status'],stamp,json.dumps(item)))
 c.commit(); c.execute('ANALYZE'); c.close()

try:
 start();stop();seed();settings.write_text(json.dumps({'autoResumeLimitedThreads':True,'snoozeLimitedThreads':False,'enableProviderUpdateChecks':False,'autoSettleAfterDays':None,'autoSettleOnMerge':False}));start()
 time.sleep(12)
 warmups=[sweep(bool((i+1)%2)) for i in range(5)]
 results=[]
 for batch in range(3):
  values=[sweep(bool((batch*samples+i+6)%2)) for i in range(samples)]
  results.append(dict(batch=batch+1,medianMs=statistics.median(values),minMs=min(values),maxMs=max(values),samplesMs=values))
  print(json.dumps({'commit':sha,'batch':results[-1]}),flush=True)
 stop()
 c=sqlite3.connect(dbpath)
 armed=[r[0] for r in c.execute("SELECT thread_id FROM orchestration_v2_projection_threads WHERE json_extract(payload_json,'$.limitRecovery.autoResume')=1 ORDER BY thread_id")]
 counts={name:c.execute('SELECT count(*) FROM orchestration_v2_projection_'+name).fetchone()[0] for name in ['threads','runs','turn_items']}
 report=dict(commit=sha,environment=dict(os=platform.system(),architecture=platform.machine(),cpu=next((line.split(':',1)[1].strip() for line in Path('/proc/cpuinfo').read_text().splitlines() if line.startswith('model name')), 'unknown'),node=subprocess.check_output(['node','--version'],text=True).strip(),pythonSqlite=sqlite3.sqlite_version,nodeSqlite=subprocess.check_output(['node','-p','process.versions.sqlite'],text=True).strip()),method='Real t3 serve; settings-file snooze toggles invalidate UsageLimitRecoveryWorker; durations from successful ProjectionStore.getLimitRecoveryCandidates server trace spans; 5 warmups, 3 batches. Identical synthetic fixture seeded offline after each server migrated its fresh database.',counts=counts,usageLimitRows=c.execute("SELECT count(*) FROM orchestration_v2_projection_turn_items WHERE CASE WHEN json_valid(payload_json) THEN json_extract(payload_json,'$.failure.class')='usage_limit' ELSE 0 END").fetchone()[0],warmupsMs=warmups,batches=results,armedThreadIds=armed,expectedArmedThreadIds=[f'fixture-thread-{i:04}' for i in range(3)],eligibilityPreserved=armed==[f'fixture-thread-{i:04}' for i in range(3)])
 (out/'recovery-spans.json').write_text(json.dumps([{k:r[k] for k in ['name','startTimeUnixNano','durationMs']} for r in spans()],indent=2))
 (out/'measurement.json').write_text(json.dumps(report,indent=2)); print(json.dumps(report,indent=2),flush=True)
finally:
 stop();log.close()
