oh-langfuse 0.1.43 → 0.1.45

package/codex_langfuse_notify.py

@@ -61,6 +61,7 @@ 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"
 
@@ -460,6 +461,7 @@ def build_interaction_metadata(
 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",
     ]
@@ -490,6 +492,71 @@ def _skill_id_segment(name: str) -> str:
     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(),
+    }
+
+
+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
+    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]]:
+    found: List[Dict[str, str]] = []
+    if not text:
+        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"))
+    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()
@@ -507,19 +574,59 @@ def detect_skill_usages(tool_calls: List[Dict[str, Any]], known_skills: set) ->
                         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})
+                    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)
-        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"})
+        found.extend(_detect_skill_usages_from_text(text, known_skills))
     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_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))
+    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]] = []
@@ -615,14 +722,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]] = []
-
-    for row in rows:
-        row_type = row.get("type")
-        payload = get_payload(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")
@@ -664,10 +773,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,
-    }
+        "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(
@@ -686,7 +796,7 @@ def emit_codex_turn(
     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_skill_usages(tool_calls, discover_known_skills())
+    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(

package/langfuse_hook.py

@@ -10,7 +10,7 @@ import re
 import sys
 import time
 import hashlib
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
@@ -526,7 +526,7 @@ def _dedupe_turn_skill_usages(usages: List[Dict[str, str]]) -> List[Dict[str, st
 
 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, *turn.assistant_msgs]
+    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)
@@ -694,13 +694,20 @@ def read_new_jsonl(transcript_path: Path, ss: SessionState) -> Tuple[List[Dict[s
     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]
-
-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)
@@ -715,38 +722,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
-
-    def flush_turn():
-        nonlocal current_user, assistant_order, assistant_latest, tool_results_by_id, 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)))
+    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 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 = {}
-            continue
+            assistant_order = []
+            assistant_latest = {}
+            tool_results_by_id = {}
+            context_msgs = []
+            continue
 
         if role == "assistant":
             if current_user is None:

package/package.json

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

package/scripts/auto-update-runtime.mjs

@@ -10,6 +10,21 @@ const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
 const packageJson = JSON.parse(fs.readFileSync(path.join(rootDir, "package.json"), "utf8"));
 const ALLOWED_TARGETS = new Set(["claude", "opencode", "codex"]);
 
