Probe Gradio startup

app.py

@@ -1,1428 +1,17 @@
 import os
 
-os.environ.setdefault("HF_HOME", "/tmp/.cache/huggingface")
-os.environ.setdefault("HF_MODULES_CACHE", "/tmp/hf_modules")
-os.environ.setdefault("MPLCONFIGDIR", "/tmp/matplotlib")
 os.environ.setdefault("GRADIO_ANALYTICS_ENABLED", "False")
 os.environ.setdefault("GRADIO_SSR_MODE", "false")
-if not os.environ.get("HF_TOKEN"):
-    for _token_key in ("HUGGING_FACE_HUB_TOKEN", "HUGGINGFACE_HUB_TOKEN"):
-        if os.environ.get(_token_key):
-            os.environ["HF_TOKEN"] = os.environ[_token_key]
-            break
 
-print("codex-traces startup: env configured", flush=True)
-
-import html
-import json
-import math
-import re
-from datetime import datetime, timezone
-from functools import lru_cache
-from pathlib import Path
-from typing import Any
+print("probe startup: before gradio import", flush=True)
 
 import gradio as gr
-from huggingface_hub import hf_hub_download, list_repo_files
-
-print("codex-traces startup: imports complete", flush=True)
-
-
-APP_TITLE = "Codex Traces"
-APP_REVISION = "parser-v2"
-DATASET_REPO = "Mike0021/codex-sessions"
-REPO_TYPE = "dataset"
-FILE_SUFFIX = "_rollout.jsonl"
-SESSION_PATH_PREFIX = "sessions/rollout-"
-SESSION_PATH_SUFFIX = ".jsonl"
-PAGE_SIZE = 120
-MAX_OUTPUT_CHARS = 22000
-MAX_MESSAGE_CHARS = 30000
-KNOWN_SESSIONS = (
-    "agents-a1-demo",
-    "ai-agent-soccer",
-    "anime-soccer-generator",
-    "asasr-space",
-    "codex-traces-viewer",
-    "craft-agents-oss",
-    "deepspec-space",
-    "edit-anything",
-    "fractal-pi-extension",
-    "gaussian-splat-demo",
-    "hf-history-article",
-    "hf-motion-video",
-    "horus-hiero-space",
-    "locate-anything-space",
-    "ltx-3dreal-space",
-    "microworld-space",
-    "olmoearth-demo",
-    "paris-13-landing",
-    "pulpie-demo",
-    "pulpie-gguf",
-    "pulpie-mlx",
-    "pulpie-onnx",
-    "pulpie-web-demo",
-    "qwen3-asr-space",
-    "rampart-demo",
-    "sync-lora-space",
-    "tabfm-arena",
-)
-
-ANSI_RE = re.compile(r"\x1b\[[0-9;?]*[ -/]*[@-~]")
-TIMESTAMP_KEYS = (
-    "timestamp",
-    "time",
-    "created_at",
-    "updated_at",
-    "started_at",
-    "completed_at",
-)
-
-
-def _hub_token() -> str | None:
-    return (
-        os.environ.get("HF_TOKEN")
-        or os.environ.get("HUGGING_FACE_HUB_TOKEN")
-        or os.environ.get("HUGGINGFACE_HUB_TOKEN")
-        or None
-    )
-
-
-def _display_name(file_name: str) -> str:
-    if file_name.startswith(SESSION_PATH_PREFIX) and file_name.endswith(SESSION_PATH_SUFFIX):
-        return file_name[len(SESSION_PATH_PREFIX) : -len(SESSION_PATH_SUFFIX)]
-    return file_name[: -len(FILE_SUFFIX)] if file_name.endswith(FILE_SUFFIX) else file_name
-
-
-def _is_rollout_file(file_name: str) -> bool:
-    return (
-        file_name.startswith(SESSION_PATH_PREFIX)
-        and file_name.endswith(SESSION_PATH_SUFFIX)
-    ) or file_name.endswith(FILE_SUFFIX)
-
-
-def _file_candidates(session_name: str | None) -> list[str]:
-    if not session_name:
-        return []
-    name = str(session_name).strip()
-    if name.endswith(".jsonl"):
-        return [name]
-
-    candidates = [
-        f"{SESSION_PATH_PREFIX}{name}{SESSION_PATH_SUFFIX}",
-        f"{name}{FILE_SUFFIX}",
-    ]
-    return list(dict.fromkeys(candidates))
-
-
-def _fmt_number(value: int | None) -> str:
-    return f"{int(value or 0):,}"
-
-
-def _fmt_bytes(value: int | None) -> str:
-    value = int(value or 0)
-    units = ("B", "KB", "MB", "GB")
-    size = float(value)
-    for unit in units:
-        if size < 1024 or unit == units[-1]:
-            return f"{size:.1f} {unit}" if unit != "B" else f"{value} B"
-        size /= 1024
-    return f"{value} B"
-
-
-def _strip_ansi(text: Any) -> str:
-    return ANSI_RE.sub("", str(text or ""))
-
-
-def _escape(text: Any) -> str:
-    return html.escape(str(text or ""), quote=True)
-
-
-def _limit_text(text: str, limit: int, label: str) -> tuple[str, str]:
-    if len(text) <= limit:
-        return text, ""
-    hidden = len(text) - limit
-    note = f"\n\n[{label} truncated by {hidden:,} characters for browser responsiveness.]"
-    return text[:limit] + note, f" truncated {hidden:,} chars"
-
-
-def _parse_time(value: Any) -> datetime | None:
-    if value is None:
-        return None
-    if isinstance(value, (int, float)):
-        seconds = float(value) / 1000 if value > 10_000_000_000 else float(value)
-        try:
-            return datetime.fromtimestamp(seconds, tz=timezone.utc)
-        except (OSError, OverflowError, ValueError):
-            return None
-    if isinstance(value, str):
-        raw = value.strip()
-        if not raw:
-            return None
-        try:
-            if raw.endswith("Z"):
-                raw = raw[:-1] + "+00:00"
-            parsed = datetime.fromisoformat(raw)
-            return parsed if parsed.tzinfo else parsed.replace(tzinfo=timezone.utc)
-        except ValueError:
-            return None
-    return None
-
-
-def _duration_label(timestamps: list[datetime]) -> str:
-    if len(timestamps) < 2:
-        return "not recorded"
-    delta = max(timestamps) - min(timestamps)
-    seconds = max(0, int(delta.total_seconds()))
-    if seconds < 60:
-        return f"{seconds}s"
-    minutes, sec = divmod(seconds, 60)
-    if minutes < 60:
-        return f"{minutes}m {sec}s"
-    hours, minutes = divmod(minutes, 60)
-    return f"{hours}h {minutes}m"
-
-
-@lru_cache(maxsize=1)
-def _list_sessions_cached() -> tuple[tuple[str, ...], str]:
-    try:
-        files = list_repo_files(DATASET_REPO, repo_type=REPO_TYPE, token=_hub_token())
-    except Exception as exc:
-        return (), f"{type(exc).__name__}: {exc}"
-    sessions = tuple(sorted({_display_name(f) for f in files if _is_rollout_file(f)}))
-    if not sessions:
-        return (), "No *_rollout.jsonl files were found in the dataset."
-    return sessions, ""
-
-
-def _session_choices(live: bool = True) -> list[str]:
-    if not live:
-        return list(KNOWN_SESSIONS)
-    sessions, _ = _list_sessions_cached()
-    return list(sessions or KNOWN_SESSIONS)
-
-
-def _default_session() -> str | None:
-    choices = _session_choices(live=False)
-    return choices[0] if choices else None
-
-
-def _download_session(file_name: str) -> Path:
-    return Path(
-        hf_hub_download(
-            repo_id=DATASET_REPO,
-            filename=file_name,
-            repo_type=REPO_TYPE,
-            token=_hub_token(),
-        )
-    )
-
-
-def _command_status(item: dict[str, Any]) -> tuple[str, str]:
-    status = str(item.get("status") or "").lower()
-    exit_code = item.get("exit_code")
-    if status in {"failed", "error"} or (exit_code not in (None, 0)):
-        return "failed", "fail"
-    if status in {"completed", "succeeded", "success"}:
-        return "success", "success"
-    if status in {"in_progress", "running"}:
-        return "running", "running"
-    return status or "unknown", "neutral"
-
-
-def _usage_total(usage: dict[str, Any]) -> int:
-    return int(usage.get("input_tokens") or 0) + int(usage.get("output_tokens") or 0)
-
-
-def _collect_timestamps(obj: dict[str, Any], timestamps: list[datetime]) -> None:
-    for key in TIMESTAMP_KEYS:
-        parsed = _parse_time(obj.get(key))
-        if parsed:
-            timestamps.append(parsed)
-    item = obj.get("item")
-    if isinstance(item, dict):
-        for key in TIMESTAMP_KEYS:
-            parsed = _parse_time(item.get(key))
-            if parsed:
-                timestamps.append(parsed)
-
-
-def _payload_command(payload: dict[str, Any]) -> str:
-    name = str(payload.get("name") or "function_call")
-    arguments = payload.get("arguments")
-    if isinstance(arguments, dict):
-        command = arguments.get("command")
-        if command:
-            return str(command)
-        return f"{name}({json.dumps(arguments, ensure_ascii=True)})"
-    if arguments:
-        return f"{name}({arguments})"
-    return name
-
-
-@lru_cache(maxsize=6)
-def _load_session(file_name: str) -> dict[str, Any]:
-    path = _download_session(file_name)
-    events: list[dict[str, Any]] = []
-    timestamps: list[datetime] = []
-    pending_commands: list[str] = []
-    command_ids: set[str] = set()
-    failed_commands = 0
-    turn_completed = 0
-    turn_started = 0
-    parse_errors = 0
-    usage_summary = {
-        "input_tokens": 0,
-        "cached_input_tokens": 0,
-        "output_tokens": 0,
-        "reasoning_output_tokens": 0,
-    }
-
-    with path.open("r", encoding="utf-8", errors="replace") as handle:
-        for line_no, raw_line in enumerate(handle, start=1):
-            line = raw_line.strip()
-            if not line.startswith("{"):
-                parse_errors += 1
-                continue
-            try:
-                obj = json.loads(line)
-            except json.JSONDecodeError:
-                parse_errors += 1
-                continue
-
-            obj_type = obj.get("type")
-            payload = obj.get("payload") if isinstance(obj.get("payload"), dict) else {}
-            payload_type = payload.get("type")
-            item = obj.get("item") if isinstance(obj.get("item"), dict) else {}
-            item_type = item.get("type")
-            _collect_timestamps(obj, timestamps)
-
-            if obj_type == "turn_context":
-                turn_started += 1
-                continue
-
-            if obj_type == "event_msg":
-                if payload_type in {"agent_message", "user_message"}:
-                    text = str(payload.get("message") or "")
-                    is_user = payload_type == "user_message"
-                    events.append(
-                        {
-                            "kind": "user" if is_user else "agent",
-                            "role": "USER" if is_user else "AGENT",
-                            "line": line_no,
-                            "id": f"line-{line_no}",
-                            "text": text,
-                            "search": text,
-                        }
-                    )
-                    continue
-
-                if payload_type == "token_count":
-                    turn_completed += 1
-                    usage = {key: int(payload.get(key) or 0) for key in usage_summary}
-                    for key, value in usage.items():
-                        usage_summary[key] += value
-                    events.append(
-                        {
-                            "kind": "usage",
-                            "line": line_no,
-                            "usage": usage,
-                            "search": " ".join(
-                                [
-                                    "turn completed usage tokens",
-                                    " ".join(f"{k} {v}" for k, v in usage.items()),
-                                ]
-                            ),
-                        }
-                    )
-                    continue
-
-                if payload_type == "item_completed" and payload.get("item_type") == "todo_list":
-                    todos = payload.get("todos") or payload.get("items") or []
-                    if isinstance(todos, list):
-                        text = " ".join(str(todo.get("text") or "") for todo in todos if isinstance(todo, dict))
-                        events.append(
-                            {
-                                "kind": "todo",
-                                "line": line_no,
-                                "id": f"line-{line_no}",
-                                "items": todos,
-                                "search": text,
-                            }
-                        )
-                    continue
-
-                if payload_type == "patch_apply_end":
-                    path_value = str(payload.get("path") or "patch")
-                    events.append(
-                        {
-                            "kind": "files",
-                            "line": line_no,
-                            "id": f"line-{line_no}",
-                            "changes": [{"kind": "patch", "path": path_value}],
-                            "status": payload.get("status") or "",
-                            "search": f"patch {path_value} {payload.get('status') or ''}",
-                        }
-                    )
-                    continue
-
-            if obj_type == "response_item":
-                if payload_type == "function_call":
-                    pending_commands.append(_payload_command(payload))
-                    continue
-
-                if payload_type == "function_call_output":
-                    command = pending_commands.pop(0) if pending_commands else "function_call_output"
-                    output = _strip_ansi(payload.get("output") or "")
-                    exit_code = payload.get("exit_code")
-                    status = "failed" if exit_code not in (None, 0) else "completed"
-                    label, status_class = _command_status({"status": status, "exit_code": exit_code})
-                    if status_class == "fail":
-                        failed_commands += 1
-                    item_id = f"line-{line_no}"
-                    command_ids.add(item_id)
-                    events.append(
-                        {
-                            "kind": "command",
-                            "line": line_no,
-                            "id": item_id,
-                            "command": command,
-                            "output": output,
-                            "exit_code": exit_code,
-                            "status": label,
-                            "status_class": status_class,
-                            "search": " ".join([command, output, str(exit_code), label]),
-                        }
-                    )
-                    continue
-
-            if obj_type == "turn.started":
-                turn_started += 1
-                continue
-
-            if obj_type == "turn.completed":
-                turn_completed += 1
-                usage = obj.get("usage") or {}
-                if isinstance(usage, dict):
-                    for key in usage_summary:
-                        usage_summary[key] += int(usage.get(key) or 0)
-                    events.append(
-                        {
-                            "kind": "usage",
-                            "line": line_no,
-                            "usage": usage,
-                            "search": " ".join(
-                                [
-                                    "turn completed usage tokens",
-                                    " ".join(f"{k} {v}" for k, v in usage.items()),
-                                ]
-                            ),
-                        }
-                    )
-                continue
-
-            if obj_type not in {"item.completed", "item.updated"}:
-                continue
-
-            if item_type == "agent_message":
-                text = str(item.get("text") or "")
-                events.append(
-                    {
-                        "kind": "agent",
-                        "line": line_no,
-                        "id": item.get("id") or f"line-{line_no}",
-                        "text": text,
-                        "search": text,
-                    }
-                )
-                continue
-
-            if item_type == "command_execution":
-                item_id = str(item.get("id") or f"line-{line_no}")
-                if item_id not in command_ids:
-                    command_ids.add(item_id)
-                label, status_class = _command_status(item)
-                if status_class == "fail":
-                    failed_commands += 1
-                command = str(item.get("command") or "")
-                output = _strip_ansi(item.get("aggregated_output") or "")
-                exit_code = item.get("exit_code")
-                events.append(
-                    {
-                        "kind": "command",
-                        "line": line_no,
-                        "id": item_id,
-                        "command": command,
-                        "output": output,
-                        "exit_code": exit_code,
-                        "status": label,
-                        "status_class": status_class,
-                        "search": " ".join([command, output, str(exit_code), label]),
-                    }
-                )
-                continue
-
-            if item_type == "todo_list":
-                todos = item.get("items") or []
-                if isinstance(todos, list):
-                    text = " ".join(str(todo.get("text") or "") for todo in todos if isinstance(todo, dict))
-                    events.append(
-                        {
-                            "kind": "todo",
-                            "line": line_no,
-                            "id": item.get("id") or f"line-{line_no}",
-                            "items": todos,
-                            "search": text,
-                        }
-                    )
-                continue
-
-            if item_type == "file_change":
-                changes = item.get("changes") or []
-                if isinstance(changes, list):
-                    text = " ".join(
-                        f"{change.get('kind', '')} {change.get('path', '')}"
-                        for change in changes
-                        if isinstance(change, dict)
-                    )
-                    events.append(
-                        {
-                            "kind": "files",
-                            "line": line_no,
-                            "id": item.get("id") or f"line-{line_no}",
-                            "changes": changes,
-                            "status": item.get("status") or "",
-                            "search": text,
-                        }
-                    )
-
-    total_turns = turn_completed or turn_started
-    return {
-        "file_name": file_name,
-        "path": str(path),
-        "bytes": path.stat().st_size,
-        "events": events,
-        "summary": {
-            "turns": total_turns,
-            "commands": len(command_ids),
-            "failed_commands": failed_commands,
-            "duration": _duration_label(timestamps),
-            "parse_errors": parse_errors,
-            **usage_summary,
-            "total_tokens": usage_summary["input_tokens"] + usage_summary["output_tokens"],
-        },
-    }
-
-
-def _filter_events(events: list[dict[str, Any]], query: str | None) -> list[dict[str, Any]]:
-    needle = (query or "").strip().lower()
-    if not needle:
-        return events
-    terms = [part for part in needle.split() if part]
-    return [
-        event
-        for event in events
-        if all(term in str(event.get("search", "")).lower() for term in terms)
-    ]
-
-
-def _metric(label: str, value: str, tone: str = "") -> str:
-    return (
-        f'<div class="metric {tone}">'
-        f'<span class="metric-label">{_escape(label)}</span>'
-        f'<span class="metric-value">{_escape(value)}</span>'
-        "</div>"
-    )
-
-
-def _render_summary(data: dict[str, Any], matches: int, query: str) -> str:
-    summary = data["summary"]
-    file_label = _display_name(data["file_name"])
-    query_label = f"Filtered: {matches:,} matches" if query.strip() else f"{matches:,} visible events"
-    failed = int(summary["failed_commands"])
-    return (
-        '<section class="summary-panel">'
-        '<div class="summary-topline">'
-        f'<div><h1>{_escape(file_label)}</h1>'
-        f'<p>{_escape(data["file_name"])} · {_fmt_bytes(data["bytes"])} · {query_label}</p></div>'
-        f'<div class="repo-pill">private dataset · {_escape(APP_REVISION)}</div>'
-        "</div>"
-        '<div class="metrics-grid">'
-        f'{_metric("Turns", _fmt_number(summary["turns"]))}'
-        f'{_metric("Total tokens", _fmt_number(summary["total_tokens"]))}'
-        f'{_metric("Input", _fmt_number(summary["input_tokens"]))}'
-        f'{_metric("Output", _fmt_number(summary["output_tokens"]))}'
-        f'{_metric("Reasoning", _fmt_number(summary["reasoning_output_tokens"]))}'
-        f'{_metric("Duration", str(summary["duration"]))}'
-        f'{_metric("Commands", _fmt_number(summary["commands"]))}'
-        f'{_metric("Failed", _fmt_number(failed), "danger" if failed else "ok")}'
-        "</div>"
-        "</section>"
-    )
-
-
-def _render_agent(event: dict[str, Any]) -> str:
-    text, note = _limit_text(str(event.get("text") or ""), MAX_MESSAGE_CHARS, "message")
-    role = str(event.get("role") or "AGENT").upper()
-    role_class = "user" if role == "USER" else "agent"
-    return (
-        f'<article class="event {role_class}-event">'
-        f'<div class="event-rail {role_class}-rail">{_escape(role)}</div>'
-        f'<div class="bubble {role_class}-bubble">'
-        f'<div class="event-meta">line {_fmt_number(event["line"])}{_escape(note)}</div>'
-        f'<div class="message-text">{_escape(text)}</div>'
-        "</div>"
-        "</article>"
-    )
-
-
-def _render_command(event: dict[str, Any]) -> str:
-    output = str(event.get("output") or "")
-    output_limited, note = _limit_text(output, MAX_OUTPUT_CHARS, "output")
-    exit_code = event.get("exit_code")
-    exit_label = "pending" if exit_code is None else str(exit_code)
-    status = str(event.get("status") or "unknown")
-    status_class = str(event.get("status_class") or "neutral")
-    output_count = f"{len(output):,} chars"
-    return (
-        '<article class="event command-event">'
-        '<div class="event-rail command-rail">CMD</div>'
-        '<div class="command-card">'
-        '<div class="command-head">'
-        f'<span class="status-badge {status_class}">{_escape(status)}</span>'
-        f'<span class="exit-badge">exit {_escape(exit_label)}</span>'
-        f'<span class="event-meta">line {_fmt_number(event["line"])}</span>'
-        "</div>"
-        f'<pre class="code command-code"><code>{_escape(event.get("command") or "")}</code></pre>'
-        f'<details class="output-drawer"><summary>Command output · {output_count}{_escape(note)}</summary>'
-        f'<pre class="code output-code"><code>{_escape(output_limited) if output_limited else "No output."}</code></pre>'
-        "</details>"
-        "</div>"
-        "</article>"
-    )
-
-
-def _render_usage(event: dict[str, Any]) -> str:
-    usage = event.get("usage") or {}
-    input_tokens = int(usage.get("input_tokens") or 0)
-    cached = int(usage.get("cached_input_tokens") or 0)
-    output = int(usage.get("output_tokens") or 0)
-    reasoning = int(usage.get("reasoning_output_tokens") or 0)
-    total = input_tokens + output
-    return (
-        '<article class="event usage-event">'
-        '<div class="event-rail usage-rail">TURN</div>'
-        '<div class="usage-card">'
-        f'<span>Total {_fmt_number(total)}</span>'
-        f'<span>Input {_fmt_number(input_tokens)}</span>'
-        f'<span>Cached {_fmt_number(cached)}</span>'
-        f'<span>Output {_fmt_number(output)}</span>'
-        f'<span>Reasoning {_fmt_number(reasoning)}</span>'
-        f'<span class="event-meta">line {_fmt_number(event["line"])}</span>'
-        "</div>"
-        "</article>"
-    )
-
-
-def _render_todo(event: dict[str, Any]) -> str:
-    items = event.get("items") or []
-    rows = []
-    for todo in items:
-        if not isinstance(todo, dict):
-            continue
-        done = bool(todo.get("completed"))
-        rows.append(
-            '<li class="todo-row">'
-            f'<span class="todo-check {"done" if done else "open"}">{"&#10003;" if done else "&#9711;"}</span>'
-            f'<span>{_escape(todo.get("text") or "")}</span>'
-            "</li>"
-        )
-    return (
-        '<article class="event todo-event">'
-        '<div class="event-rail todo-rail">TODO</div>'
-        '<div class="todo-card">'
-        f'<div class="event-meta">line {_fmt_number(event["line"])}</div>'
-        f'<ul>{"".join(rows) if rows else "<li>No todo items.</li>"}</ul>'
-        "</div>"
-        "</article>"
-    )
-
-
-def _render_files(event: dict[str, Any]) -> str:
-    changes = event.get("changes") or []
-    rows = []
-    for change in changes:
-        if not isinstance(change, dict):
-            continue
-        rows.append(
-            '<li>'
-            f'<span class="file-kind">{_escape(change.get("kind") or "change")}</span>'
-            f'<code>{_escape(change.get("path") or "")}</code>'
-            "</li>"
-        )
-    return (
-        '<article class="event file-event">'
-        '<div class="event-rail file-rail">FILE</div>'
-        '<div class="file-card">'
-        f'<div class="event-meta">line {_fmt_number(event["line"])} · {_escape(event.get("status") or "")}</div>'
-        f'<ul>{"".join(rows) if rows else "<li>No file paths recorded.</li>"}</ul>'
-        "</div>"
-        "</article>"
-    )
-
-
-def _render_event(event: dict[str, Any]) -> str:
-    kind = event.get("kind")
-    if kind in {"agent", "user"}:
-        return _render_agent(event)
-    if kind == "command":
-        return _render_command(event)
-    if kind == "usage":
-        return _render_usage(event)
-    if kind == "todo":
-        return _render_todo(event)
-    if kind == "files":
-        return _render_files(event)
-    return ""
-
-
-def _render_transcript(events: list[dict[str, Any]], page: int, total_pages: int) -> str:
-    if not events:
-        return (
-            '<section class="empty-state">'
-            "<h2>No matching transcript events</h2>"
-            "<p>Try a broader search term or choose another session.</p>"
-            "</section>"
-        )
-    start = (page - 1) * PAGE_SIZE
-    visible = events[start : start + PAGE_SIZE]
-    rendered = "".join(_render_event(event) for event in visible)
-    return (
-        '<section class="transcript">'
-        f'<div class="page-marker">Page {page:,} of {total_pages:,}</div>'
-        f"{rendered}"
-        "</section>"
-    )
-
-
-def _render_error(title: str, details: str) -> tuple[str, str, str, int]:
-    return (
-        '<section class="summary-panel error-panel">'
-        f"<h1>{_escape(title)}</h1>"
-        f"<p>{_escape(details)}</p>"
-        "</section>",
-        '<section class="empty-state"><h2>Session unavailable</h2></section>',
-        "No session loaded.",
-        1,
-    )
-
-
-def _initial_view(choices: list[str]) -> tuple[str, str, str, int]:
-    choices_label = f"{len(choices):,} session files available" if choices else "No session files available"
-    summary = (
-        '<section class="summary-panel">'
-        '<div class="summary-topline">'
-        "<div><h1>Select a session</h1>"
-        f"<p>{_escape(choices_label)} from {DATASET_REPO}</p></div>"
-        f'<div class="repo-pill">private dataset · {_escape(APP_REVISION)}</div>'
-        "</div>"
-        '<div class="metrics-grid">'
-        f'{_metric("Startup mode", "metadata only")}'
-        f'{_metric("Files listed", _fmt_number(len(choices)))}'
-        f'{_metric("Downloads", "on demand")}'
-        f'{_metric("Page size", _fmt_number(PAGE_SIZE))}'
-        "</div>"
-        "</section>"
-    )
-    transcript = (
-        '<section class="empty-state">'
-        "<h2>No session loaded yet</h2>"
-        "<p>Choose a session in the sidebar and select Load session. Files are downloaded lazily.</p>"
-        "</section>"
-    )
-    return summary, transcript, "No session file downloaded yet.", 1
-
-
-def render_session(session_name: str | None, query: str | None = "", page: int | float | None = 1) -> tuple[str, str, str, int]:
-    choices = KNOWN_SESSIONS
-    list_error = ""
-    if not choices:
-        return _render_error("Dataset file list unavailable", list_error or "HF_TOKEN is not configured.")
-
-    session_name = session_name or choices[0]
-    if session_name not in choices and _display_name(str(session_name)) in choices:
-        session_name = _display_name(str(session_name))
-    candidates = _file_candidates(session_name)
-    if not candidates:
-        return _render_error("No session selected", "Choose a session from the dropdown.")
-
-    last_error: Exception | None = None
-    data = None
-    for file_name in candidates:
-        try:
-            data = _load_session(file_name)
-            break
-        except Exception as exc:
-            last_error = exc
-    if data is None:
-        details = f"{type(last_error).__name__}: {last_error}" if last_error else "No file candidates were available."
-        return _render_error("Could not load session", details)
-
-    query = query or ""
-    filtered = _filter_events(data["events"], query)
-    total_pages = max(1, math.ceil(len(filtered) / PAGE_SIZE))
-    try:
-        page_int = int(page or 1)
-    except (TypeError, ValueError):
-        page_int = 1
-    page_int = min(max(1, page_int), total_pages)
-    start = (page_int - 1) * PAGE_SIZE + 1 if filtered else 0
-    end = min(page_int * PAGE_SIZE, len(filtered))
-    page_info = (
-        f"Showing {start:,}-{end:,} of {len(filtered):,} matching events "
-        f"({len(data['events']):,} total parsed)."
-    )
-    if data["summary"]["parse_errors"]:
-        page_info += f" Skipped {data['summary']['parse_errors']:,} non-JSON lines."
-    summary = _render_summary(data, len(filtered), query)
-    transcript = _render_transcript(filtered, page_int, total_pages)
-    return summary, transcript, page_info, page_int
-
-
-def load_session(session_name: str | None) -> tuple[str, str, str, int, str]:
-    summary, transcript, page_info, page = render_session(session_name, "", 1)
-    return summary, transcript, page_info, page, ""
-
-
-def filter_session(session_name: str | None, query: str | None) -> tuple[str, str, str, int]:
-    return render_session(session_name, query, 1)
-
-
-def next_page(session_name: str | None, query: str | None, page: int | float | None) -> tuple[str, str, str, int]:
-    return render_session(session_name, query, int(page or 1) + 1)
-
-
-def previous_page(session_name: str | None, query: str | None, page: int | float | None) -> tuple[str, str, str, int]:
-    return render_session(session_name, query, int(page or 1) - 1)
-
-
-def refresh_sessions() -> tuple[Any, str, str, str, int, str]:
-    _list_sessions_cached.cache_clear()
-    choices = _session_choices()
-    value = None
-    summary, transcript, page_info, page = _initial_view(choices)
-    return gr.update(choices=choices, value=value), summary, transcript, page_info, page, ""
-
-
-CUSTOM_CSS = """
-:root {
-  --ct-bg: #0b0d10;
-  --ct-panel: #11151a;
-  --ct-panel-2: #151a21;
-  --ct-line: #30363d;
-  --ct-text: #e6edf3;
-  --ct-muted: #8b949e;
-  --ct-green: #3fb950;
-  --ct-red: #f85149;
-  --ct-yellow: #d29922;
-  --ct-blue: #58a6ff;
-  --ct-cyan: #39c5cf;
-  --ct-mono: "SFMono-Regular", Consolas, "Liberation Mono", Menlo, monospace;
-  --ct-sans: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
-}
-
-html, body, .gradio-container {
-  min-height: 100%;
-  background: var(--ct-bg) !important;
-  color: var(--ct-text) !important;
-  font-family: var(--ct-sans) !important;
-}
-
-.gradio-container,
-.gradio-container .contain,
-.gradio-container main {
-  max-width: none !important;
-  width: 100% !important;
-  padding: 0 !important;
-}
-
-#ct-app {
-  min-height: 100vh;
-  background:
-    linear-gradient(180deg, rgba(88, 166, 255, 0.07), transparent 210px),
-    var(--ct-bg);
-}
-
-.ct-shell {
-  display: grid;
-  grid-template-columns: minmax(260px, 330px) minmax(0, 1fr);
-  gap: 0;
-  min-height: 100vh;
-}
-
-.ct-sidebar {
-  background: #0f1318;
-  border-right: 1px solid var(--ct-line);
-  padding: 22px 18px;
-  position: sticky;
-  top: 0;
-  height: 100vh;
-  overflow: auto;
-}
-
-.ct-brand {
-  margin-bottom: 22px;
-}
-
-.ct-brand h1 {
-  font-family: var(--ct-mono);
-  font-size: 21px;
-  line-height: 1.2;
-  margin: 0 0 6px;
-  color: var(--ct-text);
-  letter-spacing: 0;
-}
-
-.ct-brand p {
-  margin: 0;
-  color: var(--ct-muted);
-  font-size: 13px;
-  line-height: 1.45;
-}
-
-.ct-sidebar .gradio-dropdown,
-.ct-sidebar .gradio-textbox,
-.ct-sidebar .gradio-button {
-  font-family: var(--ct-mono) !important;
-}
-
-.ct-sidebar .block,
-.ct-sidebar .form,
-.ct-sidebar .wrap,
-.ct-sidebar .container,
-.ct-sidebar .secondary-wrap,
-.ct-sidebar .input-container,
-.ct-sidebar .block > div {
-  background: transparent !important;
-  border-color: var(--ct-line) !important;
-  box-shadow: none !important;
-}
-
-.ct-sidebar .block {
-  background: var(--ct-panel) !important;
-  border: 1px solid var(--ct-line) !important;
-  border-radius: 8px !important;
-}
-
-.ct-sidebar label,
-.ct-sidebar .block span {
-  color: var(--ct-muted) !important;
-}
-
-.ct-sidebar input,
-.ct-sidebar textarea,
-.ct-sidebar .wrap,
-.ct-sidebar .container {
-  background: var(--ct-panel) !important;
-  color: var(--ct-text) !important;
-  border-color: var(--ct-line) !important;
-}
-
-.ct-sidebar button {
-  background: var(--ct-panel-2) !important;
-  border: 1px solid var(--ct-line) !important;
-  border-radius: 8px !important;
-  color: var(--ct-text) !important;
-  font-family: var(--ct-mono) !important;
-  min-height: 42px;
-}
-
-.ct-sidebar button:hover {
-  border-color: var(--ct-blue) !important;
-  color: #ffffff !important;
-}
-
-.ct-sidebar button.primary,
-.ct-sidebar .primary button {
-  background: #1f6feb !important;
-  border-color: #388bfd !important;
-  color: #ffffff !important;
-}
-
-.ct-main {
-  padding: 22px;
-  min-width: 0;
-}
-
-.summary-panel {
-  background: var(--ct-panel);
-  border: 1px solid var(--ct-line);
-  border-radius: 8px;
-  margin-bottom: 18px;
-  padding: 18px;
-}
-
-.summary-topline {
-  display: flex;
-  align-items: flex-start;
-  justify-content: space-between;
-  gap: 16px;
-  margin-bottom: 16px;
-}
-
-.summary-topline h1 {
-  font-family: var(--ct-mono);
-  font-size: 22px;
-  margin: 0 0 6px;
-  color: var(--ct-text);
-  letter-spacing: 0;
-}
-
-.summary-topline p {
-  margin: 0;
-  color: var(--ct-muted);
-  font-family: var(--ct-mono);
-  font-size: 13px;
-}
-
-.repo-pill {
-  border: 1px solid rgba(57, 197, 207, 0.45);
-  color: var(--ct-cyan);
-  border-radius: 999px;
-  padding: 5px 10px;
-  font-family: var(--ct-mono);
-  font-size: 12px;
-  white-space: nowrap;
-}
-
-.metrics-grid {
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(135px, 1fr));
-  gap: 10px;
-}
-
-.metric {
-  background: var(--ct-panel-2);
-  border: 1px solid var(--ct-line);
-  border-radius: 8px;
-  padding: 10px 12px;
-  min-height: 62px;
-}
-
-.metric-label {
-  display: block;
-  color: var(--ct-muted);
-  font-size: 12px;
-  margin-bottom: 6px;
-}
-
-.metric-value {
-  display: block;
-  color: var(--ct-text);
-  font-family: var(--ct-mono);
-  font-size: 17px;
-  overflow-wrap: anywhere;
-}
-
-.metric.ok .metric-value {
-  color: var(--ct-green);
-}
-
-.metric.danger .metric-value {
-  color: var(--ct-red);
-}
-
-.transcript {
-  display: flex;
-  flex-direction: column;
-  gap: 14px;
-}
-
-.page-marker {
-  color: var(--ct-muted);
-  font-family: var(--ct-mono);
-  font-size: 12px;
-  padding: 0 2px;
-}
-
-.event {
-  display: grid;
-  grid-template-columns: 58px minmax(0, 1fr);
-  gap: 12px;
-  align-items: start;
-}
-
-.event-rail {
-  position: sticky;
-  top: 18px;
-  border: 1px solid var(--ct-line);
-  border-radius: 8px;
-  padding: 8px 0;
-  text-align: center;
-  font-family: var(--ct-mono);
-  font-size: 11px;
-  color: var(--ct-muted);
-  background: #0f1318;
-}
-
-.agent-rail { color: var(--ct-blue); }
-.user-rail { color: var(--ct-cyan); }
-.command-rail { color: var(--ct-yellow); }
-.usage-rail { color: var(--ct-green); }
-.todo-rail { color: var(--ct-cyan); }
-.file-rail { color: #c9d1d9; }
-
-.bubble,
-.command-card,
-.usage-card,
-.todo-card,
-.file-card,
-.empty-state {
-  border: 1px solid var(--ct-line);
-  border-radius: 8px;
-  background: var(--ct-panel);
-  min-width: 0;
-}
-
-.agent-bubble {
-  padding: 14px 15px;
-  border-left: 3px solid var(--ct-blue);
-}
-
-.user-bubble {
-  padding: 14px 15px;
-  border-left: 3px solid var(--ct-cyan);
-  background: #101820;
-}
-
-.event-meta {
-  color: var(--ct-muted);
-  font-family: var(--ct-mono);
-  font-size: 12px;
-  margin-bottom: 8px;
-}
-
-.message-text {
-  white-space: pre-wrap;
-  overflow-wrap: anywhere;
-  color: var(--ct-text);
-  line-height: 1.55;
-  font-size: 14px;
-}
-
-.command-card {
-  overflow: hidden;
-  border-left: 3px solid var(--ct-yellow);
-}
-
-.command-head {
-  display: flex;
-  align-items: center;
-  flex-wrap: wrap;
-  gap: 8px;
-  padding: 12px 12px 0;
-}
-
-.status-badge,
-.exit-badge {
-  font-family: var(--ct-mono);
-  font-size: 12px;
-  border-radius: 999px;
-  border: 1px solid var(--ct-line);
-  padding: 3px 8px;
-}
-
-.status-badge.success { color: var(--ct-green); border-color: rgba(63, 185, 80, .5); }
-.status-badge.fail { color: var(--ct-red); border-color: rgba(248, 81, 73, .55); }
-.status-badge.running { color: var(--ct-yellow); border-color: rgba(210, 153, 34, .55); }
-.status-badge.neutral { color: var(--ct-muted); }
-
-.exit-badge {
-  color: var(--ct-muted);
-}
-
-.code {
-  margin: 0;
-  overflow: auto;
-  font-family: var(--ct-mono);
-  font-size: 12.5px;
-  line-height: 1.55;
-  color: #dbeafe;
-  background: #070a0f;
-}
-
-.command-code {
-  margin: 12px;
-  padding: 12px;
-  border: 1px solid #1f2937;
-  border-radius: 8px;
-}
-
-.output-drawer {
-  border-top: 1px solid var(--ct-line);
-}
-
-.output-drawer summary {
-  cursor: pointer;
-  color: var(--ct-muted);
-  font-family: var(--ct-mono);
-  font-size: 12px;
-  padding: 10px 12px;
-}
-
-.output-code {
-  max-height: 520px;
-  padding: 12px;
-  border-top: 1px solid #1f2937;
-}
-
-.usage-card {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 8px;
-  padding: 12px;
-  border-left: 3px solid var(--ct-green);
-}
-
-.usage-card span {
-  font-family: var(--ct-mono);
-  font-size: 12px;
-  color: var(--ct-text);
-  background: #0b1117;
-  border: 1px solid var(--ct-line);
-  border-radius: 999px;
-  padding: 4px 9px;
-}
-
-.todo-card,
-.file-card {
-  padding: 12px;
-}
-
-.todo-card {
-  border-left: 3px solid var(--ct-cyan);
-}
-
-.file-card {
-  border-left: 3px solid #c9d1d9;
-}
-
-.todo-card ul,
-.file-card ul {
-  list-style: none;
-  padding: 0;
-  margin: 0;
-  display: grid;
-  gap: 8px;
-}
-
-.todo-row {
-  display: grid;
-  grid-template-columns: 24px minmax(0, 1fr);
-  gap: 8px;
-  color: var(--ct-text);
-  line-height: 1.45;
-}
-
-.todo-check {
-  font-family: var(--ct-mono);
-  color: var(--ct-muted);
-}
-
-.todo-check.done {
-  color: var(--ct-green);
-}
-
-.file-card li {
-  display: flex;
-  gap: 10px;
-  align-items: baseline;
-  min-width: 0;
-}
-
-.file-kind {
-  color: var(--ct-yellow);
-  font-family: var(--ct-mono);
-  font-size: 12px;
-  min-width: 46px;
-}
-
-.file-card code {
-  color: var(--ct-text);
-  font-family: var(--ct-mono);
-  overflow-wrap: anywhere;
-}
-
-.empty-state {
-  padding: 32px;
-  color: var(--ct-muted);
-}
-
-.empty-state h2 {
-  color: var(--ct-text);
-  margin: 0 0 8px;
-  font-family: var(--ct-mono);
-  font-size: 18px;
-  letter-spacing: 0;
-}
-
-.error-panel {
-  border-color: rgba(248, 81, 73, .6);
-}
-
-.ct-page-info {
-  color: var(--ct-muted);
-  font-family: var(--ct-mono);
-  font-size: 12px;
-  margin: 8px 0 12px;
-}
-
-.ct-page-info,
-.ct-page-info * {
-  color: var(--ct-muted) !important;
-}
-
-.ct-pager {
-  display: grid;
-  grid-template-columns: 1fr 1fr;
-  gap: 8px;
-}
-
-@media (max-width: 860px) {
-  .ct-shell {
-    grid-template-columns: 1fr;
-  }
-  .ct-sidebar {
-    position: relative;
-    height: auto;
-    border-right: 0;
-    border-bottom: 1px solid var(--ct-line);
-  }
-  .ct-main {
-    padding: 14px;
-  }
-  .event {
-    grid-template-columns: 1fr;
-  }
-  .event-rail {
-    position: relative;
-    top: 0;
-    width: 58px;
-  }
-  .summary-topline {
-    flex-direction: column;
-  }
-}
-"""
-
-
-def build_app() -> gr.Blocks:
-    print("codex-traces startup: building app", flush=True)
-    choices = _session_choices(live=False)
-    default = None
-    initial_summary, initial_transcript, initial_page_info, initial_page = _initial_view(choices)
-    theme = gr.themes.Base(
-        primary_hue="blue",
-        secondary_hue="cyan",
-        neutral_hue="slate",
-        radius_size="sm",
-    )
-
-    with gr.Blocks(title=APP_TITLE, theme=theme, css=CUSTOM_CSS) as demo:
-        with gr.Row(elem_id="ct-app", elem_classes=["ct-shell"]):
-            with gr.Column(elem_classes=["ct-sidebar"], scale=0):
-                gr.HTML(
-                    '<div class="ct-brand">'
-                    "<h1>Codex Traces</h1>"
-                    "<p>Private rollout.jsonl session viewer</p>"
-                    "</div>"
-                )
-                session = gr.Dropdown(
-                    choices=choices,
-                    value=default,
-                    label="Session file",
-                    interactive=True,
-                    allow_custom_value=False,
-                )
-                search = gr.Textbox(
-                    label="Search transcript",
-                    placeholder="Filter by keyword, command, output, token...",
-                    lines=1,
-                    max_lines=1,
-                )
-                filter_button = gr.Button("Filter", variant="primary")
-                load_button = gr.Button("Load session")
-                refresh_button = gr.Button("Refresh file list")
-                page_state = gr.State(initial_page)
-                page_info = gr.Markdown(initial_page_info, elem_classes=["ct-page-info"])
-                with gr.Row(elem_classes=["ct-pager"]):
-                    prev_button = gr.Button("Previous")
-                    next_button = gr.Button("Next")
-
-            with gr.Column(elem_classes=["ct-main"], scale=1):
-                summary = gr.HTML(initial_summary)
-                transcript = gr.HTML(initial_transcript)
-
-        session.change(
-            fn=load_session,
-            inputs=session,
-            outputs=[summary, transcript, page_info, page_state, search],
-            api_name="load_session",
-            show_progress="minimal",
-        )
-        load_button.click(
-            fn=load_session,
-            inputs=session,
-            outputs=[summary, transcript, page_info, page_state, search],
-            api_name=False,
-            show_progress="minimal",
-        )
-        filter_button.click(
-            fn=filter_session,
-            inputs=[session, search],
-            outputs=[summary, transcript, page_info, page_state],
-            api_name="filter_session",
-            show_progress="minimal",
-        )
-        search.submit(
-            fn=filter_session,
-            inputs=[session, search],
-            outputs=[summary, transcript, page_info, page_state],
-            api_name=False,
-            show_progress="minimal",
-        )
-        prev_button.click(
-            fn=previous_page,
-            inputs=[session, search, page_state],
-            outputs=[summary, transcript, page_info, page_state],
-            api_name="previous_page",
-            show_progress="minimal",
-        )
-        next_button.click(
-            fn=next_page,
-            inputs=[session, search, page_state],
-            outputs=[summary, transcript, page_info, page_state],
-            api_name="next_page",
-            show_progress="minimal",
-        )
-        refresh_button.click(
-            fn=refresh_sessions,
-            inputs=None,
-            outputs=[session, summary, transcript, page_info, page_state, search],
-            api_name="refresh_sessions",
-            show_progress="minimal",
-        )
-
-    print("codex-traces startup: app built", flush=True)
-    return demo
 
+print("probe startup: after gradio import", flush=True)
 
-demo = build_app()
-print("codex-traces startup: demo ready", flush=True)
+with gr.Blocks(title="Codex Traces Probe") as demo:
+    gr.Markdown("# Codex Traces Probe\n\nRuntime startup check.")
+    out = gr.Textbox(value="ready", label="Status")
 
-print("codex-traces startup: launching", flush=True)
-demo.launch(
-    server_name="0.0.0.0",
-    server_port=7860,
-    show_error=True,
-)
+print("probe startup: launching", flush=True)
+demo.launch(server_name="0.0.0.0", server_port=7860, show_error=True)