#!/usr/bin/env bash
set -Eeuo pipefail

# Ornith P1 — Cache / Prefix Reuse Suite
# Pure llama.cpp benchmark: no OpenCode/tool noise.
# Restores production baseline on success or failure.

ROOT="$HOME/bench/ornith"
P1ROOT="$ROOT/p1"
IMAGE="lomelidev/llama.cpp:cu130-nccl-sse-faall-10974"
MODEL_DIR="$HOME/models/ornith15-9b"
MODEL_FILE="Ornith-1.5-9B-Q4_K_L.gguf"
PORT=8120
ALIAS="ornith-local"
SLOTS=3
CTX_SLOT=262144
CTX_TOTAL=786432
P1_NPREDICT=64
BASELINE_NPREDICT=4096
CACHE_RAM=32768
ROUNDS=3
TURNS=5
RUN=""
RESTORE_ON_EXIT=0
MON_PID=""
SELF="$(readlink -f "$0")"
mkdir -p "$P1ROOT"

die(){ echo; echo "ERROR: $*" >&2; exit 1; }
need(){ command -v "$1" >/dev/null 2>&1 || die "Falta comando: $1"; }
stamp(){ date -u +%Y%m%dT%H%M%SZ; }

preflight(){
  for c in docker curl jq python3 nvidia-smi tmux timeout ss sha256sum awk sed grep column; do need "$c"; done
  [[ -f "$MODEL_DIR/$MODEL_FILE" ]] || die "No existe $MODEL_DIR/$MODEL_FILE"
  docker image inspect "$IMAGE" >/dev/null 2>&1 || die "No existe imagen $IMAGE"
  tmux has-session -t llama 2>/dev/null || die "No existe tmux session 'llama'"
}