+const colorEnabled = process.stdout.isTTY && process.env.NO_COLOR !== "1";
+const ansi = (code) => (colorEnabled ? `\x1b[${code}m` : "");
+const t = {
+  reset: ansi(0),
+  bold: ansi(1),
+  cyan: ansi("96"),
+  green: ansi("92"),
+  gold: ansi("93"),
+};
+
+function paint(text, ...styles) {
+  if (!colorEnabled) return text;
+  return `${styles.join("")}${text}${t.reset}`;
+}
+
 function parseArgs(argv) {
   const args = { _: [] };
   for (const raw of argv) {
@@ -45,6 +60,26 @@ function npxCommand() {
   return process.platform === "win32" ? "npx.cmd" : "npx";
 }
 
+function targetLabel(target) {
+  if (target === "claude") return "Claude";
+  if (target === "codex") return "Codex";
+  if (target === "opencode") return "OpenCode";
+  return target;
+}
+
+function printUpdateAvailable(target, message, updateCommand) {
+  const label = targetLabel(target);
+  console.log(paint(`[UPDATE] \u68c0\u6d4b\u5230 ${label} Langfuse \u53ef\u66f4\u65b0`, t.bold, t.gold));
+  console.log(`[INFO] ${message}`);
+  console.log(`${paint("[CMD]", t.bold, t.cyan)} ${updateCommand}`);
+}
+
+function printUpdateCommand(target, updateCommand) {
+  const label = targetLabel(target);
+  console.log(paint(`[UPDATE] \u6b63\u5728\u6267\u884c\u66f4\u65b0\u547d\u4ee4\uff1a${label} Langfuse`, t.bold, t.cyan));
+  console.log(`${paint("[CMD]", t.bold, t.cyan)} ${updateCommand}`);
+}
+
 function runUpdate(target, args) {
   const updateArgs = ["-y", "oh-langfuse@latest", "update", target];
   if (args["skip-check"]) updateArgs.push("--skip-check");
@@ -89,24 +124,27 @@ async function main() {
   const updateCommand = `npx oh-langfuse@latest update ${target}`;
 
   if (args["notify-only"] || args.notifyOnly) {
-    console.log(`[INFO] ${message}`);
+    printUpdateAvailable(target, message, updateCommand);
     console.log(`[INFO] To update safely, close the agent and run: ${updateCommand}`);
     return 0;
   }
 
   if (args.yes || args.y) {
-    console.log(`[INFO] ${message}`);
+    printUpdateAvailable(target, message, updateCommand);
+    printUpdateCommand(target, updateCommand);
     const code = runUpdate(target, args);
     return args.strict ? code : 0;
   }
 
   if (!process.stdin.isTTY || !process.stdout.isTTY) {
-    console.log(`[INFO] ${message} Run: ${updateCommand}`);
+    printUpdateAvailable(target, message, updateCommand);
     return 0;
   }
 
-  const answer = await question(`${message}\nUpdate now? (y/N) `);
+  printUpdateAvailable(target, message, updateCommand);
+  const answer = await question(`${paint("[CONFIRM]", t.bold, t.gold)} Update now? (y/N) `);
   if (!/^(y|yes)$/i.test(answer)) return 0;
+  printUpdateCommand(target, updateCommand);
   const code = runUpdate(target, args);
   return args.strict ? code : 0;
 }

package/scripts/update-langfuse-runtime.mjs

@@ -3,7 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { extractVersionFromNpmMetadata, selectUpdateTargets } from "./update-utils.mjs";
+import { buildUpdatePlan, extractVersionFromNpmMetadata } from "./update-utils.mjs";
 import { writeRuntimeInstallRecord } from "./runtime-state-utils.mjs";
 
 const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
@@ -13,6 +13,23 @@ const DEFAULT_LANGFUSE_BASE_URL = "http://120.46.221.227:3000";
 const DEFAULT_LANGFUSE_PUBLIC_KEY = "pk-lf-da0c90a7-6e93-4eb7-bb86-c1047c8d187d";
 const DEFAULT_LANGFUSE_SECRET_KEY = "sk-lf-0269b85d-bfdc-442c-bfa3-e737954e3315";
 
+const colorEnabled = process.stdout.isTTY && process.env.NO_COLOR !== "1";
+const ansi = (code) => (colorEnabled ? `\x1b[${code}m` : "");
+const t = {
+  reset: ansi(0),
+  bold: ansi(1),
+  dim: ansi(2),
+  cyan: ansi("96"),
+  green: ansi("92"),
+  gold: ansi("93"),
+  red: ansi("91"),
+};
+
+function paint(text, ...styles) {
+  if (!colorEnabled) return text;
+  return `${styles.join("")}${text}${t.reset}`;
+}
+
 function parseArgs(argv) {
   const args = { _: [] };
   for (const raw of argv) {
@@ -142,14 +159,72 @@ function checkScript(target) {
   return "opencode-langfuse-check.mjs";
 }
 
+function targetLabel(target) {
+  if (target === "claude") return "Claude";
+  if (target === "codex") return "Codex";
+  if (target === "opencode") return "OpenCode";
+  return target;
+}
+
+function updatedItems(target, args) {
+  const items = [];
+  if (target === "claude") {
+    items.push("Claude Code Langfuse hook", "direct claude auto-update command shim", "Claude launcher", "runtime version record");
+  } else if (target === "codex") {
+    items.push("Codex notify hook", "direct codex auto-update command shim", "Codex launcher", "runtime version record");
+  } else {
+    items.push("OpenCode Langfuse plugin/config", "direct opencode auto-update command shim", "OpenCode launcher", "runtime version record");
+    if (args["skip-plugin-install"] || args.skipPluginInstall) {
+      items[0] = "OpenCode Langfuse config";
+    }
+  }
+  if (!args["skip-check"]) items.push("post-update configuration check");
+  return items;
+}
+
+function printSkippedTarget(target) {
+  const label = targetLabel(target);
+  console.log(paint(`[WARN] \u5f53\u524d\u672a\u68c0\u6d4b\u5230 ${label} \u5b89\u88c5\uff0c\u8df3\u8fc7\u66f4\u65b0 ${label} Langfuse \u63d2\u4ef6\u3002`, t.bold, t.gold));
+}
+
+function printUpdateStart(target) {
+  const label = targetLabel(target);
+  console.log("");
+  console.log(paint(`[UPDATE] \u6b63\u5728\u66f4\u65b0 ${label} Langfuse ...`, t.bold, t.cyan));
+}
+
+function printUpdateCheck(target) {
+  const label = targetLabel(target);
+  console.log(paint(`[CHECK] \u6b63\u5728\u6821\u9a8c ${label} Langfuse \u914d\u7f6e ...`, t.bold, t.gold));
+}
+
+function printUpdateSuccess(target, args) {
+  const label = targetLabel(target);
+  console.log(paint(`[SUCCESS] ${label} Langfuse \u66f4\u65b0\u6210\u529f\uff1a${packageJson.name}@${packageJson.version}`, t.bold, t.green));
+  console.log(`${paint("[DETAIL]", t.bold, t.gold)} \u66f4\u65b0\u5185\u5bb9\uff1a${updatedItems(target, args).join("\u3001")}`);
+}
+
+function printUpdateSummary(targets) {
+  console.log("");
+  console.log(paint(`[SUCCESS] Langfuse \u66f4\u65b0\u5b8c\u6210\uff1a${targets.map(targetLabel).join("\u3001")} -> ${packageJson.name}@${packageJson.version}`, t.bold, t.green));
+}
+
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   const targetArg = args._[0] || "all";
   const installed = detectInstalledTargets();
-  const targets = selectUpdateTargets(targetArg, installed);
-  if (!targets.length) {
+  const plan = buildUpdatePlan(targetArg, installed);
+  const targets = plan.targets;
+  for (const item of plan.skipped) {
+    if (item.reason === "not_detected") printSkippedTarget(item.target);
+  }
+  if (!targets.length && !plan.skipped.length) {
     throw new Error("No installed oh-langfuse targets were detected. Run setup first, or specify a target with credentials.");
   }
+  if (!targets.length) {
+    console.log("[INFO] \u6ca1\u6709\u53ef\u66f4\u65b0\u7684 Langfuse agent runtime\u3002");
+    return;
+  }
 
   console.log(`[INFO] Running package: ${packageJson.name}@${packageJson.version}`);
   try {
@@ -163,8 +238,7 @@ async function main() {
   }
 
   for (const target of targets) {
-    console.log("");
-    console.log(`[INFO] Updating ${target} runtime...`);
+    printUpdateStart(target);
     const config = mergedConfig(target, args);
     runNodeScript(setupScript(target), setupArgs(target, config, args));
     writeRuntimeInstallRecord(target, {
@@ -172,9 +246,12 @@ async function main() {
       packageVersion: packageJson.version,
     });
     if (!args["skip-check"]) {
+      printUpdateCheck(target);
       runNodeScript(checkScript(target), []);
     }
+    printUpdateSuccess(target, args);
   }
+  printUpdateSummary(targets);
 }
 
 main().catch((error) => {

package/scripts/update-utils.mjs

@@ -1,4 +1,5 @@
 const ALLOWED_TARGETS = new Set(["claude", "opencode", "codex"]);
+const ALL_TARGETS = ["claude", "opencode", "codex"];
 
 export function extractVersionFromNpmMetadata(metadata) {
   const latest = metadata?.["dist-tags"]?.latest;
@@ -38,10 +39,35 @@ export function isNewerVersion(candidate, current) {
 export function selectUpdateTargets(target = "all", installed = {}) {
   const normalized = String(target || "all").trim().toLowerCase();
   if (normalized === "all") {
-    return ["claude", "opencode", "codex"].filter((name) => Boolean(installed[name]));
+    return ALL_TARGETS.filter((name) => Boolean(installed[name]));
   }
   if (!ALLOWED_TARGETS.has(normalized)) {
     throw new Error(`Unsupported update target: ${target}`);
   }
   return [normalized];
 }
+
+export function buildUpdatePlan(target = "all", installed = {}) {
+  const normalized = String(target || "all").trim().toLowerCase();
+  if (normalized === "all") {
+    return {
+      targets: ALL_TARGETS.filter((name) => Boolean(installed[name])),
+      skipped: ALL_TARGETS
+        .filter((name) => !installed[name])
+        .map((name) => ({ target: name, reason: "not_detected" })),
+    };
+  }
+  if (!ALLOWED_TARGETS.has(normalized)) {
+    throw new Error(`Unsupported update target: ${target}`);
+  }
+  if (!installed[normalized]) {
+    return {
+      targets: [],
+      skipped: [{ target: normalized, reason: "not_detected" }],
+    };
+  }
+  return {
+    targets: [normalized],
+    skipped: [],
+  };
+}