oh-langfuse 0.1.46 → 0.1.48

package/codex_langfuse_notify.py

@@ -61,7 +61,6 @@ 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"))
-MAX_SKILL_SCAN_CHARS = int(os.environ.get("CODEX_LANGFUSE_SKILL_SCAN_MAX_CHARS", "200000"))
 METRICS_SCHEMA_VERSION = "1.1"
 AGENT_NAME = "codex"
 
@@ -425,6 +424,8 @@ def build_interaction_metadata(
     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,
@@ -454,6 +455,8 @@ def build_interaction_metadata(
         **({
             "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 {}),
     }
 
@@ -483,8 +486,37 @@ def _skill_namespace(name: str) -> str:
     return name.split(":", 1)[0] if ":" in name else ""
 
 
-def _skill_event_type(detected_by: str) -> str:
-    return "invoked" if detected_by in ("tool_call", "plugin_event", "attribution_skill", "slash_command") else "detected"
+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:
@@ -502,85 +534,78 @@ def _skill_usage(name: str, detected_by: str, skill_call_id: str = "") -> Dict[s
     }
 
 
-def _accept_skill_candidate(name: Any, known_skills: set, trusted: bool = False) -> str:
-    clean = str(name or "").strip()
-    if not clean:
-        return ""
-    if trusted or not known_skills or clean in known_skills:
-        return clean
+_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 _collect_strings_limited(value: Any, out: List[str], remaining: List[int]) -> None:
-    if remaining[0] <= 0 or value is None:
-        return
-    if isinstance(value, str):
-        text = value[: remaining[0]]
-        if text:
-            out.append(text)
-            remaining[0] -= len(text)
-        return
-    if isinstance(value, (int, float, bool)):
-        return
-    if isinstance(value, list):
-        for item in value:
-            _collect_strings_limited(item, out, remaining)
-            if remaining[0] <= 0:
-                break
-        return
-    if isinstance(value, dict):
-        for item in value.values():
-            _collect_strings_limited(item, out, remaining)
-            if remaining[0] <= 0:
-                break
-
-
-def _detect_skill_usages_from_text(text: str, known_skills: set) -> List[Dict[str, str]]:
+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 text:
+    if not command:
         return found
-    seen: set = set()
-    for match in re.finditer(r"([A-Za-z]:)?[^\"'\n\r]*[\\/]+([^\\/\"'\n\r]+)[\\/]+SKILL\.md", text, re.IGNORECASE):
-        name = _accept_skill_candidate(match.group(2), known_skills)
-        if name and name not in seen:
-            seen.add(name)
-            found.append(_skill_usage(name, "skill_file_path"))
-    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 not path_match:
-            continue
-        name = _accept_skill_candidate(path_match.group(1), known_skills)
-        if name and name not in seen:
-            seen.add(name)
-            found.append(_skill_usage(name, "skill_file_path"))
+
+    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]] = []
-    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(_skill_usage(name, "tool_call", call_id))
-                    break
-        try:
-            text = json.dumps(input_obj, ensure_ascii=False)
-        except Exception:
-            text = str(input_obj)
-        found.extend(_detect_skill_usages_from_text(text, known_skills))
+        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
 
 
@@ -611,19 +636,8 @@ def _dedupe_turn_skill_usages(usages: List[Dict[str, str]]) -> List[Dict[str, st
 
 
 def detect_turn_skill_usages(material: Dict[str, Any], known_skills: set) -> List[Dict[str, str]]:
-    found = list(detect_skill_usages(material.get("tool_calls") or [], known_skills))
-    sources = [
-        material.get("user_text"),
-        material.get("assistant_text"),
-        material.get("skill_detection_sources"),
-    ]
-    strings: List[str] = []
-    remaining = [max(0, MAX_SKILL_SCAN_CHARS)]
-    for source in sources:
-        _collect_strings_limited(source, strings, remaining)
-        if remaining[0] <= 0:
-            break
-    found.extend(_detect_skill_usages_from_text("\n".join(strings), known_skills))
+    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)
 
 
@@ -631,6 +645,7 @@ def build_skill_use_events(interaction_id: str, skill_usages: List[Dict[str, str
     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:
@@ -646,12 +661,15 @@ def build_skill_use_events(interaction_id: str, skill_usages: List[Dict[str, str
             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),
-            "skill_trigger": "unknown",
+            "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),
@@ -669,6 +687,9 @@ def summarize_skill_usages(skill_usages: List[Dict[str, str]]) -> List[Dict[str,
             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())
 
 

package/langfuse_hook.py

@@ -354,6 +354,8 @@ def build_interaction_metadata(
     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,
@@ -383,6 +385,8 @@ def build_interaction_metadata(
         **({
             "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 {}),
     }
 
@@ -408,7 +412,29 @@ def discover_known_skills(extra_roots: Optional[List[Path]] = None) -> set:
 def _skill_namespace(name: str) -> str:
     return name.split(":", 1)[0] if ":" in name else ""
 
-def _skill_event_type(detected_by: str) -> str:
+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:
@@ -540,6 +566,7 @@ def build_skill_use_events(interaction_id: str, skill_usages: List[Dict[str, str
     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:
@@ -555,12 +582,15 @@ def build_skill_use_events(interaction_id: str, skill_usages: List[Dict[str, str
             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),
-            "skill_trigger": "unknown",
+            "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),
@@ -577,6 +607,9 @@ def summarize_skill_usages(skill_usages: List[Dict[str, str]]) -> List[Dict[str,
             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:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-langfuse",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "private": false,
   "type": "module",
   "description": "Use npm scripts to configure Claude Code / OpenCode / Codex with Langfuse tracing.",

package/scripts/codex-langfuse-setup.mjs

@@ -109,10 +109,20 @@ function listCliCandidatesFromPath(target) {
   const args = process.platform === "win32" ? [target] : ["-a", target];
   const result = spawnSync(cmd, args, { encoding: "utf8", windowsHide: true });
   if (result.status !== 0) return [];
-  return String(result.stdout || "")
+  const candidates = String(result.stdout || "")
     .split(/\r?\n/)
     .map((line) => line.trim())
     .filter(Boolean);
+  return process.platform === "win32" ? sortWindowsCliCandidates(candidates) : candidates;
+}
+
+function sortWindowsCliCandidates(candidates) {
+  const extPriority = (candidate) => {
+    const ext = path.extname(String(candidate || "")).toLowerCase();
+    if (ext === ".cmd" || ext === ".bat" || ext === ".exe") return 0;
+    return 1;
+  };
+  return [...candidates].sort((a, b) => extPriority(a) - extPriority(b));
 }
 
 function resolveAgentCli({ target, preferred = "", shimDir = "" }) {

package/scripts/metrics-utils.mjs

@@ -68,8 +68,46 @@ function skillNamespace(name) {
   return String(name || "").includes(":") ? String(name).split(":", 1)[0] : "";
 }
 
-function skillEventType(detectedBy) {
-  return ["tool_call", "plugin_event", "attribution_skill", "slash_command"].includes(detectedBy) ? "invoked" : "detected";
+function agentFromInteractionId(interactionId) {
+  return String(interactionId || "").split(":", 1)[0] || "unknown";
+}
+
+function skillAgentPath(agent, detectedBy) {
+  if (agent === "claude") {
+    if (detectedBy === "tool_call") return "claude_skill_tool";
+    if (detectedBy === "slash_command") return "claude_slash_skill";
+    if (detectedBy === "attribution_skill") return "claude_attribution_skill";
+  }
+  if (agent === "opencode") {
+    if (detectedBy === "tool_call") return "opencode_skill_tool";
+    if (detectedBy === "slash_command") return "opencode_slash_prompt";
+  }
+  if (agent === "codex") {
+    if (detectedBy === "codex_explicit_injection") return "codex_native_skill_injection";
+    if (detectedBy === "codex_implicit_script") return "codex_skill_script_exec";
+    if (detectedBy === "codex_implicit_doc_read") return "codex_skill_doc_read";
+    if (detectedBy === "tool_call") return "codex_unsupported_skill_tool";
+  }
+  if (detectedBy === "skill_file_path") return "skill_file_path";
+  return detectedBy || "metadata";
+}
+
+function skillInvocationMode(agent, detectedBy) {
+  if (agent === "opencode" && detectedBy === "slash_command") return "explicit_request";
+  if (agent === "codex" && ["codex_implicit_script", "codex_implicit_doc_read"].includes(detectedBy)) return "implicit";
+  if (agent === "codex" && detectedBy === "codex_explicit_injection") return "explicit";
+  if (["slash_command", "attribution_skill"].includes(detectedBy)) return "explicit";
+  if (["tool_call", "plugin_event"].includes(detectedBy)) return "implicit";
+  return "detected";
+}
+
+function skillEventType(detectedBy, agent = "unknown") {
+  if (agent === "opencode" && detectedBy === "slash_command") return "requested";
+  if (agent === "codex" && detectedBy === "tool_call") return "detected";
+  if (["tool_call", "plugin_event", "attribution_skill", "slash_command", "codex_explicit_injection", "codex_implicit_script", "codex_implicit_doc_read"].includes(detectedBy)) {
+    return "invoked";
+  }
+  return "detected";
 }
 
 function skillIdSegment(name) {
@@ -225,6 +263,8 @@ export function buildInteractionMetadata(options = {}) {
     ? skillUseEvents.map((event) => event.skill_name)
     : normalizeSkillNames(options.skillNames ?? options.skill_names);
   const skillNames = normalizeSkillNames(skillNamesAll);
+  const skillInvocationModes = skillUseEvents.map((event) => event.skill_invocation_mode).filter(Boolean);
+  const skillAgentPaths = skillUseEvents.map((event) => event.skill_agent_path).filter(Boolean);
   const skillUseCount = skillUseEvents.length || skillNamesAll.length || Number(options.skillUseCount ?? options.skill_use_count ?? 0) || 0;
   const toolCallCount = Math.max(Number(options.toolCallCount ?? options.tool_call_count ?? 0) || 0, skillUseCount);
   const toolResultCount = Math.max(Number(options.toolResultCount ?? options.tool_result_count ?? 0) || 0, skillUseCount);
@@ -263,6 +303,12 @@ export function buildInteractionMetadata(options = {}) {
   if (skillNamesAll.length) {
     metadata.skill_names_all = skillNamesAll;
   }
+  if (skillInvocationModes.length) {
+    metadata.skill_invocation_modes = skillInvocationModes;
+  }
+  if (skillAgentPaths.length) {
+    metadata.skill_agent_paths = skillAgentPaths;
+  }
 
   return metadata;
 }
@@ -276,17 +322,21 @@ function normalizeSkillUseEvents(events) {
 
 export function buildSkillUseEvents(options = {}) {
   const interactionId = String(options.interactionId ?? options.interaction_id ?? "unknown");
+  const agent = String(options.agent || options.source || agentFromInteractionId(interactionId));
   const usages = dedupeSkillUsages(normalizeSkillUsages(options.skillUsages ?? options.skill_usages));
   const total = usages.length;
   return usages.map((usage, index) => {
     const skillUseIndex = index + 1;
     const detectedBy = usage.detected_by;
+    const invocationMode = skillInvocationMode(agent, detectedBy);
     return {
       skill_use_id: `${interactionId}:skill:${skillUseIndex}:${skillIdSegment(usage.name)}`,
       skill_use_index: skillUseIndex,
       skill_use_count_in_interaction: total,
-      skill_event_type: skillEventType(detectedBy),
-      skill_trigger: "unknown",
+      skill_event_type: skillEventType(detectedBy, agent),
+      skill_trigger: invocationMode,
+      skill_invocation_mode: invocationMode,
+      skill_agent_path: skillAgentPath(agent, detectedBy),
       skill_name: usage.name,
       skill_namespace: usage.skill_namespace,
       detected_by: detectedBy,

package/scripts/opencode-langfuse-setup.mjs

@@ -309,7 +309,18 @@ function getPatchedLangfuseDistIndexJs() {
     "  return out;",
     "};",
     "const skillNamespace = (name) => String(name || '').includes(':') ? String(name).split(':', 1)[0] : '';",
-    "const skillEventType = (detectedBy) => detectedBy === 'tool_call' || detectedBy === 'plugin_event' || detectedBy === 'slash_command' ? 'invoked' : 'detected';",
+    "const skillAgentPath = (detectedBy) => {",
+    "  if (detectedBy === 'tool_call') return 'opencode_skill_tool';",
+    "  if (detectedBy === 'slash_command') return 'opencode_slash_prompt';",
+    "  if (detectedBy === 'skill_file_path') return 'skill_file_path';",
+    "  return detectedBy || 'metadata';",
+    "};",
+    "const skillInvocationMode = (detectedBy) => {",
+    "  if (detectedBy === 'slash_command') return 'explicit_request';",
+    "  if (detectedBy === 'tool_call' || detectedBy === 'plugin_event') return 'implicit';",
+    "  return 'detected';",
+    "};",
+    "const skillEventType = (detectedBy) => detectedBy === 'slash_command' ? 'requested' : (detectedBy === 'tool_call' || detectedBy === 'plugin_event' ? 'invoked' : 'detected');",
     "const skillIdSegment = (name) => String(name || 'unknown').trim().replace(/[^A-Za-z0-9_.:-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 96) || 'unknown';",
     "",
     "const escapeRegExp = (value) => String(value).replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');",
@@ -409,12 +420,15 @@ function getPatchedLangfuseDistIndexJs() {
     "  return usages.map((usage, index) => {",
     "    const skillName = String(usage.name || '').trim();",
     "    const detectedBy = String(usage.detected_by || 'metadata');",
+    "    const invocationMode = skillInvocationMode(detectedBy);",
     "    return {",
     "      skill_use_id: `${interactionId}:skill:${index + 1}:${skillIdSegment(skillName)}`,",
     "      skill_use_index: index + 1,",
     "      skill_use_count_in_interaction: total,",
     "      skill_event_type: skillEventType(detectedBy),",
-    "      skill_trigger: 'unknown',",
+    "      skill_trigger: invocationMode,",
+    "      skill_invocation_mode: invocationMode,",
+    "      skill_agent_path: skillAgentPath(detectedBy),",
     "      skill_name: skillName,",
     "      skill_use_count: 1,",
     "      skill_namespace: usage.skill_namespace || skillNamespace(skillName),",
@@ -580,6 +594,8 @@ function getPatchedLangfuseDistIndexJs() {
     "    const skillUseEvents = buildSkillUseEvents(interactionId, skillUsages);",
     "    const skillNames = uniqueSkillNames(skillUsages);",
     "    const skillNamesAll = skillUseEvents.map((event) => event.skill_name);",
+    "    const skillInvocationModes = skillUseEvents.map((event) => event.skill_invocation_mode).filter(Boolean);",
+    "    const skillAgentPaths = skillUseEvents.map((event) => event.skill_agent_path).filter(Boolean);",
     "    const toolCallCount = Math.max(new Set([...(toolCallIdsByMessageId.get(messageId) ?? []), ...(toolCallIdsBySessionId.get(sessionId) ?? [])]).size, skillUseEvents.length);",
     "    const toolResultCount = Math.max(new Set([...(toolResultIdsByMessageId.get(messageId) ?? []), ...(toolResultIdsBySessionId.get(sessionId) ?? [])]).size, skillUseEvents.length);",
     '    span.setAttribute("oh.langfuse.source", "opencode");',
@@ -603,6 +619,8 @@ function getPatchedLangfuseDistIndexJs() {
     '    if (skillNames.length) span.setAttribute("langfuse.observation.metadata.skill_names", skillNames);',
     '    if (skillNames.length) span.setAttribute("langfuse.observation.metadata.skill_names_csv", skillNames.join(","));',
     '    if (skillNamesAll.length) span.setAttribute("langfuse.observation.metadata.skill_names_all", skillNamesAll);',
+    '    if (skillInvocationModes.length) span.setAttribute("langfuse.observation.metadata.skill_invocation_modes", skillInvocationModes);',
+    '    if (skillAgentPaths.length) span.setAttribute("langfuse.observation.metadata.skill_agent_paths", skillAgentPaths);',
     '    if (tokenMetrics.input !== undefined) span.setAttribute("langfuse.observation.metadata.input_tokens", tokenMetrics.input);',
     '    if (tokenMetrics.output !== undefined) span.setAttribute("langfuse.observation.metadata.output_tokens", tokenMetrics.output);',
     '    if (total !== undefined) span.setAttribute("langfuse.observation.metadata.total_tokens", total);',