oh-langfuse 0.1.53 → 0.1.55

package/langfuse_hook.py

@@ -4,58 +4,58 @@ Claude Code -> Langfuse hook
 
 """
 
-import json
-import os
-import re
-import sys
-import time
-import hashlib
-from dataclasses import dataclass, field
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
-from urllib.parse import urlparse
-
-
-def configure_langfuse_no_proxy() -> None:
-    hosts = ["localhost", "127.0.0.1"]
-    for key in ("LANGFUSE_HOST", "LANGFUSE_BASEURL", "CC_LANGFUSE_BASE_URL"):
-        value = os.environ.get(key)
-        if not value:
-            continue
-        parsed = urlparse(value if "://" in value else f"http://{value}")
-        if parsed.hostname:
-            hosts.append(parsed.hostname)
-        if parsed.netloc:
-            hosts.append(parsed.netloc)
-    existing = []
-    for key in ("NO_PROXY", "no_proxy"):
-        existing.extend([item.strip() for item in os.environ.get(key, "").split(",") if item.strip()])
-    merged = []
-    for item in [*existing, *hosts]:
-        if item and item not in merged:
-            merged.append(item)
-    if merged:
-        value = ",".join(merged)
-        os.environ["NO_PROXY"] = value
-        os.environ["no_proxy"] = value
-
-
-configure_langfuse_no_proxy()
-
-# --- Langfuse import (fail-open) ---
-try:
-    from langfuse import Langfuse, propagate_attributes
-except Exception as e:
-    try:
-        state_dir = Path.home() / ".claude" / "state"
-        state_dir.mkdir(parents=True, exist_ok=True)
-        with open(state_dir / "langfuse_hook.log", "a", encoding="utf-8") as f:
-            ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            f.write(f"{ts} [ERROR] Failed to import langfuse package: {e}\n")
-    except Exception:
-        pass
-    sys.exit(0)
+import json
+import os
+import re
+import sys
+import time
+import hashlib
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+from urllib.parse import urlparse
+
+
+def configure_langfuse_no_proxy() -> None:
+    hosts = ["localhost", "127.0.0.1"]
+    for key in ("LANGFUSE_HOST", "LANGFUSE_BASEURL", "CC_LANGFUSE_BASE_URL"):
+        value = os.environ.get(key)
+        if not value:
+            continue
+        parsed = urlparse(value if "://" in value else f"http://{value}")
+        if parsed.hostname:
+            hosts.append(parsed.hostname)
+        if parsed.netloc:
+            hosts.append(parsed.netloc)
+    existing = []
+    for key in ("NO_PROXY", "no_proxy"):
+        existing.extend([item.strip() for item in os.environ.get(key, "").split(",") if item.strip()])
+    merged = []
+    for item in [*existing, *hosts]:
+        if item and item not in merged:
+            merged.append(item)
+    if merged:
+        value = ",".join(merged)
+        os.environ["NO_PROXY"] = value
+        os.environ["no_proxy"] = value
+
+
+configure_langfuse_no_proxy()
+
+# --- Langfuse import (fail-open) ---
+try:
+    from langfuse import Langfuse, propagate_attributes
+except Exception as e:
+    try:
+        state_dir = Path.home() / ".claude" / "state"
+        state_dir.mkdir(parents=True, exist_ok=True)
+        with open(state_dir / "langfuse_hook.log", "a", encoding="utf-8") as f:
+            ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            f.write(f"{ts} [ERROR] Failed to import langfuse package: {e}\n")
+    except Exception:
+        pass
+    sys.exit(0)
 
 # --- Paths ---
 STATE_DIR = Path.home() / ".claude" / "state"
@@ -63,10 +63,10 @@ LOG_FILE = STATE_DIR / "langfuse_hook.log"
 STATE_FILE = STATE_DIR / "langfuse_state.json"
 LOCK_FILE = STATE_DIR / "langfuse_state.lock"
 
-DEBUG = os.environ.get("CC_LANGFUSE_DEBUG", "").lower() == "true"
-MAX_CHARS = int(os.environ.get("CC_LANGFUSE_MAX_CHARS", "20000"))
-METRICS_SCHEMA_VERSION = "1.1"
-AGENT_NAME = "claude"
+DEBUG = os.environ.get("CC_LANGFUSE_DEBUG", "").lower() == "true"
+MAX_CHARS = int(os.environ.get("CC_LANGFUSE_MAX_CHARS", "20000"))
+METRICS_SCHEMA_VERSION = "1.1"
+AGENT_NAME = "claude"
 
 # ----------------- Logging -----------------
 def _log(level: str, message: str) -> None:
@@ -268,349 +268,349 @@ def extract_text(content: Any) -> str:
         return "\n".join([p for p in parts if p])
     return ""
 
-def truncate_text(s: str, max_chars: int = MAX_CHARS) -> Tuple[str, Dict[str, Any]]:
+def truncate_text(s: str, max_chars: int = MAX_CHARS) -> Tuple[str, Dict[str, Any]]:
     if s is None:
         return "", {"truncated": False, "orig_len": 0}
     orig_len = len(s)
     if orig_len <= max_chars:
         return s, {"truncated": False, "orig_len": orig_len}
-    head = s[:max_chars]
-    return head, {"truncated": True, "orig_len": orig_len, "kept_len": len(head), "sha256": hashlib.sha256(s.encode("utf-8")).hexdigest()}
-
-def build_interaction_id(source: str, session_id: str, turn_number: int) -> str:
-    return f"{source or 'unknown'}:{session_id or 'unknown'}:{int(turn_number or 0)}"
-
-def _num_or_none(value: Any) -> Optional[int]:
-    if isinstance(value, bool):
-        return None
-    if isinstance(value, int) and value >= 0:
-        return value
-    if isinstance(value, float) and value >= 0:
-        return int(value)
-    if isinstance(value, str):
-        try:
-            n = int(value)
-            return n if n >= 0 else None
-        except Exception:
-            return None
-    return None
-
-def _first_num(raw: Dict[str, Any], *keys: str) -> Optional[int]:
-    for key in keys:
-        if key in raw:
-            value = _num_or_none(raw.get(key))
-            if value is not None:
-                return value
-    return None
-
-def normalize_token_metrics(raw: Optional[Dict[str, Any]]) -> Dict[str, Any]:
-    if not isinstance(raw, dict) or not raw:
-        return {
-            "token_metrics_available": False,
-            "input_tokens": None,
-            "output_tokens": None,
-            "total_tokens": None,
-            "cache_read_tokens": None,
-            "reasoning_tokens": None,
-        }
-    input_tokens = _first_num(raw, "input", "input_tokens", "inputTokens")
-    output_tokens = _first_num(raw, "output", "output_tokens", "outputTokens")
-    total_tokens = _first_num(raw, "total", "total_tokens", "totalTokens")
-    if total_tokens is None and input_tokens is not None and output_tokens is not None:
-        total_tokens = input_tokens + output_tokens
-    cache_read_tokens = _first_num(raw, "cache_read_tokens", "cachedInputTokens", "cacheRead")
-    reasoning_tokens = _first_num(raw, "reasoning_tokens", "reasoningTokens", "reasoning")
-    available = any(v is not None for v in [input_tokens, output_tokens, total_tokens, cache_read_tokens, reasoning_tokens])
-    return {
-        "token_metrics_available": available,
-        "input_tokens": input_tokens if available else None,
-        "output_tokens": output_tokens if available else None,
-        "total_tokens": total_tokens if available else None,
-        "cache_read_tokens": cache_read_tokens if available else None,
-        "reasoning_tokens": reasoning_tokens if available else None,
-    }
-
-def _ratio(numerator: Optional[int], denominator: Optional[int]) -> Optional[float]:
-    if numerator is None or denominator in (None, 0):
-        return None
-    return numerator / denominator
-
-def build_interaction_metadata(
-    source: str,
-    user_id: Optional[str],
-    session_id: str,
-    turn_number: int,
-    token_metrics: Optional[Dict[str, Any]],
-    tool_call_count: int,
-    tool_result_count: int,
-    skill_use_count: int,
-    model: Optional[str],
-    user_message_count: int = 1,
-    assistant_message_count: int = 1,
-    skill_use_events: Optional[List[Dict[str, Any]]] = None,
-) -> Dict[str, Any]:
-    tokens = normalize_token_metrics(token_metrics)
-    interaction_id = build_interaction_id(source, session_id, turn_number)
-    events = list(skill_use_events or [])
-    skill_names_all = [str(event.get("skill_name") or "") for event in events if event.get("skill_name")]
-    unique_skill_names = list(dict.fromkeys(skill_names_all))
-    skill_invocation_modes = [str(event.get("skill_invocation_mode") or "") for event in events if event.get("skill_invocation_mode")]
-    skill_agent_paths = [str(event.get("skill_agent_path") or "") for event in events if event.get("skill_agent_path")]
-    effective_skill_count = len(events) if events else int(skill_use_count or 0)
-    return {
-        "source": source,
-        "agent": source,
-        "user_id": user_id or "",
-        "session_id": session_id,
-        "interaction_id": interaction_id,
-        "metrics_schema_version": METRICS_SCHEMA_VERSION,
-        "interaction_count": 1,
-        "user_message_count": user_message_count,
-        "assistant_message_count": assistant_message_count,
-        "tool_call_count": int(tool_call_count or 0),
-        "tool_result_count": int(tool_result_count or 0),
-        "skill_use_count": effective_skill_count,
-        "unique_skill_count": len(unique_skill_names),
-        "repeated_skill_count": max(0, effective_skill_count - len(unique_skill_names)),
-        **tokens,
-        "model": model,
-        "turn_number": int(turn_number or 0),
-        "efficiency": {
-            "tokens_per_interaction": tokens.get("total_tokens"),
-            "tool_calls_per_interaction": int(tool_call_count or 0),
-            "skills_per_interaction": effective_skill_count,
-            "output_input_token_ratio": _ratio(tokens.get("output_tokens"), tokens.get("input_tokens")),
-            "tokens_per_tool_call": _ratio(tokens.get("total_tokens"), int(tool_call_count or 0)),
-        },
-        **({
-            "skill_names": unique_skill_names,
-            "skill_names_all": skill_names_all,
-            "skill_invocation_modes": skill_invocation_modes,
-            "skill_agent_paths": skill_agent_paths,
-        } if events else {}),
-    }
-
-def discover_known_skills(extra_roots: Optional[List[Path]] = None) -> set:
-    roots = [
-        Path.home() / ".codex" / "skills",
-        Path.home() / ".claude" / "skills",
-        Path.home() / ".config" / "opencode" / "skill",
-    ]
-    if extra_roots:
-        roots.extend(extra_roots)
-    names = set()
-    for root in roots:
-        try:
-            if not root.exists():
-                continue
-            for skill_file in root.rglob("SKILL.md"):
-                names.add(skill_file.parent.name)
-        except Exception:
-            continue
-    return names
-
-def _skill_namespace(name: str) -> str:
-    return name.split(":", 1)[0] if ":" in name else ""
-
-def _skill_agent_from_interaction_id(interaction_id: str) -> str:
-    return str(interaction_id or "unknown").split(":", 1)[0] or "unknown"
-
-def _skill_agent_path(agent: str, detected_by: str) -> str:
-    if agent == "claude":
-        if detected_by == "tool_call":
-            return "claude_skill_tool"
-        if detected_by == "slash_command":
-            return "claude_slash_skill"
-        if detected_by == "attribution_skill":
-            return "claude_attribution_skill"
-    if detected_by == "skill_file_path":
-        return "skill_file_path"
-    return detected_by or "metadata"
-
-def _skill_invocation_mode(agent: str, detected_by: str) -> str:
-    if detected_by in ("slash_command", "attribution_skill"):
-        return "explicit"
-    if detected_by in ("tool_call", "plugin_event"):
-        return "implicit"
-    return "detected"
-
-def _skill_event_type(detected_by: str, agent: str = "unknown") -> str:
-    return "invoked" if detected_by in ("tool_call", "plugin_event", "attribution_skill", "slash_command") else "detected"
-
-def _skill_id_segment(name: str) -> str:
-    segment = re.sub(r"[^A-Za-z0-9_.:-]+", "-", str(name or "").strip()).strip("-")
-    return (segment or "unknown")[:96]
-
-def detect_skill_usages(tool_calls: List[Dict[str, Any]], known_skills: set) -> List[Dict[str, str]]:
-    found: List[Dict[str, str]] = []
-    seen_call_ids: set = set()
-    for call in tool_calls or []:
-        tool_name = str(call.get("name") or "")
-        call_id = str(call.get("id") or call.get("call_id") or call.get("callId") or call.get("tool_call_id") or call.get("toolCallId") or "").strip()
-        input_obj = call.get("input") if isinstance(call.get("input"), (dict, list, str)) else {}
-        if tool_name.lower() == "skill" and isinstance(input_obj, dict):
-            for key in ("skill_name", "skill", "name"):
-                value = input_obj.get(key)
-                if isinstance(value, str) and value.strip():
-                    name = value.strip()
-                    if call_id:
-                        dedupe_key = f"call:{call_id}"
-                        if dedupe_key in seen_call_ids:
-                            break
-                        seen_call_ids.add(dedupe_key)
-                    found.append({"name": name, "skill_namespace": _skill_namespace(name), "detected_by": "tool_call", "skill_call_id": call_id})
-                    break
-        try:
-            text = json.dumps(input_obj, ensure_ascii=False)
-        except Exception:
-            text = str(input_obj)
-        for match in re.finditer(r"([A-Za-z]:)?[^\"'\n\r]*[\\/]+([^\\/\"'\n\r]+)[\\/]+SKILL\.md", text, re.IGNORECASE):
-            candidate = match.group(2)
-            if candidate and (candidate in known_skills or not known_skills):
-                found.append({"name": candidate, "skill_namespace": _skill_namespace(candidate), "detected_by": "skill_file_path"})
-    return found
-
-def _skill_usage(name: str, detected_by: str, skill_call_id: str = "") -> Dict[str, str]:
-    clean = str(name or "").strip().lstrip("/")
-    return {
-        "name": clean,
-        "skill_namespace": _skill_namespace(clean),
-        "detected_by": detected_by,
-        "skill_call_id": str(skill_call_id or "").strip(),
-    }
-
-def _accept_skill_candidate(name: Any, known_skills: set, trusted: bool = False) -> str:
-    clean = str(name or "").strip().lstrip("/")
-    if not clean:
-        return ""
-    if trusted or not known_skills or clean in known_skills:
-        return clean
-    return ""
-
-def _detect_skill_usages_from_text(text: str, known_skills: set) -> List[Dict[str, str]]:
-    found: List[Dict[str, str]] = []
-    if not text:
-        return found
-
-    for pattern in (
-        r"<command-name>\s*/?([^<\s]+)\s*</command-name>",
-        r"<command-message>\s*/?([^<\s]+)\s*</command-message>",
-    ):
-        for match in re.finditer(pattern, text, re.IGNORECASE):
-            name = _accept_skill_candidate(match.group(1), known_skills)
-            if name:
-                found.append(_skill_usage(name, "slash_command"))
-
-    for match in re.finditer(r"Base directory for this skill:\s*([^\r\n]+)", text, re.IGNORECASE):
-        path_text = match.group(1)
-        path_match = re.search(r"[\\/](?:skills|skill)[\\/]([^\\/\"\r\n]+)", path_text, re.IGNORECASE)
-        if path_match:
-            name = _accept_skill_candidate(path_match.group(1), known_skills)
-            if name:
-                found.append(_skill_usage(name, "skill_file_path"))
-
-    return found
-
-def _attribution_skill_from_row(row: Dict[str, Any]) -> str:
-    if not isinstance(row, dict):
-        return ""
-    value = row.get("attributionSkill") or row.get("attribution_skill")
-    if isinstance(value, str) and value.strip():
-        return value.strip()
-    message = row.get("message")
-    if isinstance(message, dict):
-        value = message.get("attributionSkill") or message.get("attribution_skill")
-        if isinstance(value, str) and value.strip():
-            return value.strip()
-    return ""
-
-def _dedupe_turn_skill_usages(usages: List[Dict[str, str]]) -> List[Dict[str, str]]:
-    out: List[Dict[str, str]] = []
-    seen_call_ids: set = set()
-    seen_detected_names: set = set()
-    for usage in usages or []:
-        name = str(usage.get("name") or "").strip()
-        if not name:
-            continue
-        call_id = str(usage.get("skill_call_id") or "").strip()
-        if call_id:
-            key = f"call:{call_id}"
-            if key in seen_call_ids:
-                continue
-            seen_call_ids.add(key)
-            out.append(usage)
-            continue
-
-        detected_by = str(usage.get("detected_by") or "")
-        if detected_by in ("attribution_skill", "slash_command", "skill_file_path"):
-            key = f"name:{name}"
-            if key in seen_detected_names:
-                continue
-            seen_detected_names.add(key)
-        out.append(usage)
-    return out
-
-def detect_turn_skill_usages(turn: "Turn", tool_calls: List[Dict[str, Any]], known_skills: set) -> List[Dict[str, str]]:
-    found = list(detect_skill_usages(tool_calls, known_skills))
-    rows = [turn.user_msg, *getattr(turn, "context_msgs", []), *turn.assistant_msgs]
-
-    for row in rows:
-        attributed = _accept_skill_candidate(_attribution_skill_from_row(row), known_skills, trusted=True)
-        if attributed:
-            found.append(_skill_usage(attributed, "attribution_skill"))
-        found.extend(_detect_skill_usages_from_text(extract_text(get_content(row)), known_skills))
-
-    return _dedupe_turn_skill_usages(found)
-
-def build_skill_use_events(interaction_id: str, skill_usages: List[Dict[str, str]]) -> List[Dict[str, Any]]:
-    events: List[Dict[str, Any]] = []
-    deduped: List[Dict[str, str]] = []
-    seen_call_ids: set = set()
-    agent = _skill_agent_from_interaction_id(interaction_id)
-    for skill in skill_usages or []:
-        call_id = str(skill.get("skill_call_id") or "").strip()
-        if call_id:
-            dedupe_key = f"call:{call_id}"
-            if dedupe_key in seen_call_ids:
-                continue
-            seen_call_ids.add(dedupe_key)
-        deduped.append(skill)
-    total = len(deduped)
-    for index, skill in enumerate(deduped, start=1):
-        name = str(skill.get("name") or "").strip()
-        if not name:
-            continue
-        detected_by = str(skill.get("detected_by") or "metadata")
-        call_id = str(skill.get("skill_call_id") or "").strip()
-        invocation_mode = _skill_invocation_mode(agent, detected_by)
-        events.append({
-            "skill_use_id": f"{interaction_id}:skill:{index}:{_skill_id_segment(name)}",
-            "skill_use_index": index,
-            "skill_use_count_in_interaction": total,
-            "skill_event_type": _skill_event_type(detected_by, agent),
-            "skill_trigger": invocation_mode,
-            "skill_invocation_mode": invocation_mode,
-            "skill_agent_path": _skill_agent_path(agent, detected_by),
-            "skill_name": name,
-            "skill_use_count": 1,
-            "skill_namespace": skill.get("skill_namespace") or _skill_namespace(name),
-            "detected_by": detected_by,
-            **({"skill_call_id": call_id} if call_id else {}),
-        })
-    return events
-
-def summarize_skill_usages(skill_usages: List[Dict[str, str]]) -> List[Dict[str, Any]]:
-    summary: Dict[str, Dict[str, Any]] = {}
-    for item in skill_usages or []:
-        name = item.get("name")
-        if not name:
-            continue
-        entry = summary.setdefault(name, {"name": name, "count": 0, "detected_by": item.get("detected_by")})
-        entry["count"] += 1
-        detected_by = str(item.get("detected_by") or "metadata")
-        entry.setdefault("skill_invocation_mode", _skill_invocation_mode("claude", detected_by))
-        entry.setdefault("skill_agent_path", _skill_agent_path("claude", detected_by))
-    return list(summary.values())
+    head = s[:max_chars]
+    return head, {"truncated": True, "orig_len": orig_len, "kept_len": len(head), "sha256": hashlib.sha256(s.encode("utf-8")).hexdigest()}
+
+def build_interaction_id(source: str, session_id: str, turn_number: int) -> str:
+    return f"{source or 'unknown'}:{session_id or 'unknown'}:{int(turn_number or 0)}"
+
+def _num_or_none(value: Any) -> Optional[int]:
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, int) and value >= 0:
+        return value
+    if isinstance(value, float) and value >= 0:
+        return int(value)
+    if isinstance(value, str):
+        try:
+            n = int(value)
+            return n if n >= 0 else None
+        except Exception:
+            return None
+    return None
+
+def _first_num(raw: Dict[str, Any], *keys: str) -> Optional[int]:
+    for key in keys:
+        if key in raw:
+            value = _num_or_none(raw.get(key))
+            if value is not None:
+                return value
+    return None
+
+def normalize_token_metrics(raw: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+    if not isinstance(raw, dict) or not raw:
+        return {
+            "token_metrics_available": False,
+            "input_tokens": None,
+            "output_tokens": None,
+            "total_tokens": None,
+            "cache_read_tokens": None,
+            "reasoning_tokens": None,
+        }
+    input_tokens = _first_num(raw, "input", "input_tokens", "inputTokens")
+    output_tokens = _first_num(raw, "output", "output_tokens", "outputTokens")
+    total_tokens = _first_num(raw, "total", "total_tokens", "totalTokens")
+    if total_tokens is None and input_tokens is not None and output_tokens is not None:
+        total_tokens = input_tokens + output_tokens
+    cache_read_tokens = _first_num(raw, "cache_read_tokens", "cachedInputTokens", "cacheRead")
+    reasoning_tokens = _first_num(raw, "reasoning_tokens", "reasoningTokens", "reasoning")
+    available = any(v is not None for v in [input_tokens, output_tokens, total_tokens, cache_read_tokens, reasoning_tokens])
+    return {
+        "token_metrics_available": available,
+        "input_tokens": input_tokens if available else None,
+        "output_tokens": output_tokens if available else None,
+        "total_tokens": total_tokens if available else None,
+        "cache_read_tokens": cache_read_tokens if available else None,
+        "reasoning_tokens": reasoning_tokens if available else None,
+    }
+
+def _ratio(numerator: Optional[int], denominator: Optional[int]) -> Optional[float]:
+    if numerator is None or denominator in (None, 0):
+        return None
+    return numerator / denominator
+
+def build_interaction_metadata(
+    source: str,
+    user_id: Optional[str],
+    session_id: str,
+    turn_number: int,
+    token_metrics: Optional[Dict[str, Any]],
+    tool_call_count: int,
+    tool_result_count: int,
+    skill_use_count: int,
+    model: Optional[str],
+    user_message_count: int = 1,
+    assistant_message_count: int = 1,
+    skill_use_events: Optional[List[Dict[str, Any]]] = None,
+) -> Dict[str, Any]:
+    tokens = normalize_token_metrics(token_metrics)
+    interaction_id = build_interaction_id(source, session_id, turn_number)
+    events = list(skill_use_events or [])
+    skill_names_all = [str(event.get("skill_name") or "") for event in events if event.get("skill_name")]
+    unique_skill_names = list(dict.fromkeys(skill_names_all))
+    skill_invocation_modes = [str(event.get("skill_invocation_mode") or "") for event in events if event.get("skill_invocation_mode")]
+    skill_agent_paths = [str(event.get("skill_agent_path") or "") for event in events if event.get("skill_agent_path")]
+    effective_skill_count = len(events) if events else int(skill_use_count or 0)
+    return {
+        "source": source,
+        "agent": source,
+        "user_id": user_id or "",
+        "session_id": session_id,
+        "interaction_id": interaction_id,
+        "metrics_schema_version": METRICS_SCHEMA_VERSION,
+        "interaction_count": 1,
+        "user_message_count": user_message_count,
+        "assistant_message_count": assistant_message_count,
+        "tool_call_count": int(tool_call_count or 0),
+        "tool_result_count": int(tool_result_count or 0),
+        "skill_use_count": effective_skill_count,
+        "unique_skill_count": len(unique_skill_names),
+        "repeated_skill_count": max(0, effective_skill_count - len(unique_skill_names)),
+        **tokens,
+        "model": model,
+        "turn_number": int(turn_number or 0),
+        "efficiency": {
+            "tokens_per_interaction": tokens.get("total_tokens"),
+            "tool_calls_per_interaction": int(tool_call_count or 0),
+            "skills_per_interaction": effective_skill_count,
+            "output_input_token_ratio": _ratio(tokens.get("output_tokens"), tokens.get("input_tokens")),
+            "tokens_per_tool_call": _ratio(tokens.get("total_tokens"), int(tool_call_count or 0)),
+        },
+        **({
+            "skill_names": unique_skill_names,
+            "skill_names_all": skill_names_all,
+            "skill_invocation_modes": skill_invocation_modes,
+            "skill_agent_paths": skill_agent_paths,
+        } if events else {}),
+    }
+
+def discover_known_skills(extra_roots: Optional[List[Path]] = None) -> set:
+    roots = [
+        Path.home() / ".codex" / "skills",
+        Path.home() / ".claude" / "skills",
+        Path.home() / ".config" / "opencode" / "skill",
+    ]
+    if extra_roots:
+        roots.extend(extra_roots)
+    names = set()
+    for root in roots:
+        try:
+            if not root.exists():
+                continue
+            for skill_file in root.rglob("SKILL.md"):
+                names.add(skill_file.parent.name)
+        except Exception:
+            continue
+    return names
+
+def _skill_namespace(name: str) -> str:
+    return name.split(":", 1)[0] if ":" in name else ""
+
+def _skill_agent_from_interaction_id(interaction_id: str) -> str:
+    return str(interaction_id or "unknown").split(":", 1)[0] or "unknown"
+
+def _skill_agent_path(agent: str, detected_by: str) -> str:
+    if agent == "claude":
+        if detected_by == "tool_call":
+            return "claude_skill_tool"
+        if detected_by == "slash_command":
+            return "claude_slash_skill"
+        if detected_by == "attribution_skill":
+            return "claude_attribution_skill"
+    if detected_by == "skill_file_path":
+        return "skill_file_path"
+    return detected_by or "metadata"
+
+def _skill_invocation_mode(agent: str, detected_by: str) -> str:
+    if detected_by in ("slash_command", "attribution_skill"):
+        return "explicit"
+    if detected_by in ("tool_call", "plugin_event"):
+        return "implicit"
+    return "detected"
+
+def _skill_event_type(detected_by: str, agent: str = "unknown") -> str:
+    return "invoked" if detected_by in ("tool_call", "plugin_event", "attribution_skill", "slash_command") else "detected"
+
+def _skill_id_segment(name: str) -> str:
+    segment = re.sub(r"[^A-Za-z0-9_.:-]+", "-", str(name or "").strip()).strip("-")
+    return (segment or "unknown")[:96]
+
+def detect_skill_usages(tool_calls: List[Dict[str, Any]], known_skills: set) -> List[Dict[str, str]]:
+    found: List[Dict[str, str]] = []
+    seen_call_ids: set = set()
+    for call in tool_calls or []:
+        tool_name = str(call.get("name") or "")
+        call_id = str(call.get("id") or call.get("call_id") or call.get("callId") or call.get("tool_call_id") or call.get("toolCallId") or "").strip()
+        input_obj = call.get("input") if isinstance(call.get("input"), (dict, list, str)) else {}
+        if tool_name.lower() == "skill" and isinstance(input_obj, dict):
+            for key in ("skill_name", "skill", "name"):
+                value = input_obj.get(key)
+                if isinstance(value, str) and value.strip():
+                    name = value.strip()
+                    if call_id:
+                        dedupe_key = f"call:{call_id}"
+                        if dedupe_key in seen_call_ids:
+                            break
+                        seen_call_ids.add(dedupe_key)
+                    found.append({"name": name, "skill_namespace": _skill_namespace(name), "detected_by": "tool_call", "skill_call_id": call_id})
+                    break
+        try:
+            text = json.dumps(input_obj, ensure_ascii=False)
+        except Exception:
+            text = str(input_obj)
+        for match in re.finditer(r"([A-Za-z]:)?[^\"'\n\r]*[\\/]+([^\\/\"'\n\r]+)[\\/]+SKILL\.md", text, re.IGNORECASE):
+            candidate = match.group(2)
+            if candidate and (candidate in known_skills or not known_skills):
+                found.append({"name": candidate, "skill_namespace": _skill_namespace(candidate), "detected_by": "skill_file_path"})
+    return found
+
+def _skill_usage(name: str, detected_by: str, skill_call_id: str = "") -> Dict[str, str]:
+    clean = str(name or "").strip().lstrip("/")
+    return {
+        "name": clean,
+        "skill_namespace": _skill_namespace(clean),
+        "detected_by": detected_by,
+        "skill_call_id": str(skill_call_id or "").strip(),
+    }
+
+def _accept_skill_candidate(name: Any, known_skills: set, trusted: bool = False) -> str:
+    clean = str(name or "").strip().lstrip("/")
+    if not clean:
+        return ""
+    if trusted or not known_skills or clean in known_skills:
+        return clean
+    return ""
+
+def _detect_skill_usages_from_text(text: str, known_skills: set) -> List[Dict[str, str]]:
+    found: List[Dict[str, str]] = []
+    if not text:
+        return found
+
+    for pattern in (
+        r"<command-name>\s*/?([^<\s]+)\s*</command-name>",
+        r"<command-message>\s*/?([^<\s]+)\s*</command-message>",
+    ):
+        for match in re.finditer(pattern, text, re.IGNORECASE):
+            name = _accept_skill_candidate(match.group(1), known_skills)
+            if name:
+                found.append(_skill_usage(name, "slash_command"))
+
+    for match in re.finditer(r"Base directory for this skill:\s*([^\r\n]+)", text, re.IGNORECASE):
+        path_text = match.group(1)
+        path_match = re.search(r"[\\/](?:skills|skill)[\\/]([^\\/\"\r\n]+)", path_text, re.IGNORECASE)
+        if path_match:
+            name = _accept_skill_candidate(path_match.group(1), known_skills)
+            if name:
+                found.append(_skill_usage(name, "skill_file_path"))
+
+    return found
+
+def _attribution_skill_from_row(row: Dict[str, Any]) -> str:
+    if not isinstance(row, dict):
+        return ""
+    value = row.get("attributionSkill") or row.get("attribution_skill")
+    if isinstance(value, str) and value.strip():
+        return value.strip()
+    message = row.get("message")
+    if isinstance(message, dict):
+        value = message.get("attributionSkill") or message.get("attribution_skill")
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    return ""
+
+def _dedupe_turn_skill_usages(usages: List[Dict[str, str]]) -> List[Dict[str, str]]:
+    out: List[Dict[str, str]] = []
+    seen_call_ids: set = set()
+    seen_detected_names: set = set()
+    for usage in usages or []:
+        name = str(usage.get("name") or "").strip()
+        if not name:
+            continue
+        call_id = str(usage.get("skill_call_id") or "").strip()
+        if call_id:
+            key = f"call:{call_id}"
+            if key in seen_call_ids:
+                continue
+            seen_call_ids.add(key)
+            out.append(usage)
+            continue
+
+        detected_by = str(usage.get("detected_by") or "")
+        if detected_by in ("attribution_skill", "slash_command", "skill_file_path"):
+            key = f"name:{name}"
+            if key in seen_detected_names:
+                continue
+            seen_detected_names.add(key)
+        out.append(usage)
+    return out
+
+def detect_turn_skill_usages(turn: "Turn", tool_calls: List[Dict[str, Any]], known_skills: set) -> List[Dict[str, str]]:
+    found = list(detect_skill_usages(tool_calls, known_skills))
+    rows = [turn.user_msg, *getattr(turn, "context_msgs", []), *turn.assistant_msgs]
+
+    for row in rows:
+        attributed = _accept_skill_candidate(_attribution_skill_from_row(row), known_skills, trusted=True)
+        if attributed:
+            found.append(_skill_usage(attributed, "attribution_skill"))
+        found.extend(_detect_skill_usages_from_text(extract_text(get_content(row)), known_skills))
+
+    return _dedupe_turn_skill_usages(found)
+
+def build_skill_use_events(interaction_id: str, skill_usages: List[Dict[str, str]]) -> List[Dict[str, Any]]:
+    events: List[Dict[str, Any]] = []
+    deduped: List[Dict[str, str]] = []
+    seen_call_ids: set = set()
+    agent = _skill_agent_from_interaction_id(interaction_id)
+    for skill in skill_usages or []:
+        call_id = str(skill.get("skill_call_id") or "").strip()
+        if call_id:
+            dedupe_key = f"call:{call_id}"
+            if dedupe_key in seen_call_ids:
+                continue
+            seen_call_ids.add(dedupe_key)
+        deduped.append(skill)
+    total = len(deduped)
+    for index, skill in enumerate(deduped, start=1):
+        name = str(skill.get("name") or "").strip()
+        if not name:
+            continue
+        detected_by = str(skill.get("detected_by") or "metadata")
+        call_id = str(skill.get("skill_call_id") or "").strip()
+        invocation_mode = _skill_invocation_mode(agent, detected_by)
+        events.append({
+            "skill_use_id": f"{interaction_id}:skill:{index}:{_skill_id_segment(name)}",
+            "skill_use_index": index,
+            "skill_use_count_in_interaction": total,
+            "skill_event_type": _skill_event_type(detected_by, agent),
+            "skill_trigger": invocation_mode,
+            "skill_invocation_mode": invocation_mode,
+            "skill_agent_path": _skill_agent_path(agent, detected_by),
+            "skill_name": name,
+            "skill_use_count": 1,
+            "skill_namespace": skill.get("skill_namespace") or _skill_namespace(name),
+            "detected_by": detected_by,
+            **({"skill_call_id": call_id} if call_id else {}),
+        })
+    return events
+
+def summarize_skill_usages(skill_usages: List[Dict[str, str]]) -> List[Dict[str, Any]]:
+    summary: Dict[str, Dict[str, Any]] = {}
+    for item in skill_usages or []:
+        name = item.get("name")
+        if not name:
+            continue
+        entry = summary.setdefault(name, {"name": name, "count": 0, "detected_by": item.get("detected_by")})
+        entry["count"] += 1
+        detected_by = str(item.get("detected_by") or "metadata")
+        entry.setdefault("skill_invocation_mode", _skill_invocation_mode("claude", detected_by))
+        entry.setdefault("skill_agent_path", _skill_agent_path("claude", detected_by))
+    return list(summary.values())
 
 def get_model(msg: Dict[str, Any]) -> str:
     m = msg.get("message")
@@ -699,48 +699,48 @@ def read_new_jsonl(transcript_path: Path, ss: SessionState) -> Tuple[List[Dict[s
         text = chunk.decode(errors="replace")
 
     combined = ss.buffer + text
-    lines = combined.split("\n")
-    tail = lines[-1]
-    ss.offset = new_offset
-
-    msgs: List[Dict[str, Any]] = []
-    for line in lines[:-1]:
-        line = line.strip()
+    lines = combined.split("\n")
+    tail = lines[-1]
+    ss.offset = new_offset
+
+    msgs: List[Dict[str, Any]] = []
+    for line in lines[:-1]:
+        line = line.strip()
         if not line:
             continue
         try:
             msgs.append(json.loads(line))
-        except Exception:
-            continue
-
-    tail = tail.strip()
-    if tail:
-        try:
-            msgs.append(json.loads(tail))
-            ss.buffer = ""
-        except Exception:
-            # Keep a genuinely partial final line for the next hook run.
-            ss.buffer = tail
-    else:
-        ss.buffer = ""
-
-    return msgs, ss
+        except Exception:
+            continue
+
+    tail = tail.strip()
+    if tail:
+        try:
+            msgs.append(json.loads(tail))
+            ss.buffer = ""
+        except Exception:
+            # Keep a genuinely partial final line for the next hook run.
+            ss.buffer = tail
+    else:
+        ss.buffer = ""
+
+    return msgs, ss
 
 # ----------------- Turn assembly -----------------
-@dataclass
-class Turn:
-    user_msg: Dict[str, Any]
-    assistant_msgs: List[Dict[str, Any]]
-    tool_results_by_id: Dict[str, Any]
-    context_msgs: List[Dict[str, Any]] = field(default_factory=list)
-
-def is_skill_context_user_msg(msg: Dict[str, Any]) -> bool:
-    if get_role(msg) != "user" or is_tool_result(msg):
-        return False
-    text = extract_text(get_content(msg)).lstrip()
-    return text.startswith("Base directory for this skill:")
-
-def build_turns(messages: List[Dict[str, Any]]) -> List[Turn]:
+@dataclass
+class Turn:
+    user_msg: Dict[str, Any]
+    assistant_msgs: List[Dict[str, Any]]
+    tool_results_by_id: Dict[str, Any]
+    context_msgs: List[Dict[str, Any]] = field(default_factory=list)
+
+def is_skill_context_user_msg(msg: Dict[str, Any]) -> bool:
+    if get_role(msg) != "user" or is_tool_result(msg):
+        return False
+    text = extract_text(get_content(msg)).lstrip()
+    return text.startswith("Base directory for this skill:")
+
+def build_turns(messages: List[Dict[str, Any]]) -> List[Turn]:
     """
     Groups incremental transcript rows into turns:
     user (non-tool-result) -> assistant messages -> (tool_result rows, possibly interleaved)
