@respan/cli 0.5.3 → 0.6.1

package/dist/assets/codex_hook.py

@@ -1,897 +0,0 @@
-#!/usr/bin/env python3
-"""
-Respan Hook for Codex CLI
-
-Sends Codex CLI conversation traces to Respan after each agent turn.
-Uses Codex CLI's notify hook to capture session JSONL files and convert
-them to Respan spans.
-
-Usage:
-    Add to ~/.codex/config.toml:
-        notify = ["python3", "~/.respan/codex_hook.py"]
-    Run: respan integrate codex-cli
-"""
-
-import contextlib
-import json
-import os
-import sys
-import tempfile
-import time
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
-
-try:
-    import requests
-except ImportError:
-    print("Error: Python 'requests' package is required. Install: pip3 install requests", file=sys.stderr)
-    sys.exit(1)
-
-try:
-    import fcntl
-except ImportError:
-    fcntl = None  # Not available on Windows
-
-# Configuration
-LOG_FILE = Path.home() / ".codex" / "state" / "respan_hook.log"
-STATE_FILE = Path.home() / ".codex" / "state" / "respan_state.json"
-LOCK_FILE = Path.home() / ".codex" / "state" / "respan_hook.lock"
-DEBUG = os.environ.get("CODEX_RESPAN_DEBUG", "").lower() == "true"
-
-try:
-    MAX_CHARS = int(os.environ.get("CODEX_RESPAN_MAX_CHARS", "4000"))
-except (ValueError, TypeError):
-    MAX_CHARS = 4000
-
-
-def log(level: str, message: str) -> None:
-    """Log a message to the log file."""
-    LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
-    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    with open(LOG_FILE, "a", encoding="utf-8") as f:
-        f.write(f"{timestamp} [{level}] {message}\n")
-
-
-def debug(message: str) -> None:
-    """Log a debug message (only if DEBUG is enabled)."""
-    if DEBUG:
-        log("DEBUG", message)
-
-
-def load_state() -> Dict[str, Any]:
-    """Load the state file containing session tracking info."""
-    if not STATE_FILE.exists():
-        return {}
-    try:
-        return json.loads(STATE_FILE.read_text(encoding="utf-8"))
-    except (json.JSONDecodeError, IOError):
-        return {}
-
-
-def save_state(state: Dict[str, Any]) -> None:
-    """Save the state file atomically via write-to-temp + rename."""
-    STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
-    try:
-        fd, tmp_path = tempfile.mkstemp(dir=STATE_FILE.parent, suffix=".tmp")
-        try:
-            with os.fdopen(fd, "w", encoding="utf-8") as f:
-                json.dump(state, f, indent=2)
-            os.rename(tmp_path, STATE_FILE)
-        except BaseException:
-            with contextlib.suppress(OSError):
-                os.unlink(tmp_path)
-            raise
-    except OSError as e:
-        log("ERROR", f"Failed to save state atomically, falling back: {e}")
-        STATE_FILE.write_text(json.dumps(state, indent=2), encoding="utf-8")
-
-
-@contextlib.contextmanager
-def state_lock(timeout: float = 5.0):
-    """Acquire an advisory file lock around state operations."""
-    if fcntl is None:
-        yield
-        return
-
-    LOCK_FILE.parent.mkdir(parents=True, exist_ok=True)
-    lock_fd = None
-    try:
-        lock_fd = open(LOCK_FILE, "w")
-        deadline = time.monotonic() + timeout
-        while True:
-            try:
-                fcntl.flock(lock_fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
-                break
-            except (IOError, OSError):
-                if time.monotonic() >= deadline:
-                    debug("Could not acquire state lock within timeout, proceeding without lock")
-                    lock_fd.close()
-                    lock_fd = None
-                    yield
-                    return
-                time.sleep(0.1)
-        try:
-            yield
-        finally:
-            fcntl.flock(lock_fd, fcntl.LOCK_UN)
-            lock_fd.close()
-    except Exception as e:
-        debug(f"Lock error, proceeding without lock: {e}")
-        if lock_fd is not None:
-            with contextlib.suppress(Exception):
-                lock_fd.close()
-        yield
-
-
-def parse_timestamp(ts_str: str) -> Optional[datetime]:
-    """Parse ISO timestamp string to datetime."""
-    try:
-        if ts_str.endswith("Z"):
-            ts_str = ts_str[:-1] + "+00:00"
-        return datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
-    except (ValueError, AttributeError):
-        return None
-
-
-# Known config keys in respan.json that map to span fields.
-KNOWN_CONFIG_KEYS = {"customer_id", "span_name", "workflow_name"}
-
-
-def load_respan_config(cwd: str) -> Dict[str, Any]:
-    """Load .codex/respan.json from the project directory.
-
-    Returns a dict with two keys:
-      - "fields": known span fields (customer_id, span_name, workflow_name)
-      - "properties": everything else (custom properties -> metadata)
-    """
-    config_path = Path(cwd) / ".codex" / "respan.json"
-    if not config_path.exists():
-        return {"fields": {}, "properties": {}}
-    try:
-        raw = json.loads(config_path.read_text(encoding="utf-8"))
-        if not isinstance(raw, dict):
-            return {"fields": {}, "properties": {}}
-        fields = {}
-        properties = {}
-        for k, v in raw.items():
-            if k in KNOWN_CONFIG_KEYS:
-                fields[k] = v
-            else:
-                properties[k] = v
-        return {"fields": fields, "properties": properties}
-    except (json.JSONDecodeError, IOError) as e:
-        debug(f"Failed to load respan.json from {config_path}: {e}")
-        return {"fields": {}, "properties": {}}
-
-
-def truncate(text: str, max_length: int = MAX_CHARS) -> str:
-    """Truncate text to max_length."""
-    if len(text) > max_length:
-        return text[:max_length] + "\n... (truncated)"
-    return text
-
-
-def find_session_file(session_id: str) -> Optional[Path]:
-    """Find the session JSONL file for a given session ID.
-
-    Codex CLI stores sessions at:
-      ~/.codex/sessions/YYYY/MM/DD/rollout-<timestamp>-<session-id>.jsonl
-
-    The session ID appears in the filename after the timestamp prefix.
-    """
-    sessions_dir = Path.home() / ".codex" / "sessions"
-    if not sessions_dir.exists():
-        debug(f"Sessions directory not found: {sessions_dir}")
-        return None
-
-    # Search date directories in reverse order (newest first)
-    for year_dir in sorted(sessions_dir.iterdir(), reverse=True):
-        if not year_dir.is_dir():
-            continue
-        for month_dir in sorted(year_dir.iterdir(), reverse=True):
-            if not month_dir.is_dir():
-                continue
-            for day_dir in sorted(month_dir.iterdir(), reverse=True):
-                if not day_dir.is_dir():
-                    continue
-                for f in day_dir.glob("*.jsonl"):
-                    if session_id in f.name:
-                        debug(f"Found session file: {f}")
-                        return f
-
-    debug(f"No session file found for session ID: {session_id}")
-    return None
-
-
-def find_latest_session_file() -> Optional[Tuple[str, Path]]:
-    """Find the most recently modified session JSONL file.
-
-    Returns (session_id, path) or None.
-    """
-    sessions_dir = Path.home() / ".codex" / "sessions"
-    if not sessions_dir.exists():
-        return None
-
-    latest_file = None
-    latest_mtime = 0
-
-    for year_dir in sessions_dir.iterdir():
-        if not year_dir.is_dir():
-            continue
-        for month_dir in year_dir.iterdir():
-            if not month_dir.is_dir():
-                continue
-            for day_dir in month_dir.iterdir():
-                if not day_dir.is_dir():
-                    continue
-                for f in day_dir.glob("*.jsonl"):
-                    mtime = f.stat().st_mtime
-                    if mtime > latest_mtime:
-                        latest_mtime = mtime
-                        latest_file = f
-
-    if latest_file:
-        # Extract session ID from first line
-        try:
-            first_line = latest_file.read_text(encoding="utf-8").split("\n")[0]
-            if first_line:
-                first_msg = json.loads(first_line)
-                payload = first_msg.get("payload", {})
-                session_id = payload.get("id", latest_file.stem)
-                return (session_id, latest_file)
-        except (json.JSONDecodeError, IOError, IndexError) as e:
-            debug(f"Error reading session file {latest_file}: {e}")
-
-    return None
-
-
-def parse_session(lines: List[str]) -> List[Dict[str, Any]]:
-    """Parse JSONL lines into a list of events."""
-    events = []
-    for line in lines:
-        line = line.strip()
-        if not line:
-            continue
-        try:
-            events.append(json.loads(line))
-        except json.JSONDecodeError:
-            continue
-    return events
-
-
-def extract_turns(events: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-    """Extract turns from session events.
-
-    A turn is bounded by task_started and task_complete events.
-    Returns a list of turn dicts, each containing:
-      - turn_id: str
-      - start_time: str (ISO timestamp)
-      - end_time: str (ISO timestamp)
-      - model: str
-      - cwd: str
-      - user_message: str
-      - assistant_message: str
-      - commentary: List[str]
-      - tool_calls: List[dict]
-      - tool_outputs: List[dict]
-      - reasoning: bool (whether reasoning was present)
-      - token_usage: dict (from last_token_usage)
-      - events: List[dict] (raw events in this turn)
-    """
-    turns = []
-    current_turn = None
-
-    for event in events:
-        evt_type = event.get("type")
-        payload = event.get("payload", {})
-        timestamp = event.get("timestamp", "")
-
-        if evt_type == "event_msg":
-            msg_type = payload.get("type", "")
-
-            if msg_type == "task_started":
-                current_turn = {
-                    "turn_id": payload.get("turn_id", ""),
-                    "start_time": timestamp,
-                    "end_time": "",
-                    "model": "",
-                    "cwd": "",
-                    "user_message": "",
-                    "assistant_message": "",
-                    "commentary": [],
-                    "tool_calls": [],
-                    "tool_outputs": [],
-                    "reasoning": False,
-                    "token_usage": {},
-                    "events": [],
-                }
-
-            elif msg_type == "task_complete" and current_turn:
-                current_turn["end_time"] = timestamp
-                current_turn["_complete_payload"] = payload
-                turns.append(current_turn)
-                current_turn = None
-
-            elif msg_type == "user_message" and current_turn:
-                current_turn["user_message"] = payload.get("message", "")
-
-            elif msg_type == "agent_message" and current_turn:
-                phase = payload.get("phase", "")
-                message = payload.get("message", "")
-                if phase == "final_answer":
-                    current_turn["assistant_message"] = message
-                elif phase == "commentary":
-                    current_turn["commentary"].append(message)
-
-            elif msg_type == "token_count" and current_turn:
-                info = payload.get("info", {})
-                last_usage = info.get("last_token_usage", {})
-                if last_usage:
-                    current_turn["token_usage"] = last_usage
-
-        elif evt_type == "turn_context" and current_turn:
-            current_turn["model"] = payload.get("model", "")
-            current_turn["cwd"] = payload.get("cwd", "")
-
-        elif evt_type == "response_item" and current_turn:
-            item_type = payload.get("type", "")
-
-            if item_type == "function_call":
-                current_turn["tool_calls"].append({
-                    "name": payload.get("name", "unknown"),
-                    "arguments": payload.get("arguments", ""),
-                    "call_id": payload.get("call_id", ""),
-                    "timestamp": timestamp,
-                })
-
-            elif item_type == "custom_tool_call":
-                current_turn["tool_calls"].append({
-                    "name": payload.get("name", "unknown"),
-                    "arguments": payload.get("input", ""),
-                    "call_id": payload.get("call_id", ""),
-                    "timestamp": timestamp,
-                })
-
-            elif item_type == "function_call_output":
-                current_turn["tool_outputs"].append({
-                    "call_id": payload.get("call_id", ""),
-                    "output": payload.get("output", ""),
-                    "timestamp": timestamp,
-                })
-
-            elif item_type == "custom_tool_call_output":
-                current_turn["tool_outputs"].append({
-                    "call_id": payload.get("call_id", ""),
-                    "output": payload.get("output", ""),
-                    "timestamp": timestamp,
-                })
-
-            elif item_type == "reasoning":
-                current_turn["reasoning"] = True
-
-            elif item_type == "web_search_call":
-                action = payload.get("action", {})
-                query = action.get("query", "")
-                current_turn["tool_calls"].append({
-                    "name": "web_search",
-                    "arguments": json.dumps({"query": query}),
-                    "call_id": f"web_search_{timestamp}",
-                    "timestamp": timestamp,
-                })
-
-        if current_turn is not None:
-            current_turn["events"].append(event)
-
-    return turns
-
-
-def create_respan_spans(
-    session_id: str,
-    turn_num: int,
-    turn: Dict[str, Any],
-    config: Optional[Dict[str, Any]] = None,
-) -> List[Dict[str, Any]]:
-    """Create Respan span logs for a single Codex CLI turn.
-
-    Produces a span tree:
-        Root: codex-cli (agent container, latency, metadata)
-          +-- openai.chat (generation - model, tokens, messages)
-          +-- Reasoning (if reasoning_output_tokens > 0)
-          +-- Tool: Shell (if exec_command)
-          +-- Tool: File Edit (if apply_patch)
-          +-- Tool: Web Search (if web_search_call)
-    """
-    spans = []
-
-    # Extract data from the turn
-    user_text = turn.get("user_message", "")
-    assistant_text = turn.get("assistant_message", "")
-    commentary = turn.get("commentary", [])
-    model = turn.get("model", "gpt-5.4")
-    cwd = turn.get("cwd", "")
-    token_usage = turn.get("token_usage", {})
-    tool_calls = turn.get("tool_calls", [])
-    tool_outputs = turn.get("tool_outputs", [])
-    has_reasoning = turn.get("reasoning", False)
-
-    # Timing
-    start_time_str = turn.get("start_time", "")
-    end_time_str = turn.get("end_time", "")
-    now_str = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
-    if not start_time_str:
-        start_time_str = now_str
-    if not end_time_str:
-        end_time_str = now_str
-
-    latency = None
-    start_dt = parse_timestamp(start_time_str)
-    end_dt = parse_timestamp(end_time_str)
-    if start_dt and end_dt:
-        latency = (end_dt - start_dt).total_seconds()
-
-    # Messages for input/output
-    prompt_messages: List[Dict[str, Any]] = []
-    if user_text:
-        prompt_messages.append({"role": "user", "content": user_text})
-    completion_message: Optional[Dict[str, Any]] = None
-    if assistant_text:
-        completion_message = {"role": "assistant", "content": assistant_text}
-
-    # IDs from config
-    cfg_fields = (config or {}).get("fields", {})
-    cfg_props = (config or {}).get("properties", {})
-
-    trace_unique_id = f"{session_id}_turn_{turn_num}"
-    workflow_name = os.environ.get("RESPAN_WORKFLOW_NAME") or cfg_fields.get("workflow_name") or "codex-cli"
-    root_span_name = os.environ.get("RESPAN_SPAN_NAME") or cfg_fields.get("span_name") or "codex-cli"
-    thread_id = f"codexcli_{session_id}"
-    customer_id = os.environ.get("RESPAN_CUSTOMER_ID") or cfg_fields.get("customer_id") or ""
-
-    # Metadata
-    metadata: Dict[str, Any] = {
-        "codex_cli_turn": turn_num,
-    }
-    if cwd:
-        metadata["cwd"] = cwd
-    if commentary:
-        metadata["commentary"] = "\n".join(commentary)
-    if cfg_props:
-        metadata.update(cfg_props)
-    env_metadata = os.environ.get("RESPAN_METADATA")
-    if env_metadata:
-        try:
-            extra = json.loads(env_metadata)
-            if isinstance(extra, dict):
-                metadata.update(extra)
-        except json.JSONDecodeError:
-            pass
-
-    # Token usage mapping
-    usage_fields: Dict[str, Any] = {}
-    if token_usage:
-        prompt_tokens = token_usage.get("input_tokens", 0)
-        completion_tokens = token_usage.get("output_tokens", 0)
-        usage_fields["prompt_tokens"] = prompt_tokens
-        usage_fields["completion_tokens"] = completion_tokens
-        total = token_usage.get("total_tokens", prompt_tokens + completion_tokens)
-        if total > 0:
-            usage_fields["total_tokens"] = total
-        cached = token_usage.get("cached_input_tokens", 0)
-        if cached > 0:
-            usage_fields["prompt_tokens_details"] = {"cached_tokens": cached}
-        reasoning_tokens = token_usage.get("reasoning_output_tokens", 0)
-        if reasoning_tokens > 0:
-            metadata["reasoning_tokens"] = reasoning_tokens
-
-    # ------------------------------------------------------------------
-    # Root span - agent container
-    # ------------------------------------------------------------------
-    root_span_id = f"codexcli_{trace_unique_id}_root"
-    root_span: Dict[str, Any] = {
-        "trace_unique_id": trace_unique_id,
-        "thread_identifier": thread_id,
-        "customer_identifier": customer_id,
-        "span_unique_id": root_span_id,
-        "span_name": root_span_name,
-        "span_workflow_name": workflow_name,
-        "model": model,
-        "provider_id": "",
-        "span_path": "",
-        "input": json.dumps(prompt_messages) if prompt_messages else "",
-        "output": json.dumps(completion_message) if completion_message else "",
-        "timestamp": end_time_str,
-        "start_time": start_time_str,
-        "metadata": metadata,
-    }
-    if latency is not None:
-        root_span["latency"] = latency
-    spans.append(root_span)
-
-    # ------------------------------------------------------------------
-    # LLM generation child span
-    # ------------------------------------------------------------------
-    gen_span_id = f"codexcli_{trace_unique_id}_gen"
-    gen_span: Dict[str, Any] = {
-        "trace_unique_id": trace_unique_id,
-        "span_unique_id": gen_span_id,
-        "span_parent_id": root_span_id,
-        "span_name": "openai.chat",
-        "span_workflow_name": workflow_name,
-        "span_path": "openai_chat",
-        "model": model,
-        "provider_id": "openai",
-        "metadata": {},
-        "input": json.dumps(prompt_messages) if prompt_messages else "",
-        "output": json.dumps(completion_message) if completion_message else "",
-        "prompt_messages": prompt_messages,
-        "completion_message": completion_message,
-        "timestamp": end_time_str,
-        "start_time": start_time_str,
-    }
-    if latency is not None:
-        gen_span["latency"] = latency
-    gen_span.update(usage_fields)
-    spans.append(gen_span)
-
-    # ------------------------------------------------------------------
-    # Reasoning child span (if reasoning_output_tokens > 0)
-    # ------------------------------------------------------------------
-    reasoning_tokens = token_usage.get("reasoning_output_tokens", 0)
-    if has_reasoning or reasoning_tokens > 0:
-        spans.append({
-            "trace_unique_id": trace_unique_id,
-            "span_unique_id": f"codexcli_{trace_unique_id}_reasoning",
-            "span_parent_id": root_span_id,
-            "span_name": "Reasoning",
-            "span_workflow_name": workflow_name,
-            "span_path": "reasoning",
-            "provider_id": "",
-            "metadata": {"reasoning_tokens": reasoning_tokens} if reasoning_tokens > 0 else {},
-            "input": "",
-            "output": f"[Reasoning: {reasoning_tokens} tokens]" if reasoning_tokens > 0 else "[Reasoning]",
-            "timestamp": end_time_str,
-            "start_time": start_time_str,
-        })
-
-    # ------------------------------------------------------------------
-    # Tool child spans
-    # ------------------------------------------------------------------
-    # Build output lookup by call_id
-    output_map: Dict[str, Dict[str, Any]] = {}
-    for to in tool_outputs:
-        call_id = to.get("call_id", "")
-        if call_id:
-            output_map[call_id] = to
-
-    tool_num = 0
-    for tc in tool_calls:
-        tool_num += 1
-        tool_name = tc.get("name", "unknown")
-        call_id = tc.get("call_id", "")
-        arguments = tc.get("arguments", "")
-        tool_ts = tc.get("timestamp", start_time_str)
-
-        # Map Codex tool names to friendly display names
-        display_name = _tool_display_name(tool_name)
-
-        # Format input
-        tool_input = _format_tool_input(tool_name, arguments)
-
-        # Format output
-        tool_output_data = output_map.get(call_id, {})
-        tool_output = _format_tool_output(tool_output_data.get("output", ""))
-        tool_end = tool_output_data.get("timestamp", end_time_str)
-
-        # Calculate tool latency
-        tool_latency = None
-        tool_start_dt = parse_timestamp(tool_ts)
-        tool_end_dt = parse_timestamp(tool_end)
-        if tool_start_dt and tool_end_dt:
-            tool_latency = (tool_end_dt - tool_start_dt).total_seconds()
-
-        tool_span: Dict[str, Any] = {
-            "trace_unique_id": trace_unique_id,
-            "span_unique_id": f"codexcli_{trace_unique_id}_tool_{tool_num}",
-            "span_parent_id": root_span_id,
-            "span_name": f"Tool: {display_name}",
-            "span_workflow_name": workflow_name,
-            "span_path": f"tool_{tool_name.lower()}",
-            "provider_id": "",
-            "metadata": {},
-            "input": tool_input,
-            "output": tool_output,
-            "timestamp": tool_end,
-            "start_time": tool_ts,
-        }
-        if tool_latency is not None:
-            tool_span["latency"] = tool_latency
-        spans.append(tool_span)
-
-    # Add required Respan platform fields to every span.
-    respan_defaults = {
-        "warnings": "",
-        "encoding_format": "float",
-        "disable_fallback": False,
-        "respan_params": {
-            "has_webhook": False,
-            "environment": os.environ.get("RESPAN_ENVIRONMENT", "prod"),
-        },
-        "field_name": "data: ",
-        "delimiter": "\n\n",
-        "disable_log": False,
-        "request_breakdown": False,
-    }
-    for span in spans:
-        for key, value in respan_defaults.items():
-            if key not in span:
-                span[key] = value
-
-    return spans
-
-
-def _tool_display_name(name: str) -> str:
-    """Map Codex CLI tool names to display names."""
-    mapping = {
-        "exec_command": "Shell",
-        "apply_patch": "File Edit",
-        "web_search": "Web Search",
-    }
-    return mapping.get(name, name)
-
-
-def _format_tool_input(tool_name: str, arguments: str) -> str:
-    """Format tool input for display."""
-    if not arguments:
-        return ""
-    try:
-        args = json.loads(arguments) if isinstance(arguments, str) else arguments
-    except (json.JSONDecodeError, TypeError):
-        return truncate(str(arguments))
-
-    if tool_name == "exec_command" and isinstance(args, dict):
-        cmd = args.get("cmd", "")
-        workdir = args.get("workdir", "")
-        result = f"Command: {cmd}"
-        if workdir:
-            result = f"[{workdir}] {result}"
-        return truncate(result)
-
-    if tool_name == "apply_patch" and isinstance(arguments, str):
-        return truncate(arguments)
-
-    if isinstance(args, dict):
-        try:
-            return truncate(json.dumps(args, indent=2))
-        except (TypeError, ValueError):
-            pass
-
-    return truncate(str(arguments))
-
-
-def _format_tool_output(output: str) -> str:
-    """Format tool output for display."""
-    if not output:
-        return ""
-    # Try to parse JSON output (custom_tool_call_output wraps in JSON)
-    try:
-        parsed = json.loads(output)
-        if isinstance(parsed, dict) and "output" in parsed:
-            return truncate(parsed["output"])
-    except (json.JSONDecodeError, TypeError):
-        pass
-    return truncate(output)
-
-
-def send_spans(
-    spans: List[Dict[str, Any]],
-    api_key: str,
-    base_url: str,
-    turn_num: int,
-) -> None:
-    """Send spans to Respan as a single batch."""
-    url = f"{base_url}/v1/traces/ingest"
-    headers = {"Authorization": f"Bearer {api_key}"}
-
-    span_names = [s.get("span_name", "?") for s in spans]
-    payload_json = json.dumps(spans)
-    payload_size = len(payload_json)
-    debug(f"Sending {len(spans)} spans ({payload_size} bytes) for turn {turn_num}: {span_names}")
-    if DEBUG:
-        debug_file = LOG_FILE.parent / f"respan_codex_spans_turn_{turn_num}.json"
-        debug_file.write_text(payload_json, encoding="utf-8")
-        debug(f"Dumped spans to {debug_file}")
-
-    for attempt in range(3):
-        try:
-            response = requests.post(url, json=spans, headers=headers, timeout=30)
-            if response.status_code < 400:
-                resp_text = response.text[:300] if response.text else ""
-                debug(f"Sent {len(spans)} spans for turn {turn_num} "
-                      f"(attempt {attempt + 1}): {resp_text}")
-                return
-            if response.status_code < 500:
-                log("ERROR", f"Spans rejected for turn {turn_num}: "
-                    f"HTTP {response.status_code} - {response.text[:200]}")
-                return
-            debug(f"Server error for turn {turn_num} "
-                  f"(attempt {attempt + 1}), retrying...")
-            time.sleep(1.0)
-        except (requests.exceptions.Timeout, requests.exceptions.ConnectionError):
-            time.sleep(1.0)
-        except Exception as e:
-            log("ERROR", f"Failed to send spans for turn {turn_num}: {e}")
-            return
-
-    log("ERROR", f"Failed to send {len(spans)} spans for turn {turn_num} after 3 attempts")
-
-
-def process_session(
-    session_id: str,
-    session_file: Path,
-    state: Dict[str, Any],
-    api_key: str,
-    base_url: str,
-    config: Optional[Dict[str, Any]] = None,
-) -> int:
-    """Process a session JSONL file and create traces for new turns."""
-    session_state = state.get(session_id, {})
-    last_turn_count = session_state.get("turn_count", 0)
-
-    # Read and parse the full session file
-    lines = session_file.read_text(encoding="utf-8").strip().split("\n")
-    events = parse_session(lines)
-
-    if not events:
-        debug("No events in session file")
-        return 0
-
-    # Extract all turns from the session
-    all_turns = extract_turns(events)
-    total_turns = len(all_turns)
-
-    if total_turns <= last_turn_count:
-        debug(f"No new turns (total: {total_turns}, processed: {last_turn_count})")
-        return 0
-
-    # Process only new turns
-    new_turns = all_turns[last_turn_count:]
-    turns_processed = 0
-
-    for turn in new_turns:
-        turns_processed += 1
-        turn_num = last_turn_count + turns_processed
-        spans = create_respan_spans(session_id, turn_num, turn, config=config)
-        send_spans(spans, api_key, base_url, turn_num)
-
-    # Update state
-    state[session_id] = {
-        "turn_count": last_turn_count + turns_processed,
-        "updated": datetime.now(timezone.utc).isoformat(),
-    }
-    save_state(state)
-
-    return turns_processed
-
-
-def resolve_credentials() -> Tuple[Optional[str], str]:
-    """Resolve API key and base URL from env vars or credentials file.
-
-    Returns (api_key, base_url).
-    """
-    api_key = os.getenv("RESPAN_API_KEY")
-    base_url = os.getenv("RESPAN_BASE_URL", "https://api.respan.ai/api")
-
-    if not api_key:
-        creds_file = Path.home() / ".respan" / "credentials.json"
-        if creds_file.exists():
-            try:
-                creds = json.loads(creds_file.read_text(encoding="utf-8"))
-                config_file = Path.home() / ".respan" / "config.json"
-                profile = "default"
-                if config_file.exists():
-                    cfg = json.loads(config_file.read_text(encoding="utf-8"))
-                    profile = cfg.get("activeProfile", "default")
-                cred = creds.get(profile, {})
-                api_key = cred.get("apiKey") or cred.get("accessToken")
-                if not base_url or base_url == "https://api.respan.ai/api":
-                    base_url = cred.get("baseUrl", base_url)
-                if base_url and not base_url.rstrip("/").endswith("/api"):
-                    base_url = base_url.rstrip("/") + "/api"
-                if api_key:
-                    debug(f"Using API key from credentials.json (profile: {profile})")
-            except (json.JSONDecodeError, IOError) as e:
-                debug(f"Failed to read credentials.json: {e}")
-
-    return api_key, base_url
-
-
-def main():
-    script_start = datetime.now()
-    debug("Codex hook started")
-
-    # Parse notify payload from sys.argv[1]
-    if len(sys.argv) < 2:
-        debug("No argument provided (expected JSON payload in sys.argv[1])")
-        sys.exit(0)
-
-    try:
-        payload = json.loads(sys.argv[1])
-    except (json.JSONDecodeError, TypeError) as e:
-        debug(f"Invalid JSON in sys.argv[1]: {e}")
-        sys.exit(0)
-
-    # Only process agent-turn-complete events
-    event_type = payload.get("type", "")
-    if event_type != "agent-turn-complete":
-        debug(f"Ignoring event type: {event_type}")
-        sys.exit(0)
-
-    # Extract session info from the payload
-    session_id = payload.get("thread-id", "")
-    if not session_id:
-        debug("No thread-id in notify payload")
-        sys.exit(0)
-
-    debug(f"Processing notify: type={event_type}, session={session_id}")
-
-    # Resolve credentials
-    api_key, base_url = resolve_credentials()
-    if not api_key:
-        log("ERROR", "No API key found. Run: respan auth login")
-        sys.exit(0)
-
-    # Find the session file
-    session_file = find_session_file(session_id)
-    if not session_file:
-        # Fall back to latest session file
-        result = find_latest_session_file()
-        if result:
-            session_id, session_file = result
-        else:
-            debug("No session file found")
-            sys.exit(0)
-
-    # Load respan.json config from the project directory
-    config: Dict[str, Any] = {"fields": {}, "properties": {}}
-    cwd = payload.get("cwd", "")
-    if cwd:
-        config = load_respan_config(cwd)
-        debug(f"Loaded respan.json config from {cwd}: {config}")
-
-    # Process the session with retry logic
-    max_attempts = 3
-    turns = 0
-    try:
-        for attempt in range(max_attempts):
-            with state_lock():
-                state = load_state()
-                turns = process_session(
-                    session_id, session_file, state, api_key, base_url, config=config
-                )
-
-            if turns > 0:
-                break
-
-            if attempt < max_attempts - 1:
-                delay = 0.5 * (attempt + 1)
-                debug(f"No turns processed (attempt {attempt + 1}/{max_attempts}), "
-                      f"retrying in {delay}s...")
-                time.sleep(delay)
-
-        duration = (datetime.now() - script_start).total_seconds()
-        log("INFO", f"Processed {turns} turns in {duration:.1f}s")
-
-        if duration > 180:
-            log("WARN", f"Hook took {duration:.1f}s (>3min), consider optimizing")
-
-    except Exception as e:
-        log("ERROR", f"Failed to process session: {e}")
-        import traceback
-        debug(traceback.format_exc())
-
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()