clean_clients(){
  echo "== Limpiando clientes que puedan contaminar :$PORT =="
  pkill -TERM -f 'opencode run.*local-ornith/ornith-local' 2>/dev/null || true
  pkill -TERM -f 'opencode\.exe serve --stdio --port 0' 2>/dev/null || true
  sleep 1
  mapfile -t PIDS < <(ss -tnp 2>/dev/null | grep ":$PORT" | grep -oE 'pid=[0-9]+' | cut -d= -f2 | sort -u || true)
  if ((${#PIDS[@]})); then
    echo "Cortando PIDs conectados a :$PORT: ${PIDS[*]}"
    kill -TERM "${PIDS[@]}" 2>/dev/null || true
    sleep 1
    for p in "${PIDS[@]}"; do kill -KILL "$p" 2>/dev/null || true; done
  fi
  ss -tnp 2>/dev/null | grep ":$PORT" || echo "Sin conexiones a :$PORT"
}

start_llama(){
  local cache_mode="$1" npredict="$2"
  docker rm -f ornith >/dev/null 2>&1 || true
  local a=(docker run -d --name ornith --gpus 'device=0' --ipc=host -p "$PORT:8080"
    -v "$MODEL_DIR:/models:ro" -e GGML_CUDA_GRAPH_OPT=1 "$IMAGE"
    -m "/models/$MODEL_FILE" -a "$ALIAS" -ngl 999 -fa on -ctk q4_0 -ctv q4_0
    -c "$CTX_TOTAL" -np "$SLOTS" --no-kv-unified --cont-batching --no-mmproj
    --n-predict "$npredict" -b 4096 -ub 2048 --cache-ram "$CACHE_RAM" --ctx-checkpoints 4
    --jinja --metrics --host 0.0.0.0 --port 8080 --temp 0 --top-p 1 --top-k 0 --min-p 0)
  [[ "$cache_mode" == on ]] && a+=(--cache-prompt)
  "${a[@]}" >/dev/null

  local ok=0
  for _ in $(seq 1 180); do
    if curl -fsS "http://127.0.0.1:$PORT/health" >/dev/null 2>&1; then ok=1; break; fi
    docker ps --format '{{.Names}}' | grep -qx ornith || break
    sleep 1
  done
  [[ "$ok" == 1 ]] || { docker logs ornith 2>&1 | tail -120 || true; die "llama no arrancó"; }
  local l; l="$(docker logs ornith 2>&1)"
  grep -Fq 'n_slots = 3, n_ctx_slot = 262144' <<<"$l" || die "No quedó 3x256K"
  grep -q 'no FlashAttention vector kernel' <<<"$l" && die "FA fallback detectado"
  grep -Eqi 'cudaMalloc failed|out of memory|capping' <<<"$l" && die "OOM/capping detectado"
  return 0
}

restore_baseline(){
  echo "== Restaurando baseline 3x256K Q4/Q4 FA cache-ON output=4096 =="
  start_llama on "$BASELINE_NPREDICT"
  docker inspect ornith --format '{{json .Args}}' > "$ROOT/baseline-last-args.json" 2>/dev/null || true
  curl -s "http://127.0.0.1:$PORT/slots" | jq -r '.[]|"slot=\(.id) ctx=\(.n_ctx) busy=\(.is_processing) max=\(.params.max_tokens)"'
}

make_corpus(){
python3 - "$RUN/corpus.txt" <<'PY'
from pathlib import Path
import hashlib, random, sys
p=Path(sys.argv[1]); random.seed(20260917)
sysn=["gateway","worker_pool","dedupe","session_router","queue","storage","scheduler","webhook"]
inv=["cancel_before_send","bounded_retry","single_writer","idempotent_insert","deadline_propagation","ownership_transfer","graceful_shutdown","backpressure"]
rows=[]
for i in range(1,501):
    s=sysn[(i*7)%len(sysn)]; v=inv[(i*11)%len(inv)]
    chk=hashlib.sha256(f"P1-{i:04d}-{s}-{v}".encode()).hexdigest()[:12].upper()
    rows.append(f"REF-{i:04d} subsystem={s} invariant={v} value={random.randint(100000,999999)} checksum={chk}")
p.write_text("\n".join(rows)+"\n")
PY
  { echo 'This is a deterministic prefix-cache benchmark.'; echo 'Memorize the reference table. Reply only with READY-P1.'; echo; cat "$RUN/corpus.txt"; } > "$RUN/turn-1.txt"
  echo 'Return only the complete REF-0037 line. No explanation.' > "$RUN/turn-2.txt"
  echo 'Return only the complete REF-0211 line. No explanation.' > "$RUN/turn-3.txt"
  echo 'Return only the checksum value from REF-0319. No explanation.' > "$RUN/turn-4.txt"
  echo 'Return only the complete REF-0144 line. No explanation.' > "$RUN/turn-5.txt"
}

write_helpers(){
cat > "$RUN/p1_request.py" <<'PY'
#!/usr/bin/env python3
import http.client, json, os, sys, threading, time, urllib.request
from pathlib import Path
reqp, ssep, metap, samplesp, slotp, port, reqslot = sys.argv[1:]
port=int(port); reqslot=int(reqslot)
body=Path(reqp).read_bytes(); stop=threading.Event(); lock=threading.Lock()
summary={"requested_slot":reqslot,"actual_slot":None,"task_id":None,"prompt_tokens":0,"processed_tokens":0,"cached_tokens":0,"decoded_tokens":0,"max_tokens":None}

def fetch():
    try:
        with urllib.request.urlopen(f"http://127.0.0.1:{port}/slots",timeout=.5) as r: return json.loads(r.read())
    except Exception: return []

def poll():
    target=None
    with open(samplesp,"w") as out:
        while not stop.is_set():
            slots=fetch(); active=[s for s in slots if s.get("is_processing")]
            if reqslot>=0:
                cand=[s for s in active if s.get("id")==reqslot]
            elif target is not None:
                cand=[s for s in active if s.get("id")==target]
            else:
                cand=active[:1]
            if cand:
                s=cand[0]; target=s.get("id")
                rec={"ts":time.time(),"id":s.get("id"),"id_task":s.get("id_task"),"prompt":s.get("n_prompt_tokens") or 0,"processed":s.get("n_prompt_tokens_processed") or 0,"cache":s.get("n_prompt_tokens_cache") or 0,"decoded":((s.get("next_token") or [{}])[0].get("n_decoded") or 0),"max_tokens":(s.get("params") or {}).get("max_tokens")}
                out.write(json.dumps(rec)+"\n"); out.flush()
                with lock:
                    summary["actual_slot"]=rec["id"]; summary["task_id"]=rec["id_task"]
                    summary["prompt_tokens"]=max(summary["prompt_tokens"],rec["prompt"])
                    summary["processed_tokens"]=max(summary["processed_tokens"],rec["processed"])
                    summary["cached_tokens"]=max(summary["cached_tokens"],rec["cache"])
                    summary["decoded_tokens"]=max(summary["decoded_tokens"],rec["decoded"])
                    summary["max_tokens"]=rec["max_tokens"]
            time.sleep(.02)

t=threading.Thread(target=poll,daemon=True); t.start()
conn=http.client.HTTPConnection("127.0.0.1",port,timeout=600)
t0=time.monotonic(); e0=time.time(); conn.request("POST","/completion",body=body,headers={"Content-Type":"application/json","Content-Length":str(len(body)),"Connection":"close"}); resp=conn.getresponse()
first=None; pieces=[]; finish=None; final=None
with open(ssep,"wb") as raw:
    while True:
        line=resp.readline()
        if not line: break
        raw.write(line); raw.flush(); st=line.strip()
        if not st.startswith(b"data:"): continue
        payload=st[5:].strip()
        if not payload or payload==b"[DONE]": continue
        try: obj=json.loads(payload)
        except Exception: continue
        final=obj; content=obj.get("content")
        if content:
            if first is None: first=time.monotonic()
            pieces.append(content)
        if obj.get("stop") is True: finish=obj.get("stop_type") or obj.get("stop_reason") or "stop"
e1=time.time(); t1=time.monotonic(); stop.set(); t.join(timeout=1); conn.close()
meta={"http_status":resp.status,"start_epoch":e0,"end_epoch":e1,"ttft_ms":None if first is None else (first-t0)*1000,"total_ms":(t1-t0)*1000,"text":"".join(pieces),"finish_reason":finish,"final_object":final}
Path(metap).write_text(json.dumps(meta,indent=2)+"\n")
Path(slotp).write_text(json.dumps(summary,indent=2)+"\n")
if not (200 <= resp.status < 300): sys.exit(2)
PY

cat > "$RUN/parse_log.py" <<'PY'
#!/usr/bin/env python3
import json,re,sys
from pathlib import Path
path,task,slot=sys.argv[1:]; task=int(task); slot=int(slot); lines=Path(path).read_text(errors="replace").splitlines()
r={"lcp":None,"f_keep":None,"prompt_tps":None,"gen_tps":None,"log_output_tokens":None}
launch=None
for i,line in enumerate(lines):
    if re.search(rf"launch_slot_:\s+id\s+{slot}\s+\|\s+task\s+{task}\s+\|",line): launch=i; break
if launch is not None:
    for j in range(launch-1,-1,-1):
        line=lines[j]
        if "get_availabl" not in line: continue
        ms=re.search(r"get_availabl:\s+id\s+(\d+)",line)
        if ms and int(ms.group(1))!=slot: continue
        m=re.search(r"f_sim_best\s*=\s*([0-9.]+)",line); r["lcp"]=float(m.group(1)) if m else None
        m=re.search(r"f_keep\s*=\s*([0-9.]+)",line); r["f_keep"]=float(m.group(1)) if m else None
        break
pat=re.compile(rf"\|\s+task\s+{task}\s+\|")
for line in lines:
    if not pat.search(line): continue
    if "prompt eval time" in line:
        m=re.search(r"([0-9.]+)\s+tokens per second",line)
        if m: r["prompt_tps"]=float(m.group(1))
    elif " eval time " in line and "prompt eval time" not in line:
        m=re.search(r"/\s*([0-9]+)\s+tokens.*?([0-9.]+)\s+tokens per second",line)
        if m: r["log_output_tokens"]=int(m.group(1)); r["gen_tps"]=float(m.group(2))
print(json.dumps(r))
PY
chmod +x "$RUN/p1_request.py" "$RUN/parse_log.py"
}

start_monitor(){
  (
    echo 'timestamp,mem_available_kib,load1,psi_cpu,psi_mem,psi_io,gpu_util,gpu_used_mib,gpu_free_mib,power_w,temp_c'
    while true; do
      ts="$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)"; mem="$(awk '/MemAvailable:/{print $2}' /proc/meminfo)"; load="$(awk '{print $1}' /proc/loadavg)"
      pc="$(awk '/some/{for(i=1;i<=NF;i++)if($i~/^avg10=/){split($i,a,"=");print a[2]}}' /proc/pressure/cpu)"
      pm="$(awk '/some/{for(i=1;i<=NF;i++)if($i~/^avg10=/){split($i,a,"=");print a[2]}}' /proc/pressure/memory)"
      pi="$(awk '/some/{for(i=1;i<=NF;i++)if($i~/^avg10=/){split($i,a,"=");print a[2]}}' /proc/pressure/io)"
      gpu="$(nvidia-smi -i 0 --query-gpu=utilization.gpu,memory.used,memory.free,power.draw,temperature.gpu --format=csv,noheader,nounits)"
      echo "$ts,$mem,$load,$pc,$pm,$pi,$gpu"; sleep 1
    done
  ) > "$RUN/system.csv" & MON_PID=$!; echo "$MON_PID" > "$RUN/monitor.pid"
}
stop_monitor(){ [[ -n "${MON_PID:-}" ]] && { kill "$MON_PID" 2>/dev/null || true; wait "$MON_PID" 2>/dev/null || true; MON_PID=""; }; }

build_request(){
  local prompt="$1" req="$2" slot="$3" cache="$4"
  python3 - "$prompt" "$req" "$slot" "$cache" "$P1_NPREDICT" <<'PY'
import json,sys
from pathlib import Path
prompt,req,slot,cache,n=sys.argv[1:]
o={"prompt":Path(prompt).read_text(),"stream":True,"n_predict":int(n),"cache_prompt":cache=="true","temperature":0.0,"seed":1}
slot=int(slot)
if slot>=0:o["id_slot"]=slot
Path(req).write_text(json.dumps(o)+"\n")
PY
}

update_progress(){
  local s="$1" r="$2" t="$3" sl="$4"
  python3 - "$RUN/progress.json" "$s" "$r" "$t" "$sl" <<'PY'
import json,os,sys,time
p,s,r,t,sl=sys.argv[1:]; o={"scenario":s,"round":int(r),"turn":int(t),"slot":int(sl),"updated":time.time()}; tmp=p+".tmp"; open(tmp,"w").write(json.dumps(o)); os.replace(tmp,p)
PY
}

run_turn(){
  local scenario="$1" round="$2" turn="$3" reqslot="$4" cache_req="$5" transcript="$6"
  local dir="$RUN/cases/$scenario/round-$(printf '%02d' "$round")"; mkdir -p "$dir"
  local prompt="$dir/turn-$(printf '%02d' "$turn").prompt.txt" req="$dir/turn-$(printf '%02d' "$turn").request.json"
  local sse="$dir/turn-$(printf '%02d' "$turn").response.sse" meta="$dir/turn-$(printf '%02d' "$turn").response.json"
  local samples="$dir/turn-$(printf '%02d' "$turn").slots.jsonl" slotsum="$dir/turn-$(printf '%02d' "$turn").slots-summary.json"
  local llog="$dir/turn-$(printf '%02d' "$turn").llama.log" parsed="$dir/turn-$(printf '%02d' "$turn").llama-parsed.json"

  { cat "$transcript"; echo; echo "### USER TURN $turn"; cat "$RUN/turn-$turn.txt"; echo; echo; echo "### ASSISTANT TURN $turn"; } > "$prompt"
  build_request "$prompt" "$req" "$reqslot" "$cache_req"

  local before; before="$(docker logs ornith 2>&1 | wc -l)"
  local rc=0
  python3 "$RUN/p1_request.py" "$req" "$sse" "$meta" "$samples" "$slotsum" "$PORT" "$reqslot" || rc=$?
  docker logs ornith 2>&1 | tail -n "+$((before+1))" > "$llog"
  [[ "$rc" == 0 ]] || { cat "$meta" 2>/dev/null || true; tail -100 "$llog" || true; die "$scenario r$round t$turn rc=$rc"; }

  local actual task promptn cached processed decoded
  actual="$(jq -r '.actual_slot // -1' "$slotsum")"; task="$(jq -r '.task_id // -1' "$slotsum")"
  promptn="$(jq -r '.prompt_tokens // 0' "$slotsum")"; cached="$(jq -r '.cached_tokens // 0' "$slotsum")"
  processed="$(jq -r '.processed_tokens // 0' "$slotsum")"; decoded="$(jq -r '.decoded_tokens // 0' "$slotsum")"
  [[ "$actual" != -1 && "$task" != -1 ]] || die "$scenario r$round t$turn: no detecté slot/task"
  [[ "$reqslot" -lt 0 || "$actual" == "$reqslot" ]] || die "$scenario r$round t$turn: pedí slot=$reqslot real=$actual"

  python3 "$RUN/parse_log.py" "$llog" "$task" "$actual" > "$parsed"
  local reuse; reuse="$(awk -v c="$cached" -v p="$promptn" 'BEGIN{if(p>0)printf "%.4f",100*c/p;else print "0.0000"}')"

  python3 - "$scenario" "$round" "$turn" "$reqslot" "$actual" "$task" "$slotsum" "$meta" "$parsed" "$reuse" "$cache_req" "$RUN/results.jsonl" "$RUN/summary.tsv" <<'PY'
import json,sys
s,r,t,rs,aslot,task,slotf,metaf,parsef,reuse,creq,jpath,tpath=sys.argv[1:]
sl=json.load(open(slotf)); me=json.load(open(metaf)); pa=json.load(open(parsef))
row={"scenario":s,"round":int(r),"turn":int(t),"requested_slot":int(rs),"actual_slot":int(aslot),"task":int(task),"prompt_tokens":sl.get("prompt_tokens",0),"processed_tokens":sl.get("processed_tokens",0),"cached_tokens":sl.get("cached_tokens",0),"reuse_pct":float(reuse),"ttft_ms":me.get("ttft_ms"),"total_ms":me.get("total_ms"),"decoded_tokens":sl.get("decoded_tokens",0),"max_tokens":sl.get("max_tokens"),"prompt_tps":pa.get("prompt_tps"),"gen_tps":pa.get("gen_tps"),"lcp":pa.get("lcp"),"f_keep":pa.get("f_keep"),"finish_reason":me.get("finish_reason"),"request_cache_prompt":creq=="true"}
open(jpath,"a").write(json.dumps(row)+"\n")
f=[row["scenario"],row["round"],row["turn"],row["requested_slot"],row["actual_slot"],row["task"],row["prompt_tokens"],row["processed_tokens"],row["cached_tokens"],f'{row["reuse_pct"]:.2f}',"" if row["ttft_ms"] is None else f'{row["ttft_ms"]:.2f}',f'{row["total_ms"]:.2f}',"" if row["prompt_tps"] is None else f'{row["prompt_tps"]:.2f}',"" if row["gen_tps"] is None else f'{row["gen_tps"]:.2f}',row["decoded_tokens"],"" if row["lcp"] is None else f'{row["lcp"]:.4f}',"" if row["f_keep"] is None else f'{row["f_keep"]:.4f}',"on" if row["request_cache_prompt"] else "off"]
open(tpath,"a").write("\t".join(map(str,f))+"\n")
PY

  { cat "$transcript"; echo; echo "### USER TURN $turn"; cat "$RUN/turn-$turn.txt"; echo; echo; echo "### ASSISTANT TURN $turn"; jq -r '.text // ""' "$meta"; echo; } > "$transcript.next"
  mv "$transcript.next" "$transcript"
  update_progress "$scenario" "$round" "$turn" "$actual"
  printf '  %-24s r=%s t=%s slot=%s prompt=%s cached=%s reuse=%s%% TTFT=%sms\n' "$scenario" "$round" "$turn" "$actual" "$promptn" "$cached" "$reuse" "$(jq -r '.ttft_ms // 0' "$meta")"
}

run_scenario(){
  local scenario="$1" server_cache="$2" request_cache="$3" mode="$4"
  echo; echo '============================================================================'; echo "$scenario server_cache=$server_cache request_cache=$request_cache mode=$mode"; echo '============================================================================'
  for round in $(seq 1 "$ROUNDS"); do
    echo "-- round $round/$ROUNDS --"
    local dir="$RUN/cases/$scenario/round-$(printf '%02d' "$round")"
    local transcript="$dir/transcript.txt"
    mkdir -p "$dir"
    : > "$transcript"
    local first_slot=-1 prev=-1
    [[ "$mode" == cold ]] || start_llama "$server_cache" "$P1_NPREDICT"
    for turn in $(seq 1 "$TURNS"); do
      local req=-1
      if [[ "$mode" == cold ]]; then
        start_llama off "$P1_NPREDICT"; req=-1
      elif [[ "$mode" == same ]]; then
        # A/on: let LCP choose naturally so logs expose f_sim/f_keep.
        # C/off: force after turn 1 so it remains a true same-slot control.
        if [[ "$server_cache" == off && "$turn" -gt 1 ]]; then req="$first_slot"; else req=-1; fi
      elif [[ "$mode" == rotate ]]; then
        [[ "$turn" -eq 1 ]] && req=-1 || req=$(((prev+1)%3))
      fi
      run_turn "$scenario" "$round" "$turn" "$req" "$request_cache" "$transcript"
      local actual; actual="$(tail -n 1 "$RUN/results.jsonl" | jq -r '.actual_slot')"
      [[ "$turn" -eq 1 ]] && first_slot="$actual"
      if [[ "$mode" == same && "$turn" -gt 1 && "$actual" != "$first_slot" ]]; then die "$scenario r$round t$turn rotó inesperadamente $first_slot->$actual"; fi
      if [[ "$mode" == rotate && "$turn" -gt 1 && "$actual" == "$prev" ]]; then die "$scenario r$round t$turn no rotó"; fi
      prev="$actual"
    done
  done
}

validate_forced_slot(){
  echo '== Validando id_slot en /completion =='; start_llama on "$P1_NPREDICT"
  local d="$RUN/preflight"; mkdir -p "$d"; echo 'Count from 1 to 100.' > "$d/prompt.txt"; build_request "$d/prompt.txt" "$d/request.json" 2 true
  python3 "$RUN/p1_request.py" "$d/request.json" "$d/response.sse" "$d/response.json" "$d/slots.jsonl" "$d/slots-summary.json" "$PORT" 2
  local a; a="$(jq -r '.actual_slot // -1' "$d/slots-summary.json")"; [[ "$a" == 2 ]] || die "id_slot no funcionó: pedí 2 real=$a"; echo 'id_slot OK'
}

make_report(){
python3 - "$RUN" <<'PY'
from pathlib import Path
import json,statistics,sys
run=Path(sys.argv[1]); rows=[json.loads(x) for x in (run/'results.jsonl').read_text().splitlines() if x.strip()]
def med(xs):
    xs=[x for x in xs if isinstance(x,(int,float))]; return statistics.median(xs) if xs else None
def pct(xs,q):
    xs=sorted(x for x in xs if isinstance(x,(int,float)))
    if not xs:return None
    if len(xs)==1:return xs[0]
    pos=(len(xs)-1)*q; lo=int(pos); hi=min(lo+1,len(xs)-1); f=pos-lo
    return xs[lo]*(1-f)+xs[hi]*f
scenarios=sorted({r['scenario'] for r in rows}); summary={}
for s in scenarios:
    allr=[r for r in rows if r['scenario']==s]; rs=[r for r in allr if r['turn']>1]
    def vals(k): return [r.get(k) for r in rs if isinstance(r.get(k),(int,float))]
    tt=vals('ttft_ms')
    summary[s]={"samples_all":len(allr),"steady_samples":len(rs),"median_ttft_ms":med(tt),"p10_ttft_ms":pct(tt,.1),"p90_ttft_ms":pct(tt,.9),"median_reuse_pct":med(vals('reuse_pct')),"median_processed_tokens":med(vals('processed_tokens')),"median_cached_tokens":med(vals('cached_tokens')),"median_prompt_tps":med(vals('prompt_tps')),"median_gen_tps":med(vals('gen_tps')),"median_lcp":med(vals('lcp')),"median_f_keep":med(vals('f_keep'))}
(run/'summary.json').write_text(json.dumps(summary,indent=2)+'\n')
def f(v,n=2): return '-' if v is None else f'{v:.{n}f}'
md=['# Ornith P1 — Cache / Prefix Reuse','',f'Run: `{run}`','', 'Steady-state statistics use turns 2–5. Turn 1 is the cold priming turn.','', '| Scenario | n | TTFT med ms | p10 | p90 | reuse med % | processed med | cached med | prompt t/s | gen t/s | LCP | f_keep |','|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|---:|']
for s in scenarios:
    x=summary[s]; md.append(f"| {s} | {x['steady_samples']} | {f(x['median_ttft_ms'])} | {f(x['p10_ttft_ms'])} | {f(x['p90_ttft_ms'])} | {f(x['median_reuse_pct'])} | {f(x['median_processed_tokens'],0)} | {f(x['median_cached_tokens'],0)} | {f(x['median_prompt_tps'])} | {f(x['median_gen_tps'])} | {f(x['median_lcp'],3)} | {f(x['median_f_keep'],3)} |")
md+=['','## Derived comparisons','']
h=summary.get('P1-A-cache-on-same',{}); r=summary.get('P1-B-cache-on-rotate',{}); o=summary.get('P1-C-cache-off-same',{}); c=summary.get('P1-E-cold',{})
if h.get('median_ttft_ms') and c.get('median_ttft_ms'): md.append(f"- Cold/hot median TTFT ratio: **{c['median_ttft_ms']/h['median_ttft_ms']:.2f}×**.")
if h.get('median_reuse_pct') is not None and r.get('median_reuse_pct') is not None: md.append(f"- Median reuse same-slot: **{h['median_reuse_pct']:.2f}%**; rotated: **{r['median_reuse_pct']:.2f}%**.")
if o.get('median_reuse_pct') is not None:
    if o['median_reuse_pct']>10: md.append(f"- Cache-OFF still reused **{o['median_reuse_pct']:.2f}%** median; `--cache-prompt` alone does not eliminate all slot/LCP reuse in this build.")
    else: md.append(f"- Cache-OFF reuse fell to **{o['median_reuse_pct']:.2f}%** median.")
md+=['','## Baseline restored','', '- 3 × 256K','- KV Q4/Q4','- FlashAttention ON (all-quants build)','- DFlash OFF','- vision OFF','- continuous batching ON','- cache-prompt ON','- hard output 4096','']
report='\n'.join(md)+'\n'; (run/'report.md').write_text(report); print(report)
PY
}

make_manifest(){
  local iid sha; iid="$(docker image inspect "$IMAGE" --format '{{.Id}}')"; sha="$(sha256sum "$MODEL_DIR/$MODEL_FILE"|awk '{print $1}')"
  cat > "$RUN/manifest.json" <<EOF2
{
  "created_utc":"$(date -u +%Y-%m-%dT%H:%M:%SZ)",
  "suite":"Ornith P1 cache/prefix reuse",
  "image":"$IMAGE",
  "image_id":"$iid",
  "model_file":"$MODEL_FILE",
  "model_sha256":"$sha",
  "slots":$SLOTS,
  "ctx_per_slot":$CTX_SLOT,
  "ctx_total":$CTX_TOTAL,
  "kv_k":"q4_0",
  "kv_v":"q4_0",
  "flash_attention":true,
  "dflash":false,
  "vision":false,
  "cache_ram_mb":$CACHE_RAM,
  "p1_n_predict":$P1_NPREDICT,
  "baseline_n_predict":$BASELINE_NPREDICT,
  "rounds":$ROUNDS,
  "turns_per_round":$TURNS
}
EOF2
}

dashboard(){
  [[ -f "$ROOT/LAST_P1" ]] || { echo 'No hay LAST_P1 todavía'; return; }
  local d; d="$(cat "$ROOT/LAST_P1")"; clear
  echo 'ORNITH P1 — CACHE / PREFIX REUSE'; echo '============================================================================'; echo "$d"; echo
  [[ -f "$d/progress.json" ]] && jq -r '"Current : \(.scenario)\nRound   : \(.round)\nTurn    : \(.turn)\nSlot    : \(.slot)"' "$d/progress.json" || echo 'Esperando primer sample...'
  echo; echo 'ÚLTIMOS RESULTADOS'; echo '============================================================================'
  [[ -s "$d/summary.tsv" ]] && tail -n 12 "$d/summary.tsv" | column -t -s $'\t'
  echo; echo 'GPU0'; echo '============================================================================'
  nvidia-smi -i 0 --query-gpu=utilization.gpu,memory.used,memory.free,power.draw,temperature.gpu --format=csv,noheader
}

slots_view(){
  curl -s "http://127.0.0.1:$PORT/slots" | jq -r '.[]|"SLOT \(.id) task=\(.id_task) busy=\(.is_processing)\nctx=\(.n_ctx)\nprompt=\(.n_prompt_tokens)\nprocessed=\(.n_prompt_tokens_processed)\ncache=\(.n_prompt_tokens_cache)\ndecoded=\(.next_token[0].n_decoded // 0)\nmax_tokens=\(.params.max_tokens)\n---------------------------------------------"'
}

setup_tmux(){
  for w in Log Check Test Monitor OpenCode; do tmux list-windows -t llama -F '#{window_name}' | grep -qx "$w" || tmux new-window -d -t llama -n "$w"; done
  tmux send-keys -t llama:Log C-c; tmux send-keys -t llama:Log 'while true; do clear; docker logs -f ornith 2>&1; sleep 1; done' C-m
  tmux send-keys -t llama:Check C-c; tmux send-keys -t llama:Check "watch -n 1 '$SELF dashboard'" C-m
  tmux send-keys -t llama:OpenCode C-c; tmux send-keys -t llama:OpenCode "watch -n 1 '$SELF slots'" C-m
}

cleanup_runtime(){ stop_monitor || true; }
on_exit(){ local rc=$?; trap - EXIT INT TERM; cleanup_runtime || true; [[ "$RESTORE_ON_EXIT" == 1 ]] && restore_baseline || true; exit "$rc"; }

run_all(){
  preflight; clean_clients
  RUN="$P1ROOT/p1-cache-$(stamp)"; mkdir -p "$RUN"/{cases,preflight}; echo "$RUN" > "$ROOT/LAST_P1"
  printf 'scenario\tround\tturn\trequested_slot\tactual_slot\ttask\tprompt\tprocessed\tcached\treuse_pct\tttft_ms\ttotal_ms\tprompt_tps\tgen_tps\tdecoded\tlcp\tf_keep\tcache_req\n' > "$RUN/summary.tsv"
  : > "$RUN/results.jsonl"
  make_manifest; make_corpus; write_helpers; setup_tmux; start_monitor
  RESTORE_ON_EXIT=1; trap on_exit EXIT INT TERM
  validate_forced_slot
  update_progress 'P1-A-cache-on-same' 0 0 -1
  run_scenario 'P1-A-cache-on-same' on true same
  run_scenario 'P1-B-cache-on-rotate' on true rotate
  run_scenario 'P1-C-cache-off-same' off false same
  run_scenario 'P1-D-cache-off-rotate' off false rotate
  run_scenario 'P1-E-cold' off false cold
  update_progress ANALYSIS "$ROUNDS" "$TURNS" -1
  make_report | tee "$RUN/report-console.txt"
  docker logs ornith > "$RUN/llama-last.log" 2>&1 || true
  RESTORE_ON_EXIT=0; cleanup_runtime; restore_baseline
  echo; echo '============================================================================'; echo 'P1 TERMINADA — BASELINE RESTAURADO'; echo '============================================================================'
  echo "Run: $RUN"; echo "TSV: $RUN/summary.tsv"; echo "JSON: $RUN/summary.json"; echo "Reporte: $RUN/report.md"
}

results_view(){
  [[ -f "$ROOT/LAST_P1" ]] || die "No existe $ROOT/LAST_P1"; local d; d="$(cat "$ROOT/LAST_P1")"; echo "$d"; echo
  [[ -f "$d/report.md" ]] && cat "$d/report.md" || { echo 'P1 aún no termina'; tail -n 20 "$d/summary.tsv" | column -t -s $'\t'; }
}

case "${1:-run}" in
  run) run_all;;
  dashboard) dashboard;;
  slots) slots_view;;
  watch) watch -n 1 "$SELF slots";;
  results) results_view;;
  restore) restore_baseline;;
  *) echo "Uso: $SELF {run|dashboard|slots|watch|results|restore}"; exit 1;;
esac