@@ -755,50 +755,50 @@ def build_turns(messages: List[Dict[str, Any]]) -> List[Turn]:
     assistant_order: List[str] = []             # message ids in order of first appearance (or synthetic)
     assistant_latest: Dict[str, Dict[str, Any]] = {}  # id -> latest msg
 
-    tool_results_by_id: Dict[str, Any] = {}     # tool_use_id -> content
-    context_msgs: List[Dict[str, Any]] = []
-
-    def flush_turn():
-        nonlocal current_user, assistant_order, assistant_latest, tool_results_by_id, context_msgs, turns
-        if current_user is None:
-            return
-        if not assistant_latest:
-            return
-        assistants = [assistant_latest[mid] for mid in assistant_order if mid in assistant_latest]
-        turns.append(Turn(
-            user_msg=current_user,
-            assistant_msgs=assistants,
-            tool_results_by_id=dict(tool_results_by_id),
-            context_msgs=list(context_msgs),
-        ))
+    tool_results_by_id: Dict[str, Any] = {}     # tool_use_id -> content
+    context_msgs: List[Dict[str, Any]] = []
+
+    def flush_turn():
+        nonlocal current_user, assistant_order, assistant_latest, tool_results_by_id, context_msgs, turns
+        if current_user is None:
+            return
+        if not assistant_latest:
+            return
+        assistants = [assistant_latest[mid] for mid in assistant_order if mid in assistant_latest]
+        turns.append(Turn(
+            user_msg=current_user,
+            assistant_msgs=assistants,
+            tool_results_by_id=dict(tool_results_by_id),
+            context_msgs=list(context_msgs),
+        ))
 
     for msg in messages:
         role = get_role(msg)
 
         # tool_result rows show up as role=user with content blocks of type tool_result
