oh-langfuse 0.1.63 → 0.1.65

package/README.md

@@ -142,6 +142,21 @@ metadata.skill_invocation_modes
 metadata.skill_agent_paths
 ```
 
+Repository context is also attached to each Agent Turn when the runtime can identify a current working directory. The hook performs only lightweight read-only git probes and stays silent on timeout or failure.
+
+Common repository fields:
+
+```text
+metadata.cwd
+metadata.cwd_source
+metadata.git_context_available
+metadata.is_git_repo
+metadata.git_remote
+metadata.git_repo_slug
+metadata.git_branch
+metadata.git_commit
+```
+
 Dashboard 统计建议：
 
 ```text

package/codex_langfuse_notify.py

@@ -10,6 +10,7 @@ emit the new assistant/user/tool events to Langfuse.
 import json
 import os
 import re
+import subprocess
 import sys
 import time
 import hashlib
@@ -87,6 +88,9 @@ MAX_CHARS = int(os.environ.get("CODEX_LANGFUSE_MAX_CHARS", "20000"))
 METRICS_SCHEMA_VERSION = "1.1"
 AGENT_NAME = "codex"
 AGENT_TURN_NAME = "Codex Agent Turn"
+REPO_CONTEXT_TTL_S = 30.0
+REPO_CONTEXT_GIT_TIMEOUT_S = 0.5
+_REPO_CONTEXT_CACHE: Dict[str, Tuple[float, Dict[str, Any]]] = {}
 
 
 def log(level: str, message: str) -> None:
@@ -104,6 +108,158 @@ def debug(message: str) -> None:
         log("DEBUG", message)
 
 
+def empty_repo_context(
+    cwd: Optional[str] = None,
+    cwd_source: str = "unavailable",
+    available: bool = False,
+    error: str = "",
+    is_git_repo: bool = False,
+) -> Dict[str, Any]:
+    return {
+        "cwd": str(cwd or ""),
+        "cwd_source": cwd_source or "unavailable",
+        "git_context_available": bool(available),
+        "git_context_error": error or "",
+        "is_git_repo": bool(is_git_repo),
+        "git_root": "",
+        "git_remote": "",
+        "git_remote_host": "",
+        "git_repo_owner": "",
+        "git_repo_name": "",
+        "git_repo_slug": "",
+        "git_branch": "",
+        "git_commit": "",
+    }
+
+
+def sanitize_git_remote(remote: Optional[str]) -> Dict[str, str]:
+    empty = {
+        "git_remote": "",
+        "git_remote_host": "",
+        "git_repo_owner": "",
+        "git_repo_name": "",
+        "git_repo_slug": "",
+    }
+    raw = str(remote or "").strip()
+    if not raw:
+        return empty
+
+    try:
+        if "://" in raw:
+            parsed = urlparse(raw)
+            host = parsed.hostname or ""
+            parts = [part for part in parsed.path.strip("/").split("/") if part]
+        else:
+            scp_like = re.match(r"^[^@]+@([^:]+):(.+)$", raw)
+            if scp_like:
+                host = scp_like.group(1)
+                parts = [part for part in scp_like.group(2).strip("/").split("/") if part]
+            else:
+                parsed = urlparse(f"ssh://{raw}")
+                host = parsed.hostname or ""
+                parts = [part for part in parsed.path.strip("/").split("/") if part]
+
+        if len(parts) < 2 or not host:
+            return empty
+        owner = parts[-2]
+        repo = parts[-1]
+        if repo.endswith(".git"):
+            repo = repo[:-4]
+        if not owner or not repo:
+            return empty
+        slug = f"{owner}/{repo}"
+        return {
+            "git_remote": f"{host}/{slug}",
+            "git_remote_host": host,
+            "git_repo_owner": owner,
+            "git_repo_name": repo,
+            "git_repo_slug": slug,
+        }
+    except Exception:
+        return empty
+
+
+def run_git_command(cwd: str, args: List[str], timeout_s: float = REPO_CONTEXT_GIT_TIMEOUT_S) -> Tuple[bool, str, str]:
+    try:
+        result = subprocess.run(
+            ["git", "-C", cwd, *args],
+            text=True,
+            capture_output=True,
+            timeout=timeout_s,
+            check=False,
+        )
+        return result.returncode == 0, (result.stdout or "").strip(), (result.stderr or "").strip()
+    except subprocess.TimeoutExpired:
+        return False, "", "timeout"
+    except FileNotFoundError:
+        return False, "", "git_unavailable"
+    except Exception:
+        return False, "", "git_error"
+
+
+def collect_repo_context(cwd: Optional[str], cwd_source: str = "unavailable") -> Dict[str, Any]:
+    cwd_text = str(cwd or "").strip()
+    if not cwd_text:
+        return empty_repo_context(error="missing_cwd")
+
+    path = Path(cwd_text)
+    if not path.exists():
+        return empty_repo_context(cwd_text, cwd_source, available=False, error="missing_cwd")
+
+    cache_key = str(path.resolve())
+    cached = _REPO_CONTEXT_CACHE.get(cache_key)
+    now = time.time()
+    if cached and now - cached[0] <= REPO_CONTEXT_TTL_S:
+        context = dict(cached[1])
+        context["cwd_source"] = cwd_source or context.get("cwd_source") or "unavailable"
+        return context
+
+    ok, inside, error = run_git_command(cwd_text, ["rev-parse", "--is-inside-work-tree"])
+    if not ok:
+        reason = error if error in ("timeout", "git_unavailable") else ""
+        if reason:
+            context = empty_repo_context(cwd_text, cwd_source, available=False, error=reason)
+        else:
+            context = empty_repo_context(cwd_text, cwd_source, available=True, is_git_repo=False)
+        _REPO_CONTEXT_CACHE[cache_key] = (now, dict(context))
+        return context
+    if inside.lower() != "true":
+        context = empty_repo_context(cwd_text, cwd_source, available=True, is_git_repo=False)
+        _REPO_CONTEXT_CACHE[cache_key] = (now, dict(context))
+        return context
+
+    context = empty_repo_context(cwd_text, cwd_source, available=True, is_git_repo=True)
+
+    ok_root, root, root_error = run_git_command(cwd_text, ["rev-parse", "--show-toplevel"])
+    if not ok_root and root_error in ("timeout", "git_unavailable"):
+        context["git_context_available"] = False
+        context["git_context_error"] = root_error
+        _REPO_CONTEXT_CACHE[cache_key] = (now, dict(context))
+        return context
+    context["git_root"] = root
+
+    ok_remote, remote, remote_error = run_git_command(cwd_text, ["config", "--get", "remote.origin.url"])
+    if ok_remote and remote:
+        remote_context = sanitize_git_remote(remote)
+        context.update(remote_context)
+        if not remote_context["git_remote"]:
+            context["git_context_error"] = "remote_parse_failed"
+    elif remote_error in ("timeout", "git_unavailable"):
+        context["git_context_available"] = False
+        context["git_context_error"] = remote_error
+
+    ok_branch, branch, _branch_error = run_git_command(cwd_text, ["branch", "--show-current"])
+    if ok_branch:
+        context["git_branch"] = branch
+
+    ok_commit, commit, _commit_error = run_git_command(cwd_text, ["rev-parse", "--short", "HEAD"])
+    if ok_commit:
+        context["git_commit"] = commit
+
+    _REPO_CONTEXT_CACHE[cache_key] = (now, dict(context))
+    return context
+
+
 class FileLock:
     def __init__(self, path: Path, timeout_s: float = 2.0):
         self.path = path
