oh-langfuse 0.1.53 → 0.1.55

package/codex_langfuse_notify.py

@@ -7,46 +7,46 @@ uses that signal to incrementally read the matching Codex session JSONL file and
 emit the new assistant/user/tool events to Langfuse.
 """
 
-import json
-import os
-import re
-import sys
-import time
-import hashlib
-from dataclasses import dataclass
-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", "CODEX_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()
-
-try:
+import json
+import os
+import re
+import sys
+import time
+import hashlib
+from dataclasses import dataclass
+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", "CODEX_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()
+
+try:
     from langfuse import Langfuse, propagate_attributes
 except Exception:
     sys.exit(0)
@@ -59,10 +59,10 @@ STATE_FILE = STATE_DIR / "state.json"
 LOCK_FILE = STATE_DIR / "state.lock"
 LOG_FILE = STATE_DIR / "codex_langfuse_notify.log"
 
-DEBUG = os.environ.get("CODEX_LANGFUSE_DEBUG", "").lower() == "true"
-MAX_CHARS = int(os.environ.get("CODEX_LANGFUSE_MAX_CHARS", "20000"))
-METRICS_SCHEMA_VERSION = "1.1"
-AGENT_NAME = "codex"
+DEBUG = os.environ.get("CODEX_LANGFUSE_DEBUG", "").lower() == "true"
+MAX_CHARS = int(os.environ.get("CODEX_LANGFUSE_MAX_CHARS", "20000"))
+METRICS_SCHEMA_VERSION = "1.1"
+AGENT_NAME = "codex"
 
 
 def log(level: str, message: str) -> None:
@@ -321,7 +321,7 @@ def extract_text(content: Any) -> str:
     return ""
 
 
-def truncate(value: Any, max_chars: int = MAX_CHARS) -> Tuple[Any, Dict[str, Any]]:
+def truncate(value: Any, max_chars: int = MAX_CHARS) -> Tuple[Any, Dict[str, Any]]:
     if not isinstance(value, str):
         try:
             text = json.dumps(value, ensure_ascii=False)
@@ -334,363 +334,363 @@ def truncate(value: Any, max_chars: int = MAX_CHARS) -> Tuple[Any, Dict[str, Any
     if orig_len <= max_chars:
         return value if isinstance(value, str) else value, {"truncated": False, "orig_len": orig_len}
     kept = text[:max_chars]
-    return kept, {
-        "truncated": True,
-        "orig_len": orig_len,
-        "kept_len": len(kept),
-        "sha256": hashlib.sha256(text.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 = [
-        CODEX_DIR / "skills",
-        CODEX_DIR / "plugins" / "cache",
-        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 == "codex":
-        if detected_by == "codex_explicit_injection":
-            return "codex_native_skill_injection"
-        if detected_by == "codex_implicit_script":
-            return "codex_skill_script_exec"
-        if detected_by == "codex_implicit_doc_read":
-            return "codex_skill_doc_read"
-        if detected_by == "tool_call":
-            return "codex_unsupported_skill_tool"
-    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 agent == "codex" and detected_by == "codex_explicit_injection":
-        return "explicit"
-    if agent == "codex" and detected_by in ("codex_implicit_script", "codex_implicit_doc_read"):
-        return "implicit"
-    return "detected"
-
-
-def _skill_event_type(detected_by: str, agent: str = "unknown") -> str:
-    if agent == "codex" and detected_by == "tool_call":
-        return "detected"
-    return "invoked" if detected_by in ("codex_explicit_injection", "codex_implicit_script", "codex_implicit_doc_read") 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 _skill_usage(name: str, detected_by: str, skill_call_id: str = "") -> Dict[str, str]:
-    clean = str(name or "").strip()
-    return {
-        "name": clean,
-        "skill_namespace": _skill_namespace(clean),
-        "detected_by": detected_by,
-        "skill_call_id": str(skill_call_id or "").strip(),
-    }
-
-
-_CODEX_SCRIPT_RUNNERS = {"python", "python3", "bash", "zsh", "sh", "node", "deno", "ruby", "perl", "pwsh"}
-_CODEX_DOC_READERS = {"cat", "sed", "head", "tail", "less", "more", "bat", "awk"}
-
-
-def _command_from_tool_input(input_obj: Any) -> str:
-    if isinstance(input_obj, dict):
-        command = input_obj.get("command")
-        if isinstance(command, str) and command.strip():
-            return command.strip()
-        argv = input_obj.get("cmd") or input_obj.get("argv")
-        if isinstance(argv, list):
-            return " ".join(str(item) for item in argv)
-    if isinstance(input_obj, str):
-        return input_obj.strip()
-    return ""
-
-
-def _first_command_token(command: str) -> str:
-    match = re.match(r"\s*(?:[A-Za-z]:)?[^\"'\s]*?([^\\/\"'\s]+)(?:\.(?:exe|cmd))?(?=\s|$)", command, re.IGNORECASE)
-    return match.group(1).lower() if match else ""
-
-
-def _accept_known_skill(name: str, known_skills: set) -> str:
-    clean = str(name or "").strip()
-    return clean if clean and (clean in known_skills or not known_skills) else ""
-
-
-def _detect_codex_skill_command(command: str, known_skills: set) -> List[Dict[str, str]]:
-    found: List[Dict[str, str]] = []
-    if not command:
-        return found
-
-    first = _first_command_token(command)
-    if first in _CODEX_SCRIPT_RUNNERS:
-        script_pattern = r"[\\/](?:skills|skill)[\\/]([^\\/\"'\s]+)[\\/]scripts[\\/][^\"'\s]+\.(?:py|sh|js|ts|rb|pl|ps1)(?=$|[\"'\s])"
-        for match in re.finditer(script_pattern, command, re.IGNORECASE):
-            name = _accept_known_skill(match.group(1), known_skills)
-            if name:
-                found.append(_skill_usage(name, "codex_implicit_script"))
-
-    if first in _CODEX_DOC_READERS:
-        doc_pattern = r"[\\/](?:skills|skill)[\\/]([^\\/\"'\s]+)[\\/]SKILL\.md(?=$|[\"'\s])"
-        for match in re.finditer(doc_pattern, command, re.IGNORECASE):
-            name = _accept_known_skill(match.group(1), known_skills)
-            if name:
-                found.append(_skill_usage(name, "codex_implicit_doc_read"))
-
-    return found
-
-
-def detect_skill_usages(tool_calls: List[Dict[str, Any]], known_skills: set) -> List[Dict[str, str]]:
-    found: List[Dict[str, str]] = []
-    for call in tool_calls or []:
-        input_obj = call.get("input") if isinstance(call.get("input"), (dict, list, str)) else {}
-        found.extend(_detect_codex_skill_command(_command_from_tool_input(input_obj), known_skills))
-    return found
-
-
-def _detect_codex_explicit_injections(material: Dict[str, Any], known_skills: set) -> List[Dict[str, str]]:
-    found: List[Dict[str, str]] = []
-    sources = [material.get("user_text"), *(material.get("skill_detection_sources") or [])]
-    for source in sources:
-        text = extract_text(source) if not isinstance(source, str) else source
-        if not text:
-            try:
-                text = json.dumps(source, ensure_ascii=False)
-            except Exception:
-                text = str(source)
-        for match in re.finditer(r"<skill>\s*<name>\s*([^<\s]+)\s*</name>.*?</skill>", text, re.IGNORECASE | re.DOTALL):
-            name = _accept_known_skill(match.group(1), known_skills)
-            if name:
-                found.append(_skill_usage(name, "codex_explicit_injection"))
-    return found
-
-
-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: 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 == "skill_file_path":
-            key = f"{name}:{detected_by}"
-            if key in seen_detected:
-                continue
-            seen_detected.add(key)
-        out.append(usage)
-    return out
-
-
-def detect_turn_skill_usages(material: Dict[str, Any], known_skills: set) -> List[Dict[str, str]]:
-    found = list(_detect_codex_explicit_injections(material, known_skills))
-    found.extend(detect_skill_usages(material.get("tool_calls") or [], 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("codex", detected_by))
-        entry.setdefault("skill_agent_path", _skill_agent_path("codex", detected_by))
-    return list(summary.values())
+    return kept, {
+        "truncated": True,
+        "orig_len": orig_len,
+        "kept_len": len(kept),
+        "sha256": hashlib.sha256(text.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 = [
+        CODEX_DIR / "skills",
+        CODEX_DIR / "plugins" / "cache",
+        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 == "codex":
+        if detected_by == "codex_explicit_injection":
+            return "codex_native_skill_injection"
+        if detected_by == "codex_implicit_script":
+            return "codex_skill_script_exec"
+        if detected_by == "codex_implicit_doc_read":
+            return "codex_skill_doc_read"
+        if detected_by == "tool_call":
+            return "codex_unsupported_skill_tool"
+    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 agent == "codex" and detected_by == "codex_explicit_injection":
+        return "explicit"
+    if agent == "codex" and detected_by in ("codex_implicit_script", "codex_implicit_doc_read"):
+        return "implicit"
+    return "detected"
+
+
+def _skill_event_type(detected_by: str, agent: str = "unknown") -> str:
+    if agent == "codex" and detected_by == "tool_call":
+        return "detected"
+    return "invoked" if detected_by in ("codex_explicit_injection", "codex_implicit_script", "codex_implicit_doc_read") 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 _skill_usage(name: str, detected_by: str, skill_call_id: str = "") -> Dict[str, str]:
+    clean = str(name or "").strip()
+    return {
+        "name": clean,
+        "skill_namespace": _skill_namespace(clean),
+        "detected_by": detected_by,
+        "skill_call_id": str(skill_call_id or "").strip(),
+    }
+
+
+_CODEX_SCRIPT_RUNNERS = {"python", "python3", "bash", "zsh", "sh", "node", "deno", "ruby", "perl", "pwsh"}
+_CODEX_DOC_READERS = {"cat", "sed", "head", "tail", "less", "more", "bat", "awk"}
+
+
+def _command_from_tool_input(input_obj: Any) -> str:
+    if isinstance(input_obj, dict):
+        command = input_obj.get("command")
+        if isinstance(command, str) and command.strip():
+            return command.strip()
+        argv = input_obj.get("cmd") or input_obj.get("argv")
+        if isinstance(argv, list):
+            return " ".join(str(item) for item in argv)
+    if isinstance(input_obj, str):
+        return input_obj.strip()
+    return ""
+
+
+def _first_command_token(command: str) -> str:
+    match = re.match(r"\s*(?:[A-Za-z]:)?[^\"'\s]*?([^\\/\"'\s]+)(?:\.(?:exe|cmd))?(?=\s|$)", command, re.IGNORECASE)
+    return match.group(1).lower() if match else ""
+
+
+def _accept_known_skill(name: str, known_skills: set) -> str:
+    clean = str(name or "").strip()
+    return clean if clean and (clean in known_skills or not known_skills) else ""
+
+
+def _detect_codex_skill_command(command: str, known_skills: set) -> List[Dict[str, str]]:
+    found: List[Dict[str, str]] = []
+    if not command:
+        return found
+
+    first = _first_command_token(command)
+    if first in _CODEX_SCRIPT_RUNNERS:
+        script_pattern = r"[\\/](?:skills|skill)[\\/]([^\\/\"'\s]+)[\\/]scripts[\\/][^\"'\s]+\.(?:py|sh|js|ts|rb|pl|ps1)(?=$|[\"'\s])"
+        for match in re.finditer(script_pattern, command, re.IGNORECASE):
+            name = _accept_known_skill(match.group(1), known_skills)
+            if name:
+                found.append(_skill_usage(name, "codex_implicit_script"))
+
+    if first in _CODEX_DOC_READERS:
+        doc_pattern = r"[\\/](?:skills|skill)[\\/]([^\\/\"'\s]+)[\\/]SKILL\.md(?=$|[\"'\s])"
+        for match in re.finditer(doc_pattern, command, re.IGNORECASE):
+            name = _accept_known_skill(match.group(1), known_skills)
+            if name:
+                found.append(_skill_usage(name, "codex_implicit_doc_read"))
+
+    return found
+
+
+def detect_skill_usages(tool_calls: List[Dict[str, Any]], known_skills: set) -> List[Dict[str, str]]:
+    found: List[Dict[str, str]] = []
+    for call in tool_calls or []:
+        input_obj = call.get("input") if isinstance(call.get("input"), (dict, list, str)) else {}
+        found.extend(_detect_codex_skill_command(_command_from_tool_input(input_obj), known_skills))
+    return found
+
+
+def _detect_codex_explicit_injections(material: Dict[str, Any], known_skills: set) -> List[Dict[str, str]]:
+    found: List[Dict[str, str]] = []
+    sources = [material.get("user_text"), *(material.get("skill_detection_sources") or [])]
+    for source in sources:
+        text = extract_text(source) if not isinstance(source, str) else source
+        if not text:
+            try:
+                text = json.dumps(source, ensure_ascii=False)
+            except Exception:
+                text = str(source)
+        for match in re.finditer(r"<skill>\s*<name>\s*([^<\s]+)\s*</name>.*?</skill>", text, re.IGNORECASE | re.DOTALL):
+            name = _accept_known_skill(match.group(1), known_skills)
+            if name:
+                found.append(_skill_usage(name, "codex_explicit_injection"))
+    return found
+
+
+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: 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 == "skill_file_path":
+            key = f"{name}:{detected_by}"
+            if key in seen_detected:
+                continue
+            seen_detected.add(key)
+        out.append(usage)
+    return out
+
+
+def detect_turn_skill_usages(material: Dict[str, Any], known_skills: set) -> List[Dict[str, str]]:
+    found = list(_detect_codex_explicit_injections(material, known_skills))
+    found.extend(detect_skill_usages(material.get("tool_calls") or [], 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("codex", detected_by))
+        entry.setdefault("skill_agent_path", _skill_agent_path("codex", detected_by))
+    return list(summary.values())
 
 
 def get_payload(row: Dict[str, Any]) -> Dict[str, Any]:
@@ -743,16 +743,16 @@ def usage_details_from_codex(usage: Dict[str, Any]) -> Dict[str, int]:
 
 
 def collect_turn_material(rows: List[Dict[str, Any]]) -> Dict[str, Any]:
-    user_texts: List[str] = []
-    assistant_texts: List[str] = []
-    tool_calls: List[Dict[str, Any]] = []
-    tool_results: List[Dict[str, Any]] = []
-    skill_detection_sources: List[Any] = []
-
-    for row in rows:
-        row_type = row.get("type")
-        payload = get_payload(row)
-        skill_detection_sources.append(payload or row)
+    user_texts: List[str] = []
+    assistant_texts: List[str] = []
+    tool_calls: List[Dict[str, Any]] = []
+    tool_results: List[Dict[str, Any]] = []
+    skill_detection_sources: List[Any] = []
+
+    for row in rows:
+        row_type = row.get("type")
+        payload = get_payload(row)
+        skill_detection_sources.append(payload or row)
 
         if row_type == "response_item":
             item_type = payload.get("type")
@@ -794,11 +794,11 @@ def collect_turn_material(rows: List[Dict[str, Any]]) -> Dict[str, Any]:
 
     return {
         "user_text": "\n\n".join(user_texts[-3:]),
-        "assistant_text": "\n\n".join(assistant_texts),
-        "tool_calls": tool_calls,
-        "tool_results": tool_results,
-        "skill_detection_sources": skill_detection_sources,
-    }
+        "assistant_text": "\n\n".join(assistant_texts),
+        "tool_calls": tool_calls,
+        "tool_results": tool_results,
+        "skill_detection_sources": skill_detection_sources,
+    }
 
 
 def emit_codex_turn(
@@ -813,113 +813,113 @@ def emit_codex_turn(
 ) -> None:
     user_text, user_meta = truncate(material.get("user_text") or "")
     assistant_text, assistant_meta = truncate(material.get("assistant_text") or "")
-    usage_details = usage_details_from_codex(usage)
-    model = first_string(meta.get("model"), meta.get("model_provider")) or "codex"
-    tool_calls = material.get("tool_calls") or []
-    tool_results = material.get("tool_results") or []
-    skill_usages = detect_turn_skill_usages(material, discover_known_skills())
-    interaction_id = build_interaction_id("codex", session_id, turn_num)
-    skill_use_events = build_skill_use_events(interaction_id, skill_usages)
-    interaction_meta = build_interaction_metadata(
-        "codex",
-        user_id,
-        session_id,
-        turn_num,
-        usage_details,
-        len(tool_calls),
-        len(tool_results),
-        len(skill_use_events),
-        model,
-        user_message_count=1 if material.get("user_text") else 0,
-        assistant_message_count=1 if material.get("assistant_text") else 0,
-        skill_use_events=skill_use_events,
-    )
-    skill_summary = summarize_skill_usages(skill_usages)
-
-    with propagate_attributes(
-        user_id=user_id,
+    usage_details = usage_details_from_codex(usage)
+    model = first_string(meta.get("model"), meta.get("model_provider")) or "codex"
+    tool_calls = material.get("tool_calls") or []
+    tool_results = material.get("tool_results") or []
+    skill_usages = detect_turn_skill_usages(material, discover_known_skills())
+    interaction_id = build_interaction_id("codex", session_id, turn_num)
+    skill_use_events = build_skill_use_events(interaction_id, skill_usages)
+    interaction_meta = build_interaction_metadata(
+        "codex",
+        user_id,
+        session_id,
+        turn_num,
+        usage_details,
+        len(tool_calls),
+        len(tool_results),
+        len(skill_use_events),
+        model,
+        user_message_count=1 if material.get("user_text") else 0,
+        assistant_message_count=1 if material.get("assistant_text") else 0,
+        skill_use_events=skill_use_events,
+    )
+    skill_summary = summarize_skill_usages(skill_usages)
+
+    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,
-                "session_path": str(session_path),
+        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,
+                "session_path": str(session_path),
                 "cwd": meta.get("cwd"),
                 "originator": meta.get("originator"),
-                "cli_version": meta.get("cli_version"),
-                "user_text": user_meta,
-                "usage": usage,
-                "skills": skill_summary,
-            },
-        ) as trace_span:
-            with langfuse.start_as_current_observation(
-                name="Agent Response",
-                as_type="generation",
+                "cli_version": meta.get("cli_version"),
+                "user_text": user_meta,
+                "usage": usage,
+                "skills": skill_summary,
+            },
+        ) as trace_span:
+            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_meta,
-                    "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
-
-            for call in tool_calls:
-                tool_input, input_meta = truncate(call.get("input"))
-                with langfuse.start_as_current_observation(
-                    name="Tool Call",
+                output={"role": "assistant", "content": assistant_text},
+                usage_details=usage_details or None,
+                metadata={
+                    "assistant_text": assistant_meta,
+                    "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
+
+            for call in tool_calls:
+                tool_input, input_meta = truncate(call.get("input"))
+                with langfuse.start_as_current_observation(
+                    name="Tool Call",
+                    as_type="tool",
+                    input=tool_input,
+                    metadata={
+                        "source": AGENT_NAME,
+                        "agent": AGENT_NAME,
+                        "user_id": user_id or "",
+                        "session_id": session_id,
+                        "interaction_id": interaction_meta["interaction_id"],
+                        "tool_id": call.get("id"),
+                        "tool_name": call.get("name"),
+                        "turn_number": turn_num,
+                        "input_meta": input_meta,
+                        "metrics_schema_version": METRICS_SCHEMA_VERSION,
+                    },
+                ):
+                    pass
+
+            for result in tool_results:
+                output, output_meta = truncate(result.get("output"))
+                with langfuse.start_as_current_observation(
+                    name="Tool Result",
                     as_type="tool",
-                    input=tool_input,
-                    metadata={
-                        "source": AGENT_NAME,
-                        "agent": AGENT_NAME,
-                        "user_id": user_id or "",
-                        "session_id": session_id,
-                        "interaction_id": interaction_meta["interaction_id"],
-                        "tool_id": call.get("id"),
-                        "tool_name": call.get("name"),
-                        "turn_number": turn_num,
-                        "input_meta": input_meta,
-                        "metrics_schema_version": METRICS_SCHEMA_VERSION,
-                    },
-                ):
-                    pass
-
-            for result in tool_results:
-                output, output_meta = truncate(result.get("output"))
-                with langfuse.start_as_current_observation(
-                    name="Tool Result",
-                    as_type="tool",
-                    metadata={
-                        "source": AGENT_NAME,
-                        "agent": AGENT_NAME,
-                        "user_id": user_id or "",
-                        "session_id": session_id,
-                        "interaction_id": interaction_meta["interaction_id"],
-                        "tool_id": result.get("id"),
-                        "tool_name": result.get("name"),
-                        "turn_number": turn_num,
-                        "output_meta": output_meta,
-                        "metrics_schema_version": METRICS_SCHEMA_VERSION,
-                    },
-                ) as tool_obs:
-                    tool_obs.update(output=output)
+                    metadata={
+                        "source": AGENT_NAME,
+                        "agent": AGENT_NAME,
+                        "user_id": user_id or "",
+                        "session_id": session_id,
+                        "interaction_id": interaction_meta["interaction_id"],
+                        "tool_id": result.get("id"),
+                        "tool_name": result.get("name"),
+                        "turn_number": turn_num,
+                        "output_meta": output_meta,
+                        "metrics_schema_version": METRICS_SCHEMA_VERSION,
+                    },
+                ) as tool_obs:
+                    tool_obs.update(output=output)
 
             trace_span.update(output={"role": "assistant", "content": assistant_text})