-        if is_tool_result(msg):
-            for tr in iter_tool_results(get_content(msg)):
-                tid = tr.get("tool_use_id")
-                if tid:
-                    tool_results_by_id[str(tid)] = tr.get("content")
-            continue
-
-        if is_skill_context_user_msg(msg):
-            if current_user is not None:
-                context_msgs.append(msg)
-            continue
-
-        if role == "user":
-            # new user message -> finalize previous turn
-            flush_turn()
+        if is_tool_result(msg):
+            for tr in iter_tool_results(get_content(msg)):
+                tid = tr.get("tool_use_id")
+                if tid:
+                    tool_results_by_id[str(tid)] = tr.get("content")
+            continue
+
+        if is_skill_context_user_msg(msg):
+            if current_user is not None:
+                context_msgs.append(msg)
+            continue
+
+        if role == "user":
+            # new user message -> finalize previous turn
+            flush_turn()
 
             # start a new turn
             current_user = msg
-            assistant_order = []
-            assistant_latest = {}
-            tool_results_by_id = {}
-            context_msgs = []
-            continue
+            assistant_order = []
+            assistant_latest = {}
+            tool_results_by_id = {}
+            context_msgs = []
+            continue
 
         if role == "assistant":
             if current_user is None:
@@ -846,31 +846,31 @@ def emit_turn(
     assistant_text, assistant_text_meta = truncate_text(assistant_text_raw)
 
     model = get_model(turn.assistant_msgs[0])
-    usage_details = get_usage(last_assistant)
-
-    tool_calls = _tool_calls_from_assistants(turn.assistant_msgs)
-    skill_usages = detect_turn_skill_usages(turn, tool_calls, discover_known_skills())
-    interaction_id = build_interaction_id("claude", session_id, turn_num)
-    skill_use_events = build_skill_use_events(interaction_id, skill_usages)
-    interaction_meta = build_interaction_metadata(
-        "claude",
-        user_id,
-        session_id,
-        turn_num,
-        usage_details,
-        len(tool_calls),
-        len(turn.tool_results_by_id),
-        len(skill_use_events),
-        model,
-        user_message_count=1,
-        assistant_message_count=len(turn.assistant_msgs),
-        skill_use_events=skill_use_events,
-    )
-    skill_summary = summarize_skill_usages(skill_usages)
-
-    # attach tool outputs
-    for c in tool_calls:
-        if c["id"] and c["id"] in turn.tool_results_by_id:
+    usage_details = get_usage(last_assistant)
+
+    tool_calls = _tool_calls_from_assistants(turn.assistant_msgs)
+    skill_usages = detect_turn_skill_usages(turn, tool_calls, discover_known_skills())
+    interaction_id = build_interaction_id("claude", session_id, turn_num)
+    skill_use_events = build_skill_use_events(interaction_id, skill_usages)
+    interaction_meta = build_interaction_metadata(
+        "claude",
+        user_id,
+        session_id,
+        turn_num,
+        usage_details,
+        len(tool_calls),
+        len(turn.tool_results_by_id),
+        len(skill_use_events),
+        model,
+        user_message_count=1,
+        assistant_message_count=len(turn.assistant_msgs),
+        skill_use_events=skill_use_events,
+    )
+    skill_summary = summarize_skill_usages(skill_usages)
+
+    # attach tool outputs
+    for c in tool_calls:
+        if c["id"] and c["id"] in turn.tool_results_by_id:
             out_raw = turn.tool_results_by_id[c["id"]]
             out_str = out_raw if isinstance(out_raw, str) else json.dumps(out_raw, ensure_ascii=False)
             out_trunc, out_meta = truncate_text(out_str)
@@ -882,49 +882,49 @@ def emit_turn(
     with propagate_attributes(
         user_id=user_id,
         session_id=session_id,
-        trace_name="Agent Turn",
-        tags=[AGENT_NAME],
+        trace_name="Agent Turn",
+        tags=[AGENT_NAME],
     ):
-        with langfuse.start_as_current_observation(
-            name="Agent Turn",
-            input={"role": "user", "content": user_text},
-            output={"role": "assistant", "content": assistant_text},
-            metadata={
-                **interaction_meta,
-                "source": AGENT_NAME,
-                "agent": AGENT_NAME,
-                "session_id": session_id,
-                "turn_number": turn_num,
-                "transcript_path": str(transcript_path),
-                "user_text": user_text_meta,
-                "skills": skill_summary,
-            },
-        ) as trace_span:
-            # LLM generation
-            with langfuse.start_as_current_observation(
-                name="Agent Response",
+        with langfuse.start_as_current_observation(
+            name="Agent Turn",
+            input={"role": "user", "content": user_text},
+            output={"role": "assistant", "content": assistant_text},
+            metadata={
+                **interaction_meta,
+                "source": AGENT_NAME,
+                "agent": AGENT_NAME,
+                "session_id": session_id,
+                "turn_number": turn_num,
+                "transcript_path": str(transcript_path),
+                "user_text": user_text_meta,
+                "skills": skill_summary,
+            },
+        ) as trace_span:
+            # LLM generation
+            with langfuse.start_as_current_observation(
+                name="Agent Response",
                 as_type="generation",
                 model=model,
                 input={"role": "user", "content": user_text},
                 output={"role": "assistant", "content": assistant_text},
                 usage_details=usage_details or None,
                 metadata={
-                    "assistant_text": assistant_text_meta,
-                    "tool_count": len(tool_calls),
-                    "usage_details": usage_details,
-                    "source": AGENT_NAME,
-                    "agent": AGENT_NAME,
-                    "user_id": user_id or "",
-                    "session_id": session_id,
-                    "interaction_id": interaction_meta["interaction_id"],
-                    "turn_number": turn_num,
-                },
-            ):
-                pass
-
-            # Tool observations
-            for tc in tool_calls:
-                in_obj = tc["input"]
+                    "assistant_text": assistant_text_meta,
+                    "tool_count": len(tool_calls),
+                    "usage_details": usage_details,
+                    "source": AGENT_NAME,
+                    "agent": AGENT_NAME,
+                    "user_id": user_id or "",
+                    "session_id": session_id,
+                    "interaction_id": interaction_meta["interaction_id"],
+                    "turn_number": turn_num,
+                },
+            ):
+                pass
+
+            # Tool observations
+            for tc in tool_calls:
+                in_obj = tc["input"]
                 # truncate tool input if it's a large string payload
                 if isinstance(in_obj, str):
                     in_obj, in_meta = truncate_text(in_obj)
@@ -932,24 +932,24 @@ def emit_turn(
                     in_meta = None
 
                 with langfuse.start_as_current_observation(
-                    name="Tool Call",
+                    name="Tool Call",
                     as_type="tool",
                     input=in_obj,
-                    metadata={
-                        "source": AGENT_NAME,
-                        "agent": AGENT_NAME,
-                        "user_id": user_id or "",
-                        "session_id": session_id,
-                        "interaction_id": interaction_meta["interaction_id"],
-                        "tool_name": tc["name"],
-                        "tool_id": tc["id"],
-                        "turn_number": turn_num,
-                        "input_meta": in_meta,
-                        "output_meta": tc.get("output_meta"),
-                        "metrics_schema_version": METRICS_SCHEMA_VERSION,
-                    },
-                ) as tool_obs:
-                    tool_obs.update(output=tc.get("output"))
+                    metadata={
+                        "source": AGENT_NAME,
+                        "agent": AGENT_NAME,
+                        "user_id": user_id or "",
+                        "session_id": session_id,
+                        "interaction_id": interaction_meta["interaction_id"],
+                        "tool_name": tc["name"],
+                        "tool_id": tc["id"],
+                        "turn_number": turn_num,
+                        "input_meta": in_meta,
+                        "output_meta": tc.get("output_meta"),
+                        "metrics_schema_version": METRICS_SCHEMA_VERSION,
+                    },
+                ) as tool_obs:
+                    tool_obs.update(output=tc.get("output"))
 
             trace_span.update(output={"role": "assistant", "content": assistant_text})
 
@@ -958,34 +958,34 @@ def main() -> int:
     start = time.time()
     debug("Hook started")
 
-    if os.environ.get("TRACE_TO_LANGFUSE", "").lower() != "true":
-        return 0
-
-    public_key = os.environ.get("CC_LANGFUSE_PUBLIC_KEY") or os.environ.get("LANGFUSE_PUBLIC_KEY")
-    secret_key = os.environ.get("CC_LANGFUSE_SECRET_KEY") or os.environ.get("LANGFUSE_SECRET_KEY")
-    host = os.environ.get("CC_LANGFUSE_BASE_URL") or os.environ.get("LANGFUSE_BASEURL") or "https://cloud.langfuse.com"
-
-    if not public_key or not secret_key:
-        warn("Missing Langfuse public/secret key in hook environment; exiting.")
-        return 0
-
-    payload = read_hook_payload()
-    session_id, transcript_path, user_id = extract_session_transcript_and_user(payload)
-
-    if not session_id or not transcript_path:
-        # No structured payload; fail open (do not guess)
-        warn("Missing session_id or transcript_path from hook payload; exiting.")
-        return 0
-
-    if not transcript_path.exists():
-        warn(f"Transcript path does not exist: {transcript_path}")
-        return 0
-
-    try:
-        langfuse = Langfuse(public_key=public_key, secret_key=secret_key, host=host)
-    except Exception as e:
-        warn(f"Langfuse init failed: {e}")
-        return 0
+    if os.environ.get("TRACE_TO_LANGFUSE", "").lower() != "true":
+        return 0
+
+    public_key = os.environ.get("CC_LANGFUSE_PUBLIC_KEY") or os.environ.get("LANGFUSE_PUBLIC_KEY")
+    secret_key = os.environ.get("CC_LANGFUSE_SECRET_KEY") or os.environ.get("LANGFUSE_SECRET_KEY")
+    host = os.environ.get("CC_LANGFUSE_BASE_URL") or os.environ.get("LANGFUSE_BASEURL") or "https://cloud.langfuse.com"
+
+    if not public_key or not secret_key:
+        warn("Missing Langfuse public/secret key in hook environment; exiting.")
+        return 0
+
+    payload = read_hook_payload()
+    session_id, transcript_path, user_id = extract_session_transcript_and_user(payload)
+
+    if not session_id or not transcript_path:
+        # No structured payload; fail open (do not guess)
+        warn("Missing session_id or transcript_path from hook payload; exiting.")
+        return 0
+
+    if not transcript_path.exists():
+        warn(f"Transcript path does not exist: {transcript_path}")
+        return 0
+
+    try:
+        langfuse = Langfuse(public_key=public_key, secret_key=secret_key, host=host)
+    except Exception as e:
+        warn(f"Langfuse init failed: {e}")
+        return 0
 
     try:
         with FileLock(LOCK_FILE):
@@ -1010,21 +1010,21 @@ def main() -> int:
             for t in turns:
                 emitted += 1
                 turn_num = ss.turn_count + emitted
-                try:
-                    emit_turn(langfuse, session_id, user_id, turn_num, t, transcript_path)
-                except Exception as e:
-                    warn(f"emit_turn failed: {e}")
-                    # continue emitting other turns
+                try:
+                    emit_turn(langfuse, session_id, user_id, turn_num, t, transcript_path)
+                except Exception as e:
+                    warn(f"emit_turn failed: {e}")
+                    # continue emitting other turns
 
             ss.turn_count += emitted
             write_session_state(state, key, ss)
             save_state(state)
 
-        try:
-            langfuse.flush()
-        except Exception as e:
-            warn(f"Langfuse flush failed: {e}")
-            pass
+        try:
+            langfuse.flush()
+        except Exception as e:
+            warn(f"Langfuse flush failed: {e}")
+            pass
 
         dur = time.time() - start
         info(f"Processed {emitted} turns in {dur:.2f}s (session={session_id})")