@@ -1198,6 +1354,7 @@ def emit_codex_turn(
         skill_use_events=skill_use_events,
     )
     skill_summary = summarize_skill_usages(skill_usages)
+    repo_context = dict(meta.get("repo_context") or collect_repo_context(first_string(meta.get("cwd")), "session_meta"))
 
     with propagate_attributes(
         user_id=user_id,
@@ -1216,7 +1373,7 @@ def emit_codex_turn(
                 "session_id": session_id,
                 "turn_number": turn_num,
                 "session_path": str(session_path),
-                "cwd": meta.get("cwd"),
+                **repo_context,
                 "originator": meta.get("originator"),
                 "cli_version": meta.get("cli_version"),
                 "user_text": user_meta,
@@ -1374,6 +1531,7 @@ def main() -> int:
             meta = get_session_meta(rows, session_path)
             meta.update({k: v for k, v in parsed.session_meta.items() if v not in (None, "")})
             meta.setdefault("session_path", str(session_path))
+            meta["repo_context"] = collect_repo_context(first_string(meta.get("cwd")), "session_meta")
             session_id = first_string(str(meta.get("id")) if meta.get("id") else "", session_path.stem) or session_path.stem
             uploaded = 0
 

package/langfuse_hook.py

@@ -7,6 +7,7 @@ Claude Code -> Langfuse hook
 import json
 import os
 import re
+import subprocess
 import sys
 import time
 import hashlib
@@ -66,8 +67,11 @@ LOCK_FILE = STATE_DIR / "langfuse_state.lock"
 DEBUG = os.environ.get("CC_LANGFUSE_DEBUG", "").lower() == "true"
 MAX_CHARS = int(os.environ.get("CC_LANGFUSE_MAX_CHARS", "20000"))
 METRICS_SCHEMA_VERSION = "1.1"
-AGENT_NAME = "claude"
-AGENT_TURN_NAME = "Claude Agent Turn"
+AGENT_NAME = "claude"
+AGENT_TURN_NAME = "Claude Agent Turn"
+REPO_CONTEXT_TTL_S = 30.0
+REPO_CONTEXT_GIT_TIMEOUT_S = 0.5
+_REPO_CONTEXT_CACHE: Dict[str, Tuple[float, Dict[str, Any]]] = {}
 
 # ----------------- Logging -----------------
 def _log(level: str, message: str) -> None:
@@ -93,6 +97,158 @@ def warn(msg: str) -> None:
 def error(msg: str) -> None:
     _log("ERROR", msg)
 
+
+def empty_repo_context(
+    cwd: Optional[str] = None,
+    cwd_source: str = "unavailable",
+    available: bool = False,
+    error: str = "",
+    is_git_repo: bool = False,
+) -> Dict[str, Any]:
+    return {
+        "cwd": str(cwd or ""),
+        "cwd_source": cwd_source or "unavailable",
+        "git_context_available": bool(available),
+        "git_context_error": error or "",
+        "is_git_repo": bool(is_git_repo),
+        "git_root": "",
+        "git_remote": "",
+        "git_remote_host": "",
+        "git_repo_owner": "",
+        "git_repo_name": "",
+        "git_repo_slug": "",
+        "git_branch": "",
+        "git_commit": "",
+    }
+
+
+def sanitize_git_remote(remote: Optional[str]) -> Dict[str, str]:
+    empty = {
+        "git_remote": "",
+        "git_remote_host": "",
+        "git_repo_owner": "",
+        "git_repo_name": "",
+        "git_repo_slug": "",
+    }
+    raw = str(remote or "").strip()
+    if not raw:
+        return empty
+
+    try:
+        if "://" in raw:
+            parsed = urlparse(raw)
+            host = parsed.hostname or ""
+            parts = [part for part in parsed.path.strip("/").split("/") if part]
+        else:
+            scp_like = re.match(r"^[^@]+@([^:]+):(.+)$", raw)
+            if scp_like:
+                host = scp_like.group(1)
+                parts = [part for part in scp_like.group(2).strip("/").split("/") if part]
+            else:
+                parsed = urlparse(f"ssh://{raw}")
+                host = parsed.hostname or ""
+                parts = [part for part in parsed.path.strip("/").split("/") if part]
+
+        if len(parts) < 2 or not host:
+            return empty
+        owner = parts[-2]
+        repo = parts[-1]
+        if repo.endswith(".git"):
+            repo = repo[:-4]
+        if not owner or not repo:
+            return empty
+        slug = f"{owner}/{repo}"
+        return {
+            "git_remote": f"{host}/{slug}",
+            "git_remote_host": host,
+            "git_repo_owner": owner,
+            "git_repo_name": repo,
+            "git_repo_slug": slug,
+        }
+    except Exception:
+        return empty
+
+
+def run_git_command(cwd: str, args: List[str], timeout_s: float = REPO_CONTEXT_GIT_TIMEOUT_S) -> Tuple[bool, str, str]:
+    try:
+        result = subprocess.run(
+            ["git", "-C", cwd, *args],
+            text=True,
+            capture_output=True,
+            timeout=timeout_s,
+            check=False,
+        )
+        return result.returncode == 0, (result.stdout or "").strip(), (result.stderr or "").strip()
+    except subprocess.TimeoutExpired:
+        return False, "", "timeout"
+    except FileNotFoundError:
+        return False, "", "git_unavailable"
+    except Exception:
+        return False, "", "git_error"
+
+
+def collect_repo_context(cwd: Optional[str], cwd_source: str = "unavailable") -> Dict[str, Any]:
+    cwd_text = str(cwd or "").strip()
+    if not cwd_text:
+        return empty_repo_context(error="missing_cwd")
+
+    path = Path(cwd_text)
+    if not path.exists():
+        return empty_repo_context(cwd_text, cwd_source, available=False, error="missing_cwd")
+
+    cache_key = str(path.resolve())
+    cached = _REPO_CONTEXT_CACHE.get(cache_key)
+    now = time.time()
+    if cached and now - cached[0] <= REPO_CONTEXT_TTL_S:
+        context = dict(cached[1])
+        context["cwd_source"] = cwd_source or context.get("cwd_source") or "unavailable"
+        return context
+
+    ok, inside, error = run_git_command(cwd_text, ["rev-parse", "--is-inside-work-tree"])
+    if not ok:
+        reason = error if error in ("timeout", "git_unavailable") else ""
+        if reason:
+            context = empty_repo_context(cwd_text, cwd_source, available=False, error=reason)
+        else:
+            context = empty_repo_context(cwd_text, cwd_source, available=True, is_git_repo=False)
+        _REPO_CONTEXT_CACHE[cache_key] = (now, dict(context))
+        return context
+    if inside.lower() != "true":
+        context = empty_repo_context(cwd_text, cwd_source, available=True, is_git_repo=False)
+        _REPO_CONTEXT_CACHE[cache_key] = (now, dict(context))
+        return context
+
+    context = empty_repo_context(cwd_text, cwd_source, available=True, is_git_repo=True)
+
+    ok_root, root, root_error = run_git_command(cwd_text, ["rev-parse", "--show-toplevel"])
+    if not ok_root and root_error in ("timeout", "git_unavailable"):
+        context["git_context_available"] = False
+        context["git_context_error"] = root_error
+        _REPO_CONTEXT_CACHE[cache_key] = (now, dict(context))
+        return context
+    context["git_root"] = root
+
+    ok_remote, remote, remote_error = run_git_command(cwd_text, ["config", "--get", "remote.origin.url"])
+    if ok_remote and remote:
+        remote_context = sanitize_git_remote(remote)
+        context.update(remote_context)
+        if not remote_context["git_remote"]:
+            context["git_context_error"] = "remote_parse_failed"
+    elif remote_error in ("timeout", "git_unavailable"):
+        context["git_context_available"] = False
+        context["git_context_error"] = remote_error
+
+    ok_branch, branch, _branch_error = run_git_command(cwd_text, ["branch", "--show-current"])
+    if ok_branch:
+        context["git_branch"] = branch
+
+    ok_commit, commit, _commit_error = run_git_command(cwd_text, ["rev-parse", "--short", "HEAD"])
+    if ok_commit:
+        context["git_commit"] = commit
+
+    _REPO_CONTEXT_CACHE[cache_key] = (now, dict(context))
+    return context
+
 # ----------------- State locking (best-effort) -----------------
 class FileLock:
     def __init__(self, path: Path, timeout_s: float = 2.0):
@@ -166,6 +322,53 @@ def read_hook_payload() -> Dict[str, Any]:
     except Exception:
         return {}
 
+
+def first_string(*values: Any) -> Optional[str]:
+    for value in values:
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    return None
+
+
+def find_value(obj: Any, keys: Tuple[str, ...]) -> Optional[str]:
+    if isinstance(obj, dict):
+        for key, value in obj.items():
+            if key in keys and isinstance(value, str) and value.strip():
+                return value.strip()
+            found = find_value(value, keys)
+            if found:
+                return found
+    elif isinstance(obj, list):
+        for item in obj:
+            found = find_value(item, keys)
+            if found:
+                return found
+    return None
+
+
+def resolve_payload_cwd(payload: Dict[str, Any]) -> Tuple[Optional[str], str]:
+    candidate = find_value(
+        payload,
+        (
+            "cwd",
+            "currentWorkingDirectory",
+            "current_working_directory",
+            "workspace",
+            "workspace_path",
+            "workspacePath",
+            "project_dir",
+            "projectDir",
+        ),
+    )
+    text = first_string(candidate)
+    if text:
+        return text, "payload"
+    try:
+        return os.getcwd(), "process"
+    except Exception:
+        return None, "unavailable"
+
+
 def extract_session_transcript_and_user(payload: Dict[str, Any]) -> Tuple[Optional[str], Optional[Path], Optional[str]]:
     """
     Tries a few plausible field names; exact keys can vary across hook types/versions.
@@ -734,6 +937,7 @@ class Turn:
     assistant_msgs: List[Dict[str, Any]]
     tool_results_by_id: Dict[str, Any]
     context_msgs: List[Dict[str, Any]] = field(default_factory=list)
+    repo_context: Dict[str, Any] = field(default_factory=dict)
 
 def is_skill_context_user_msg(msg: Dict[str, Any]) -> bool:
     if get_role(msg) != "user" or is_tool_result(msg):
@@ -868,6 +1072,7 @@ def emit_turn(
         skill_use_events=skill_use_events,
     )
     skill_summary = summarize_skill_usages(skill_usages)
+    repo_context = dict(getattr(turn, "repo_context", {}) or collect_repo_context(None))
 
     # attach tool outputs
     for c in tool_calls:
@@ -883,11 +1088,11 @@ def emit_turn(
     with propagate_attributes(
         user_id=user_id,
         session_id=session_id,
-        trace_name=AGENT_TURN_NAME,
-        tags=[AGENT_NAME],
-    ):
-        with langfuse.start_as_current_observation(
-            name=AGENT_TURN_NAME,
+        trace_name=AGENT_TURN_NAME,
+        tags=[AGENT_NAME],
+    ):
+        with langfuse.start_as_current_observation(
+            name=AGENT_TURN_NAME,
             input={"role": "user", "content": user_text},
             output={"role": "assistant", "content": assistant_text},
             metadata={
@@ -897,6 +1102,7 @@ def emit_turn(
                 "session_id": session_id,
                 "turn_number": turn_num,
                 "transcript_path": str(transcript_path),
+                **repo_context,
                 "user_text": user_text_meta,
                 "skills": skill_summary,
             },
@@ -1001,6 +1207,8 @@ def main() -> int:
                 return 0
 
             turns = build_turns(msgs)
+            cwd, cwd_source = resolve_payload_cwd(payload)
+            repo_context = collect_repo_context(cwd, cwd_source)
             if not turns:
                 write_session_state(state, key, ss)
                 save_state(state)
@@ -1011,6 +1219,7 @@ def main() -> int:
             for t in turns:
                 emitted += 1
                 turn_num = ss.turn_count + emitted
+                t.repo_context = repo_context
                 try:
                     emit_turn(langfuse, session_id, user_id, turn_num, t, transcript_path)
                 except Exception as e:

package/package.json

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

package/scripts/opencode-langfuse-setup.mjs

@@ -129,6 +129,7 @@ function getPatchedLangfuseDistIndexJs() {
     'import { promises as fs } from "node:fs";',
     'import os from "node:os";',
     'import path from "node:path";',
+    'import { execFileSync } from "node:child_process";',
     'import { NodeSDK } from "@opentelemetry/sdk-node";',
     'import { trace } from "@opentelemetry/api";',
     "",
@@ -226,6 +227,129 @@ function getPatchedLangfuseDistIndexJs() {
     "",
     "const writeMetric = (span, key, value) => writeSpanAttribute(span, `langfuse.observation.metadata.${key}`, value);",
     "",
+    "const emptyRepoContext = (cwd = '', cwdSource = 'unavailable', available = false, error = '', isGitRepo = false) => ({",
+    "  cwd: String(cwd || ''),",
+    "  cwd_source: cwdSource || 'unavailable',",
+    "  git_context_available: Boolean(available),",
+    "  git_context_error: error || '',",
+    "  is_git_repo: Boolean(isGitRepo),",
+    "  git_root: '',",
+    "  git_remote: '',",
+    "  git_remote_host: '',",
+    "  git_repo_owner: '',",
+    "  git_repo_name: '',",
+    "  git_repo_slug: '',",
+    "  git_branch: '',",
+    "  git_commit: '',",
+    "});",
+    "",
+    "const sanitizeGitRemote = (remote) => {",
+    "  const empty = { git_remote: '', git_remote_host: '', git_repo_owner: '', git_repo_name: '', git_repo_slug: '' };",
+    "  const raw = String(remote || '').trim();",
+    "  if (!raw) return empty;",
+    "  try {",
+    "    let host = '';",
+    "    let parts = [];",
+    "    if (raw.includes('://')) {",
+    "      const parsed = new URL(raw);",
+    "      host = parsed.hostname;",
+    "      parts = parsed.pathname.replace(/^\\/+|\\/+$/g, '').split('/').filter(Boolean);",
+    "    } else {",
+    "      const scp = raw.match(/^[^@]+@([^:]+):(.+)$/);",
+    "      if (scp) {",
+    "        host = scp[1];",
+    "        parts = scp[2].replace(/^\\/+|\\/+$/g, '').split('/').filter(Boolean);",
+    "      } else {",
+    "        const parsed = new URL(`ssh://${raw}`);",
+    "        host = parsed.hostname;",
+    "        parts = parsed.pathname.replace(/^\\/+|\\/+$/g, '').split('/').filter(Boolean);",
+    "      }",
+    "    }",
+    "    if (!host || parts.length < 2) return empty;",
+    "    const owner = parts[parts.length - 2];",
+    "    const repo = parts[parts.length - 1].replace(/\\.git$/i, '');",
+    "    if (!owner || !repo) return empty;",
+    "    const slug = `${owner}/${repo}`;",
+    "    return { git_remote: `${host}/${slug}`, git_remote_host: host, git_repo_owner: owner, git_repo_name: repo, git_repo_slug: slug };",
+    "  } catch {",
+    "    return empty;",
+    "  }",
+    "};",
+    "",
+    "const runGit = (cwd, args) => {",
+    "  try {",
+    "    const stdout = execFileSync('git', ['-C', cwd, ...args], { encoding: 'utf8', timeout: 500, stdio: ['ignore', 'pipe', 'ignore'] });",
+    "    return { ok: true, stdout: String(stdout || '').trim(), error: '' };",
+    "  } catch (error) {",
+    "    if (error && error.code === 'ETIMEDOUT') return { ok: false, stdout: '', error: 'timeout' };",
+    "    if (error && error.code === 'ENOENT') return { ok: false, stdout: '', error: 'git_unavailable' };",
+    "    return { ok: false, stdout: '', error: 'git_error' };",
+    "  }",
+    "};",
+    "",
+    "const repoContextCache = new Map();",
+    'const collectRepoContext = (cwd, cwdSource = "process") => {',
+    "  const cwdText = String(cwd || '').trim();",
+    "  if (!cwdText) return emptyRepoContext('', 'unavailable', false, 'missing_cwd');",
+    "  const now = Date.now();",
+    "  const cached = repoContextCache.get(cwdText);",
+    "  if (cached && now - cached.time <= 30000) return { ...cached.context, cwd_source: cwdSource || cached.context.cwd_source };",
+    "  let context = emptyRepoContext(cwdText, cwdSource, false, '', false);",
+    "  const inside = runGit(cwdText, ['rev-parse', '--is-inside-work-tree']);",
+    "  if (!inside.ok) {",
+    "    const reason = ['timeout', 'git_unavailable'].includes(inside.error) ? inside.error : '';",
+    "    context = reason ? emptyRepoContext(cwdText, cwdSource, false, reason, false) : emptyRepoContext(cwdText, cwdSource, true, '', false);",
+    "    repoContextCache.set(cwdText, { time: now, context });",
+    "    return context;",
+    "  }",
+    "  if (inside.stdout.toLowerCase() !== 'true') {",
+    "    context = emptyRepoContext(cwdText, cwdSource, true, '', false);",
+    "    repoContextCache.set(cwdText, { time: now, context });",
+    "    return context;",
+    "  }",
+    "  context = emptyRepoContext(cwdText, cwdSource, true, '', true);",
+    "  const root = runGit(cwdText, ['rev-parse', '--show-toplevel']);",
+    "  if (!root.ok && ['timeout', 'git_unavailable'].includes(root.error)) {",
+    "    context.git_context_available = false;",
+    "    context.git_context_error = root.error;",
+    "    repoContextCache.set(cwdText, { time: now, context });",
+    "    return context;",
+    "  }",
+    "  context.git_root = root.stdout || '';",
+    "  const remote = runGit(cwdText, ['config', '--get', 'remote.origin.url']);",
+    "  if (remote.ok && remote.stdout) {",
+    "    const sanitized = sanitizeGitRemote(remote.stdout);",
+    "    context = { ...context, ...sanitized };",
+    "    if (!sanitized.git_remote) context.git_context_error = 'remote_parse_failed';",
+    "  } else if (['timeout', 'git_unavailable'].includes(remote.error)) {",
+    "    context.git_context_available = false;",
+    "    context.git_context_error = remote.error;",
+    "  }",
+    "  const branch = runGit(cwdText, ['branch', '--show-current']);",
+    "  if (branch.ok) context.git_branch = branch.stdout || '';",
+    "  const commit = runGit(cwdText, ['rev-parse', '--short', 'HEAD']);",
+    "  if (commit.ok) context.git_commit = commit.stdout || '';",
+    "  repoContextCache.set(cwdText, { time: now, context });",
+    "  return context;",
+    "};",
+    "",
+    "const writeRepoContextMetrics = (span, context) => {",
+    "  const repoContext = context || {};",
+    "  writeSpanAttribute(span, 'langfuse.observation.metadata.cwd', repoContext.cwd);",
+    "  writeSpanAttribute(span, 'langfuse.observation.metadata.cwd_source', repoContext.cwd_source);",
+    "  writeSpanAttribute(span, 'langfuse.observation.metadata.git_context_available', repoContext.git_context_available);",
+    "  writeSpanAttribute(span, 'langfuse.observation.metadata.git_context_error', repoContext.git_context_error);",
+    "  writeSpanAttribute(span, 'langfuse.observation.metadata.is_git_repo', repoContext.is_git_repo);",
+    "  writeSpanAttribute(span, 'langfuse.observation.metadata.git_root', repoContext.git_root);",
+    "  writeSpanAttribute(span, 'langfuse.observation.metadata.git_remote', repoContext.git_remote);",
+    "  writeSpanAttribute(span, 'langfuse.observation.metadata.git_remote_host', repoContext.git_remote_host);",
+    "  writeSpanAttribute(span, 'langfuse.observation.metadata.git_repo_owner', repoContext.git_repo_owner);",
+    "  writeSpanAttribute(span, 'langfuse.observation.metadata.git_repo_name', repoContext.git_repo_name);",
+    "  writeSpanAttribute(span, 'langfuse.observation.metadata.git_repo_slug', repoContext.git_repo_slug);",
+    "  writeSpanAttribute(span, 'langfuse.observation.metadata.git_branch', repoContext.git_branch);",
+    "  writeSpanAttribute(span, 'langfuse.observation.metadata.git_commit', repoContext.git_commit);",
+    "};",
+    "",
     "const writeOpencodeMetricAttributes = (span, userId) => {",
     "  const attrs = span.attributes ?? {};",
     '  writeSpanAttribute(span, "oh.langfuse.source", "opencode");',
@@ -658,6 +782,7 @@ function getPatchedLangfuseDistIndexJs() {
     '    if (tokenMetrics.cacheRead !== undefined) span.setAttribute("langfuse.observation.metadata.cache_read_tokens", tokenMetrics.cacheRead);',
     '    if (tokenMetrics.reasoning !== undefined) span.setAttribute("langfuse.observation.metadata.reasoning_tokens", tokenMetrics.reasoning);',
     '    if (text) span.setAttribute("langfuse.observation.metadata.output_text_preview", text.slice(0, 512));',
+    '    writeRepoContextMetrics(span, collectRepoContext(process.cwd(), "process"));',
     "    span.end();",
     "    messageTextById.delete(messageId);",
     "    skillUsagesByMessageId.delete(messageId);",
@@ -719,7 +844,7 @@ function writeWindowsLauncherCmd(opencodeDir, { publicKey, secretKey, baseUrl, u
   cmd.push("  exit /b %ERRORLEVEL%");
   cmd.push(")");
   cmd.push("opencode %*");
-  fs.writeFileSync(p, cmd.join("\r\n") + "\r\n", "utf8");
+  fs.writeFileSync(p, cmd.join("\r\n") + "\r\n", "utf8");
   return p;
 }
 
@@ -754,7 +879,7 @@ function writeAutoUpdateHelper(target) {
       "exit /b 0",
       ""
     ];
-    fs.writeFileSync(helper, lines.join(os.EOL), "utf8");
+    fs.writeFileSync(helper, lines.join(os.EOL), "utf8");
     return helper;
   }
 
@@ -784,6 +909,18 @@ function unixAutoUpdateCommand(target) {
   return `${shQuote(writeAutoUpdateHelper(target))} || true`;
 }
 
+function windowsGitPathBootstrap() {
+  return [
+    "for /f \"delims=\" %%G in ('where.exe git.exe 2^>nul') do (",
+    "  set \"OH_LANGFUSE_GIT_EXE=%%G\"",
+    "  set \"npm_config_git=%%G\"",
+    "  set \"PATH=%%~dpG;%PATH%\"",
+    "  goto :oh_langfuse_git_ready",
+    ")",
+    ":oh_langfuse_git_ready"
+  ];
+}
+
 function writeWindowsUpdateCheckScript(dir) {
   if (process.platform !== "win32") return null;
   ensureDir(dir);
@@ -817,10 +954,11 @@ function writeOpencodeCommandShim(opencodeDir, { publicKey, secretKey, baseUrl,
     cmd.push(`set LANGFUSE_SECRET_KEY=${secretKey}`);
     cmd.push(`set LANGFUSE_BASEURL=${baseUrl}`);
     if (userId) cmd.push(`set LANGFUSE_USER_ID=${userId}`);
+    cmd.push(...windowsGitPathBootstrap());
     cmd.push(windowsAutoUpdateCommand("opencode"));
     cmd.push(`call ${cmdQuote(realOpencodeCli)} %*`);
     cmd.push("exit /b %ERRORLEVEL%");
-    fs.writeFileSync(shim, cmd.join("\r\n") + "\r\n", "utf8");
+    fs.writeFileSync(shim, cmd.join("\r\n") + "\r\n", "utf8");
     return { shim, shimDir };
   }
 
@@ -1080,7 +1218,7 @@ async function runNpmInstallOrThrow({ opencodeDir, pkgName = "opencode-plugin-la
   );
 }
 
-function setWindowsUserEnv({ publicKey, secretKey, baseUrl }) {
+function setWindowsUserEnv({ publicKey, secretKey, baseUrl }) {
   const cmd = [
     "$ErrorActionPreference = 'Stop';",
     `[Environment]::SetEnvironmentVariable('LANGFUSE_PUBLIC_KEY', ${psQuote(publicKey)}, 'User');`,
@@ -1090,10 +1228,10 @@ function setWindowsUserEnv({ publicKey, secretKey, baseUrl }) {
   const r = spawnSync("powershell", ["-NoProfile", "-Command", cmd], { stdio: "inherit", encoding: "utf8" });
   if (r.status !== 0) {
     throw new Error("写入用户级环境变量失败。");
-  }
-}
-
-function prependWindowsUserPath(dir) {
+  }
+}
+
+function prependWindowsUserPath(dir) {
   if (process.platform !== "win32") return false;
   const cmd = [
     "$ErrorActionPreference = 'Stop';",

package/scripts/real-self-verify.mjs

@@ -9,10 +9,10 @@ import { resolveOpencodeCli } from "./resolve-opencode-cli.mjs";
 const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const packageJson = JSON.parse(fs.readFileSync(path.join(rootDir, "package.json"), "utf8"));
 
-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 OPENCODE_NATIVE_AGENT_TURN_NAMES = new Set(["session.llm:ai.streamText.doStream"]);
+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 OPENCODE_NATIVE_AGENT_TURN_NAMES = new Set(["session.llm:ai.streamText.doStream"]);
 
 function parseArgs(argv) {
   const args = { _: [] };
@@ -323,34 +323,34 @@ function metadataValue(item, key) {
   const attrs = metadata.attributes || {};
   const prefixed = `langfuse.observation.metadata.${key}`;
   if (attrs[prefixed] !== undefined) return attrs[prefixed];
-  const ohKey = `oh.langfuse.${key}`;
-  if (attrs[ohKey] !== undefined) return attrs[ohKey];
-  if (metadata.source === "opencode" || attrs["oh.langfuse.source"] === "opencode") {
-    const usage = item?.usage || {};
-    if (key === "interaction_id") return `opencode:${metadata.user_id || attrs["oh.langfuse.user_id"] || "unknown"}:${item?.id || item?.traceId || item?.trace_id || "unknown"}`;
-    if (key === "interaction_count") return 1;
-    if (key === "token_metrics_available") {
-      return usage.input !== undefined || usage.output !== undefined || usage.total !== undefined || [
-        "ai.usage.inputTokens",
-        "ai.usage.outputTokens",
-        "ai.usage.totalTokens",
+  const ohKey = `oh.langfuse.${key}`;
+  if (attrs[ohKey] !== undefined) return attrs[ohKey];
+  if (metadata.source === "opencode" || attrs["oh.langfuse.source"] === "opencode") {
+    const usage = item?.usage || {};
+    if (key === "interaction_id") return `opencode:${metadata.user_id || attrs["oh.langfuse.user_id"] || "unknown"}:${item?.id || item?.traceId || item?.trace_id || "unknown"}`;
+    if (key === "interaction_count") return 1;
+    if (key === "token_metrics_available") {
+      return usage.input !== undefined || usage.output !== undefined || usage.total !== undefined || [
+        "ai.usage.inputTokens",
+        "ai.usage.outputTokens",
+        "ai.usage.totalTokens",
         "ai.usage.promptTokens",
         "ai.usage.completionTokens",
       ].some((attrKey) => attrs[attrKey] !== undefined);
     }
-    if (key === "tool_call_count" || key === "skill_use_count") return 0;
-    const tokenAttrMap = {
-      input_tokens: ["input", "ai.usage.inputTokens", "ai.usage.promptTokens"],
-      output_tokens: ["output", "ai.usage.outputTokens", "ai.usage.completionTokens"],
-      total_tokens: ["total", "ai.usage.totalTokens"],
-      cache_read_tokens: ["ai.usage.cachedInputTokens", "ai.usage.inputTokenDetails.cacheReadTokens"],
-      reasoning_tokens: ["ai.usage.reasoningTokens", "ai.usage.outputTokenDetails.reasoningTokens"],
-    };
-    for (const attrKey of tokenAttrMap[key] || []) {
-      if (usage[attrKey] !== undefined) return usage[attrKey];
-      if (attrs[attrKey] !== undefined) return attrs[attrKey];
-    }
-  }
+    if (key === "tool_call_count" || key === "skill_use_count") return 0;
+    const tokenAttrMap = {
+      input_tokens: ["input", "ai.usage.inputTokens", "ai.usage.promptTokens"],
+      output_tokens: ["output", "ai.usage.outputTokens", "ai.usage.completionTokens"],
+      total_tokens: ["total", "ai.usage.totalTokens"],
+      cache_read_tokens: ["ai.usage.cachedInputTokens", "ai.usage.inputTokenDetails.cacheReadTokens"],
+      reasoning_tokens: ["ai.usage.reasoningTokens", "ai.usage.outputTokenDetails.reasoningTokens"],
+    };
+    for (const attrKey of tokenAttrMap[key] || []) {
+      if (usage[attrKey] !== undefined) return usage[attrKey];
+      if (attrs[attrKey] !== undefined) return attrs[attrKey];
+    }
+  }
   return undefined;
 }
 
@@ -369,18 +369,18 @@ function metricInteractionId(item, target) {
     : metadataValue(item, "interaction_id");
 }
 
-function isAgentTurnObservation(item) {
-  const metadata = item?.metadata || {};
-  const attrs = metadata.attributes || {};
-  const isOpencode = metadata.source === "opencode" || attrs["oh.langfuse.source"] === "opencode";
-  if (/^(Claude|OpenCode|Codex) Agent Turn$/.test(String(item?.name || "")) || item?.name === "Agent Turn" || (!isOpencode && (metadataValue(item, "interaction_count") === 1 || metadataValue(item, "interaction_count") === "1"))) {
-    return true;
-  }
-  if (isOpencode && OPENCODE_NATIVE_AGENT_TURN_NAMES.has(String(item?.name || ""))) return true;
-  const hasModel = attrs["ai.model.id"] !== undefined || attrs["ai.model.provider"] !== undefined;
-  const isTool = attrs["ai.toolCall.name"] !== undefined || attrs["ai.toolCall.id"] !== undefined;
-  return isOpencode && hasModel && !isTool && item?.type === "GENERATION";
-}
+function isAgentTurnObservation(item) {
+  const metadata = item?.metadata || {};
+  const attrs = metadata.attributes || {};
+  const isOpencode = metadata.source === "opencode" || attrs["oh.langfuse.source"] === "opencode";
+  if (/^(Claude|OpenCode|Codex) Agent Turn$/.test(String(item?.name || "")) || item?.name === "Agent Turn" || (!isOpencode && (metadataValue(item, "interaction_count") === 1 || metadataValue(item, "interaction_count") === "1"))) {
+    return true;
+  }
+  if (isOpencode && OPENCODE_NATIVE_AGENT_TURN_NAMES.has(String(item?.name || ""))) return true;
+  const hasModel = attrs["ai.model.id"] !== undefined || attrs["ai.model.provider"] !== undefined;
+  const isTool = attrs["ai.toolCall.name"] !== undefined || attrs["ai.toolCall.id"] !== undefined;
+  return isOpencode && hasModel && !isTool && item?.type === "GENERATION";
+}
 
 function expectedAgentTurnName(target) {
   if (target === "claude") return "Claude Agent Turn";
@@ -389,32 +389,32 @@ function expectedAgentTurnName(target) {
   return "Agent Turn";
 }
 
-async function observationsForTrace(config, traceId, since) {
-  if (!traceId) return [];
-  const params = { limit: 100, fields: "core,basic,usage", traceId };
-  try {
-    return dataArray(await langfuseGet(config, "/v2/observations", params));
-  } catch (error) {
-    if (error.status !== 400 && error.status !== 404) throw error;
-  }
-  try {
-    return dataArray(await langfuseGet(config, "/observations", { limit: 100, traceId }));
-  } catch (error) {
-    if (error.status !== 400) throw error;
-  }
+async function observationsForTrace(config, traceId, since) {
+  if (!traceId) return [];
+  const params = { limit: 100, fields: "core,basic,usage", traceId };
+  try {
+    return dataArray(await langfuseGet(config, "/v2/observations", params));
+  } catch (error) {
+    if (error.status !== 400 && error.status !== 404) throw error;
+  }
+  try {
+    return dataArray(await langfuseGet(config, "/observations", { limit: 100, traceId }));
+  } catch (error) {
+    if (error.status !== 400) throw error;
+  }
   const fallback = dataArray(await langfuseGetLenient(config, "/observations", { limit: 100, fromTimestamp: since.toISOString() }));
   return fallback.filter((item) => item.traceId === traceId || item.trace_id === traceId);
 }
 
 function mergeMetricCandidates(items) {
   const out = [];
-  const seen = new Set();
-  for (const item of items || []) {
-    if (!item || typeof item !== "object") continue;
-    const key = idOf(item) || [item.name || "", item.traceId || item.trace_id || ""].join(":");
-    if (seen.has(key)) continue;
-    seen.add(key);
-    out.push(item);
+  const seen = new Set();
+  for (const item of items || []) {
+    if (!item || typeof item !== "object") continue;
+    const key = idOf(item) || [item.name || "", item.traceId || item.trace_id || ""].join(":");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(item);
   }
   return out;
 }
@@ -464,13 +464,13 @@ async function verifyMetricObservations(config, found, { since, target, marker =
 
   if (!interactions.length) {
     throw new Error(`Metric verification failed for ${target}: Agent Turn observation was not found for trace ${traceId || found.id}.`);
-  }
-
-  const expectedName = expectedAgentTurnName(target);
-  if (target !== "opencode" && !interactions.some((item) => item?.name === expectedName)) {
-    const names = interactions.map((item) => item?.name || "<unnamed>").join(", ");
-    throw new Error(`Metric verification failed for ${target}: expected observation name ${expectedName}, found ${names}.`);
-  }
+  }
+
+  const expectedName = expectedAgentTurnName(target);
+  if (target !== "opencode" && !interactions.some((item) => item?.name === expectedName)) {
+    const names = interactions.map((item) => item?.name || "<unnamed>").join(", ");
+    throw new Error(`Metric verification failed for ${target}: expected observation name ${expectedName}, found ${names}.`);
+  }
 
   const byInteractionId = new Map();
   const seenInteractionIds = new Set();
@@ -487,13 +487,33 @@ async function verifyMetricObservations(config, found, { since, target, marker =
         throw new Error(`Metric verification failed for ${target}: Agent Turn is missing ${key}.`);
       }
     }
-    if (target === "opencode") {
-      for (const key of ["interaction_id", "interaction_count", "token_metrics_available", "tool_call_count", "skill_use_count", "input_tokens", "output_tokens", "total_tokens"]) {
-        if (metadataValue(item, key) === undefined) {
-          throw new Error(`Metric verification failed for ${target}: effective metadata is missing ${key}.`);
-        }
-      }
-    }
+    const repoContextKeys = [
+      "cwd",
+      "cwd_source",
+      "git_context_available",
+      "git_context_error",
+      "is_git_repo",
+      "git_root",
+      "git_remote",
+      "git_remote_host",
+      "git_repo_owner",
+      "git_repo_name",
+      "git_repo_slug",
+      "git_branch",
+      "git_commit",
+    ];
+    for (const key of repoContextKeys) {
+      if (!hasMetadataKey(item, key)) {
+        throw new Error(`Metric verification failed for ${target}: Agent Turn is missing repo context ${key}.`);
+      }
+    }
+    if (target === "opencode") {
+      for (const key of ["interaction_id", "interaction_count", "token_metrics_available", "tool_call_count", "skill_use_count", "input_tokens", "output_tokens", "total_tokens"]) {
+        if (metadataValue(item, key) === undefined) {
+          throw new Error(`Metric verification failed for ${target}: effective metadata is missing ${key}.`);
+        }
+      }
+    }
     const tokenAvailable = metadataValue(item, "token_metrics_available");
     for (const tokenKey of ["input_tokens", "output_tokens", "total_tokens"]) {
       const value = metadataValue(item, tokenKey);