coze_lab 0.1.3 → 0.1.5

package/index.js

@@ -3,7 +3,10 @@
 
 // ─── 0. Constants ─────────────────────────────────────────────────────────────
 const CLIENT_ID   = '46371084383473718052118955183420.app.coze';
-const WORKSPACE_ID = '7645949103524380682';
+const WORKSPACE_ID = '7644910356078837760';
+// PPE 泳道：所有 cozeloop 上报 / OAuth 请求都带这两个 header（SDK 读 x_tt_env/x_use_ppe 环境变量自动注入）。
+const PPE_TT_ENV  = 'ppe_cozelab';
+const PPE_USE_PPE = '1';
 const COZE_API    = 'https://api.coze.cn';
 const CREDS_PATH  = require('path').join(require('os').homedir(), '.cozeloop', 'credentials.json');
 // Refresh when less than 10 minutes remain
@@ -3455,7 +3458,7 @@ async function _refreshToken(refreshTok) {
         const body = JSON.stringify({ grant_type: "refresh_token", client_id: _CLIENT_ID, refresh_token: refreshTok });
         const req = https.request(\`\${_COZE_API}/api/permission/oauth2/token\`, {
             method: "POST",
-            headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) },
+            headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body), "x-tt-env": "ppe_cozelab", "x-use-ppe": "1" },
         }, (res) => {
             let buf = "";
             res.on("data", c => buf += c);
@@ -3589,6 +3592,8 @@ export class CozeloopExporter {
             headers: {
                 "Authorization": authorization,
                 "cozeloop-workspace-id": workspaceId,
+                "x-tt-env": "ppe_cozelab",
+                "x-use-ppe": "1",
             },
         });
         this.provider = new BasicTracerProvider({ resource });
@@ -4117,20 +4122,61 @@ function parseArgs() {
 
 const VALID_AGENTS = ['claude-code', 'codex', 'openclaw'];
 
+// resolveAgent 读 ~/.coze/agents/<agentId>/config.json，返回 { framework, workspace, agentId, root }。
+// 目录或 config 不存在、framework 非法时直接报错退出。
+function resolveAgent(agentId) {
+  const root = path.join(os.homedir(), '.coze', 'agents', agentId);
+  const configPath = path.join(root, 'config.json');
+  if (!fs.existsSync(configPath)) {
+    errorBox([
+      `ERROR: agent "${agentId}" 不存在`,
+      '',
+      `未找到 ${configPath}`,
+      '请确认 agentId 正确，或先用 coze-bridge 创建该 agent。',
+    ]);
+  }
+  let cfg;
+  try {
+    cfg = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch (e) {
+    errorBox([`ERROR: 解析 ${configPath} 失败`, '', e.message]);
+  }
+  const framework = cfg.framework;
+  if (!VALID_AGENTS.includes(framework)) {
+    errorBox([
+      `ERROR: agent "${agentId}" 的 framework="${framework}" 不受支持`,
+      '',
+      `支持的类型: ${VALID_AGENTS.join(', ')}`,
+    ]);
+  }
+  return { framework, workspace: cfg.workspace || '', agentId, root };
+}
+
 function validateArgs(args) {
   if (args['logout'])  return { logout:  true };
   if (args['login'])   return { login:   true };
   if (args['status'])  return { status:  true };
   if (args['refresh']) return { refresh: true };
 
+  // 优先 --agent-id：读 ~/.coze/agents/<id>/config.json 的 framework 自动路由。
+  if (args['agent-id']) {
+    const resolved = resolveAgent(args['agent-id']);
+    return {
+      agent: resolved.framework,
+      agentId: resolved.agentId,
+      workspace: resolved.workspace,
+      agentRoot: resolved.root,
+      'codex-home': args['codex-home'],
+    };
+  }
+
   if (!args['agent']) {
     errorBox([
-      'ERROR: --agent is required',
+      'ERROR: --agent 或 --agent-id 至少提供一个',
       '',
       'Usage:',
-      '  --agent=claude-code',
-      '  --agent=codex',
-      '  --agent=openclaw',
+      '  --agent=claude-code | codex | openclaw   (全局配置)',
+      '  --agent-id=<id>                          (按 ~/.coze/agents/<id> 的 framework 自动路由)',
       '',
       'Other commands:',
       '  --status   Show authorization status',
@@ -4149,7 +4195,7 @@ function validateArgs(args) {
       '  --agent=openclaw',
     ]);
   }
-  return { agent: args['agent'] };
+  return { agent: args['agent'], 'codex-home': args['codex-home'] };
 }
 
 // ─── 4. Agent detection ──────────────────────────────────────────────────────
@@ -4337,22 +4383,31 @@ function mergeJson(filepath, mergeFn) {
   return mergeFn(existing);
 }
 
-function writeClaudeCodeHook(patToken, workspaceId, pythonCmd) {
+// writeClaudeCodeHook 配置 Claude Code 的 hook。
+// configBaseDir 缺省 process.cwd()（全局/项目级）；传入 agent 的 workspace 则 per-agent：
+// settings.json + 凭证写进 <configBaseDir>/.claude，仅该 agent（以此为 cwd 启动）生效。
+function writeClaudeCodeHook(patToken, workspaceId, pythonCmd, configBaseDir) {
   const hooksDir    = path.join(os.homedir(), '.claude', 'hooks');
   const hookScript  = path.join(hooksDir, 'cozeloop_hook.py');
-  const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
-  const localSettingsPath = path.join(process.cwd(), '.claude', 'settings.local.json');
-
-  // 1. Write Python hook scripts (trace + refresh)
+  const baseDir     = configBaseDir || process.cwd();
+  // per-agent 时 settings.json 写进 agent 的 .claude；全局时仍写 ~/.claude/settings.json。
+  const claudeDir   = configBaseDir
+    ? path.join(baseDir, '.claude')
+    : path.join(os.homedir(), '.claude');
+  const settingsPath = path.join(claudeDir, 'settings.json');
+  const localSettingsPath = path.join(baseDir, '.claude', 'settings.local.json');
+
+  // 1. Write Python hook scripts (trace + refresh) — 脚本放全局 ~/.claude/hooks，可共享
   ensureDir(hooksDir);
   writeHookScript(hookScript, readScript('claude-code/cozeloop_hook.py'));
   const refreshScript = path.join(hooksDir, 'cozeloop_refresh.py');
   writeHookScript(refreshScript, readScript('shared/cozeloop_refresh.py'));
 
-  // 2. Merge global settings.json — Stop (trace) + UserPromptSubmit (refresh)
-  const hookCmd    = `${pythonCmd} ~/.claude/hooks/cozeloop_hook.py`;
-  const refreshCmd = `${pythonCmd} ~/.claude/hooks/cozeloop_refresh.py`;
+  // 2. Merge settings.json — Stop (trace) + UserPromptSubmit (refresh)。用绝对路径。
+  const hookCmd    = `${pythonCmd} ${hookScript}`;
+  const refreshCmd = `${pythonCmd} ${refreshScript}`;
 
+  ensureDir(claudeDir);
   const settings = mergeJson(settingsPath, (existing) => {
     if (!existing.hooks) existing.hooks = {};
 
@@ -4377,14 +4432,17 @@ function writeClaudeCodeHook(patToken, workspaceId, pythonCmd) {
   } catch (e) {
     errorBox([`ERROR: Cannot write ${settingsPath}`, '', e.message]);
   }
-  ok(`Global hook registered in ${settingsPath}`);
+  ok(`Hook registered in ${settingsPath}`);
 
-  // 3. Write project-level credentials
-  ensureDir(path.join(process.cwd(), '.claude'));
+  // 3. Write credentials into <baseDir>/.claude/settings.local.json
+  ensureDir(path.join(baseDir, '.claude'));
   const localSettings = mergeJson(localSettingsPath, (existing) => {
     if (!existing.env) existing.env = {};
     existing.env.COZELOOP_WORKSPACE_ID = workspaceId;
     existing.env.COZELOOP_API_TOKEN    = patToken;
+    // PPE 泳道：cozeloop SDK 读这两个环境变量，自动注入 x-tt-env / x-use-ppe header
+    existing.env.x_tt_env  = PPE_TT_ENV;
+    existing.env.x_use_ppe = PPE_USE_PPE;
     return existing;
   });
   try {
@@ -4398,11 +4456,14 @@ function writeClaudeCodeHook(patToken, workspaceId, pythonCmd) {
   return { hookScript, settingsPath, localSettingsPath };
 }
 
-function writeCodexHook(token, workspaceId, pythonCmd) {
-  const hooksDir   = path.join(os.homedir(), '.codex', 'hooks');
+// writeCodexHook 把 hook 写进指定的 CODEX_HOME。codexHome 缺省 ~/.codex；
+// 传入动态目录（如 coze-bridge 的 /tmp/coze-bridge-codex-home-xxx）即可 per-agent 生效。
+function writeCodexHook(token, workspaceId, pythonCmd, codexHome) {
+  const home       = codexHome || path.join(os.homedir(), '.codex');
+  const hooksDir   = path.join(home, 'hooks');
   const hookScript = path.join(hooksDir, 'cozeloop_hook.py');
   const envFile    = path.join(hooksDir, 'cozeloop.env');
-  const hooksJson  = path.join(os.homedir(), '.codex', 'hooks.json');
+  const hooksJson  = path.join(home, 'hooks.json');
 
   // 1. Write Python hook scripts (trace + refresh)
   // Token is read from ~/.cozeloop/credentials.json at runtime
@@ -4416,6 +4477,9 @@ function writeCodexHook(token, workspaceId, pythonCmd) {
     `COZELOOP_WORKSPACE_ID=${workspaceId}`,
     `COZELOOP_API_TOKEN=${token}`,
     'TRACE_TO_COZELOOP=true',
+    // PPE 泳道：cozeloop SDK 读这两个环境变量，自动注入 x-tt-env / x-use-ppe header
+    `x_tt_env=${PPE_TT_ENV}`,
+    `x_use_ppe=${PPE_USE_PPE}`,
   ].join('\n') + '\n';
   try {
     fs.writeFileSync(envFile, envContent, { mode: 0o600 });
@@ -4425,8 +4489,9 @@ function writeCodexHook(token, workspaceId, pythonCmd) {
   ok(`Credentials written to ${envFile} (chmod 600)`);
 
   // 3. Merge hooks.json — Stop (trace) + SessionStart (refresh)
-  const hookCmd    = `set -a && . ~/.codex/hooks/cozeloop.env && set +a && ${pythonCmd} ~/.codex/hooks/cozeloop_hook.py`;
-  const refreshCmd = `${pythonCmd} ~/.codex/hooks/cozeloop_refresh.py`;
+  //    命令用绝对路径（CODEX_HOME 不一定是 ~/.codex）。
+  const hookCmd    = `set -a && . ${envFile} && set +a && ${pythonCmd} ${hookScript}`;
+  const refreshCmd = `${pythonCmd} ${refreshScript}`;
 
   const hooks = mergeJson(hooksJson, (existing) => {
     if (!existing.hooks) existing.hooks = {};
@@ -4551,6 +4616,17 @@ function writeOpenClawHook(token, workspaceId) {
     errorBox([`ERROR: Cannot write ${configPath}`, '', e.message]);
   }
   ok(`OpenClaw plugin configured in ${configPath}`);
+
+  // 自动重启 gateway，让新插件配置立即生效（不依赖 plugins install 的隐式重启）。
+  try {
+    const { execSync } = require('child_process');
+    info('Restarting OpenClaw gateway to apply hook changes...');
+    execSync('openclaw gateway restart', { stdio: 'pipe' });
+    ok('OpenClaw gateway restarted');
+  } catch (e) {
+    warn(`gateway restart 失败，请手动执行: openclaw gateway restart（${e.message}）`);
+  }
+
   return { configPath, pluginDir };
 }
 
@@ -4563,7 +4639,8 @@ function httpsPost(url, body) {
     const u = new URL(url);
     const req = https.request(
       { hostname: u.hostname, path: u.pathname + u.search, method: 'POST',
-        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) } },
+        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data),
+                   'x-tt-env': PPE_TT_ENV, 'x-use-ppe': PPE_USE_PPE } },
       (res) => {
         let buf = '';
         res.on('data', c => buf += c);
@@ -4579,7 +4656,9 @@ function httpsPost(url, body) {
 
 function httpsGet(url, headers) {
   return new Promise((resolve, reject) => {
-    const req = https.get(url, { headers }, (res) => {
+    // 合并 PPE 泳道 header
+    const h = { ...(headers || {}), 'x-tt-env': PPE_TT_ENV, 'x-use-ppe': PPE_USE_PPE };
+    const req = https.get(url, { headers: h }, (res) => {
       let buf = '';
       res.on('data', c => buf += c);
       res.on('end', () => resolve({ status: res.statusCode, body: buf }));
@@ -4845,9 +4924,9 @@ async function verifyWorkspace(token) {
 
 // ─── 9. Main ─────────────────────────────────────────────────────────────────
 const NEXT_STEP = {
-  'claude-code': 'Start a new Claude Code session to begin tracing.',
-  'codex':       'Start a new Codex session to begin tracing.',
-  'openclaw':    'Restart OpenClaw to begin tracing.',
+  'claude-code': 'Hook 已写入。请在当前 Claude Code 会话运行 /new（或重开会话）使 hook 生效——外部进程无法替你 /new。',
+  'codex':       'Hook 已写入。请重开 Codex 会话使 hook 生效——外部进程无法替你重启当前会话。',
+  'openclaw':    'OpenClaw gateway 已自动重启，trace 即刻生效。',
 };
 
 async function main() {
@@ -4913,17 +4992,22 @@ async function main() {
   }
 
   const { agent } = args;
+  // per-agent 路由时 agent 的 workspace（claude-code 用它做配置根目录）。
+  const agentWorkspace = args.workspace || '';
+  if (args.agentId) {
+    info(`目标 agent: ${args.agentId} (framework=${agent}, workspace=${agentWorkspace || 'N/A'})`);
+    console.log('');
+  }
 
   // Step 1: Authorize (load cached → refresh → device code)
-  // Step 2: Verify token works — if 401, refresh/re-auth and retry once
   info('Step 1/5: 检查授权状态...');
   let token = await getValidToken();
   console.log('');
 
+  // Step 2: Verify token works
   info('Step 2/5: 验证工作空间权限...');
   let verified = await verifyWorkspace(token);
   if (verified === null) {
-    // Token rejected by API — clear cached creds and re-authorize
     warn('Token 已失效，正在重新授权...');
     deleteCredentials();
     console.log('');
@@ -4952,27 +5036,33 @@ async function main() {
 
   // Step 5: Write hook configuration
   info('Step 5/5: Writing hook configuration...');
+  let written = {};
   if (agent === 'claude-code') {
-    writeClaudeCodeHook(token, WORKSPACE_ID, pythonCmd);
+    // per-agent 路由时把配置写进 agent 的 workspace（仅该 agent 生效）。
+    written = writeClaudeCodeHook(token, WORKSPACE_ID, pythonCmd, args.agentId ? agentWorkspace : undefined);
   } else if (agent === 'codex') {
-    writeCodexHook(token, WORKSPACE_ID, pythonCmd);
+    // CODEX_HOME 来源优先级：--codex-home= > 环境变量 CODEX_HOME > ~/.codex（缺省）。
+    const codexHome = args['codex-home'] || process.env.CODEX_HOME || undefined;
+    if (codexHome) info(`Codex 配置目录: ${codexHome}`);
+    written = writeCodexHook(token, WORKSPACE_ID, pythonCmd, codexHome);
   } else {
-    writeOpenClawHook(token, WORKSPACE_ID);
+    written = writeOpenClawHook(token, WORKSPACE_ID) || {};
   }
   console.log('');
 
-  // Success summary
+  // Success summary（用实际写入路径，per-agent / 自定义 CODEX_HOME 时也准确）
   const summaryLines = [
     `Agent:       ${agent} v${version}`,
   ];
+  if (args.agentId) summaryLines.push(`Agent ID:    ${args.agentId}`);
   if (agent === 'claude-code') {
-    summaryLines.push(`Hook script: ~/.claude/hooks/cozeloop_hook.py`);
-    summaryLines.push(`Config:      ~/.claude/settings.json`);
-    summaryLines.push(`Credentials: .claude/settings.local.json`);
+    summaryLines.push(`Hook script: ${written.hookScript || '~/.claude/hooks/cozeloop_hook.py'}`);
+    summaryLines.push(`Config:      ${written.settingsPath || '~/.claude/settings.json'}`);
+    summaryLines.push(`Credentials: ${written.localSettingsPath || '.claude/settings.local.json'}`);
   } else if (agent === 'codex') {
-    summaryLines.push(`Hook script: ~/.codex/hooks/cozeloop_hook.py`);
-    summaryLines.push(`Config:      ~/.codex/hooks.json`);
-    summaryLines.push(`Credentials: ~/.codex/hooks/cozeloop.env`);
+    summaryLines.push(`Hook script: ${written.hookScript || '~/.codex/hooks/cozeloop_hook.py'}`);
+    summaryLines.push(`Config:      ${written.hooksJson || '~/.codex/hooks.json'}`);
+    summaryLines.push(`Credentials: ${written.envFile || '~/.codex/hooks/cozeloop.env'}`);
   } else {
     summaryLines.push(`Config:      ~/.openclaw/openclaw.json`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coze_lab",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Configure local AI agents (Claude Code, Codex, OpenClaw) to report traces to CozeLoop",
   "keywords": [
     "cozeloop",

package/scripts/claude-code/cozeloop_hook.py

@@ -431,6 +431,29 @@ def _group_subagent_steps(progress_msgs: List[Dict[str, Any]]) -> List[Dict[str,
     return steps
 
 
+def _parse_ts(msg):
+    """从 transcript msg 的 timestamp 字段解析出 datetime（带时区）。失败返回 None。
+
+    Claude Code transcript 每条 user/assistant 消息都带 ISO8601 timestamp
+    （如 "2026-06-01T13:51:55.450Z"）。建 span 时用它做 start_time，
+    避免回放时所有 span 挤在几毫秒内、duration 全是几毫秒。
+    """
+    if not isinstance(msg, dict):
+        return None
+    ts = msg.get("timestamp")
+    if not ts or not isinstance(ts, str):
+        return None
+    try:
+        return datetime.fromisoformat(ts.replace("Z", "+00:00"))
+    except Exception:
+        return None
+
+
+def _ts_ms(dt):
+    """datetime → 毫秒时间戳（int）；None → None。"""
+    return int(dt.timestamp() * 1000) if dt is not None else None
+
+
 def group_messages_into_turns(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
     """Group messages into conversation turns (user -> assistant -> tool_results).
 
@@ -793,13 +816,31 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, history
     client = cozeloop.new_client(**client_kwargs)
 
     try:
-        with client.start_span(name="claude_code_request", span_type="main") as root_span:
+        # 整体时间范围：第一条 user 消息 → 最后一条 assistant 消息（真实 transcript 时间）
+        _all_ts = []
+        for _t in turns:
+            _u = _parse_ts(_t.get("user_message"))
+            if _u:
+                _all_ts.append(_u)
+            for _s in _t.get("steps", []):
+                _a = _parse_ts(_s.get("assistant_message"))
+                if _a:
+                    _all_ts.append(_a)
+        root_start_dt = min(_all_ts) if _all_ts else None
+        root_end_dt = max(_all_ts) if _all_ts else None
+
+        with client.start_span(name="claude_code_request", span_type="main", start_time=root_start_dt) as root_span:
             root_span.set_runtime(Runtime(library="claude-code"))
             root_tags = {
                 "thread_id": session_id,
                 "total_turns": len(turns),
                 "source": "claude_code"
             }
+            # 真实耗时写 tag（SDK finish 不支持显式结束时间，duration 用 tag 兜底）
+            if root_start_dt is not None and root_end_dt is not None:
+                root_tags["real_start_ms"] = _ts_ms(root_start_dt)
+                root_tags["real_end_ms"] = _ts_ms(root_end_dt)
+                root_tags["latency_ms"] = _ts_ms(root_end_dt) - _ts_ms(root_start_dt)
             root_baggage = {
                 "thread_id": session_id,
             }
@@ -836,14 +877,29 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, history
                     steps = turn.get("steps", [])
                     total_steps = len(steps)
 
-                    with client.start_span(name=f"turn_{i}", span_type="main") as turn_span:
+                    # turn 真实时间：start=user 消息时间，end=最后一个 step 的 assistant 时间
+                    turn_start_dt = _parse_ts(turn.get("user_message"))
+                    turn_end_dt = None
+                    for _s in steps:
+                        _a = _parse_ts(_s.get("assistant_message"))
+                        if _a:
+                            turn_end_dt = _a
+                    if turn_start_dt is None:
+                        turn_start_dt = turn_end_dt
+
+                    with client.start_span(name=f"turn_{i}", span_type="main", start_time=turn_start_dt) as turn_span:
                         turn_span.set_runtime(Runtime(library="claude-code"))
-                        turn_span.set_tags({
+                        _turn_tags = {
                             "thread_id": session_id,
                             "turn_index": i,
                             "total_steps": total_steps,
                             "source": "claude_code",
-                        })
+                        }
+                        if turn_start_dt is not None and turn_end_dt is not None:
+                            _turn_tags["real_start_ms"] = _ts_ms(turn_start_dt)
+                            _turn_tags["real_end_ms"] = _ts_ms(turn_end_dt)
+                            _turn_tags["latency_ms"] = _ts_ms(turn_end_dt) - _ts_ms(turn_start_dt)
+                        turn_span.set_tags(_turn_tags)
 
                         # Extract user input for this turn
                         user_message = turn.get("user_message", {}).get("message", {})
@@ -861,10 +917,23 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, history
                             raw_content = assistant_message_obj.get("content", [])
                             model_name = assistant_message_obj.get("model", "claude-code")
 
+                            # step 真实时间：start=本 step assistant 时间；end=下一 step assistant 时间（即本次模型调用+工具的耗时），无下一 step 则用 turn_end
+                            step_start_dt = _parse_ts(assistant_msg)
+                            if j + 1 < len(steps):
+                                step_end_dt = _parse_ts(steps[j + 1].get("assistant_message")) or turn_end_dt
+                            else:
+                                step_end_dt = turn_end_dt
+
                             # --- Create model span for this step ---
-                            with client.start_span(name=f"model_call_{j}", span_type="model") as model_span:
+                            with client.start_span(name=f"model_call_{j}", span_type="model", start_time=step_start_dt) as model_span:
                                 model_span.set_runtime(Runtime(library="claude-code"))
                                 model_span.set_model_name(model_name)
+                                if step_start_dt is not None and step_end_dt is not None:
+                                    model_span.set_tags({
+                                        "real_start_ms": _ts_ms(step_start_dt),
+                                        "real_end_ms": _ts_ms(step_end_dt),
+                                        "latency_ms": _ts_ms(step_end_dt) - _ts_ms(step_start_dt),
+                                    })
 
                                 # Set input: accumulated context up to this point
                                 model_span.set_input(ModelInput(
@@ -958,7 +1027,7 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, history
                                 span_type = "agent" if is_agent else "tool"
                                 span_name = f"agent_{tool_name}" if is_agent else f"tool_{tool_name}"
 
-                                with client.start_span(name=span_name, span_type=span_type) as tool_span:
+                                with client.start_span(name=span_name, span_type=span_type, start_time=step_start_dt) as tool_span:
                                     tool_span.set_runtime(Runtime(library="claude-code"))
                                     tags = {
                                         "tool_name": tool_name,

package/scripts/codex/cozeloop_hook.py

@@ -415,6 +415,28 @@ def truncate_text(text: str, limit: int = 12000) -> str:
 
 # --- Message Grouping ---
 
+def _parse_ts(obj):
+    """从 codex entry/payload 的 timestamp 解析 datetime（带时区）。失败返回 None。
+
+    Codex rollout JSONL 每条 entry 顶层带 ISO8601 timestamp。建 span 时用它做
+    start_time，避免回放时所有 span 挤在几毫秒内。
+    """
+    if not isinstance(obj, dict):
+        return None
+    ts = obj.get("timestamp") or obj.get("_ts")
+    if not ts or not isinstance(ts, str):
+        return None
+    try:
+        return datetime.fromisoformat(ts.replace("Z", "+00:00"))
+    except Exception:
+        return None
+
+
+def _ts_ms(dt):
+    """datetime → 毫秒时间戳（int）；None → None。"""
+    return int(dt.timestamp() * 1000) if dt is not None else None
+
+
 def group_messages_into_turns(entries: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
     """Group raw JSONL entries into conversation turns.
 
@@ -437,6 +459,9 @@ def group_messages_into_turns(entries: List[Dict[str, Any]]) -> List[Dict[str, A
     for entry in entries:
         entry_type = entry.get("type")
         payload = entry.get("payload", {})
+        # 把 entry 顶层 timestamp 注入 payload，供后续建 span 取真实时间
+        if isinstance(payload, dict) and entry.get("timestamp") and "_ts" not in payload:
+            payload["_ts"] = entry.get("timestamp")
 
         # --- Turn lifecycle events ---
         if entry_type == "event_msg":
@@ -645,13 +670,30 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
     ctx: List[Dict[str, Any]] = list(history_context) if history_context else []
 
     try:
-        with client.start_span(name="codex_request", span_type="main") as root_span:
+        # 整体时间范围：所有 user/assistant payload 的真实 timestamp 极值
+        _all_ts = []
+        for _t in turns:
+            _u = _parse_ts(_t.get("user_message"))
+            if _u:
+                _all_ts.append(_u)
+            for _a in _t.get("assistant_messages", []):
+                _ad = _parse_ts(_a)
+                if _ad:
+                    _all_ts.append(_ad)
+        root_start_dt = min(_all_ts) if _all_ts else None
+        root_end_dt = max(_all_ts) if _all_ts else None
+
+        with client.start_span(name="codex_request", span_type="main", start_time=root_start_dt) as root_span:
             root_span.set_runtime(Runtime(library="codex-cli"))
             root_tags = {
                 "thread_id": session_id,
                 "total_turns": len(turns),
                 "source": "codex_cli",
             }
+            if root_start_dt is not None and root_end_dt is not None:
+                root_tags["real_start_ms"] = _ts_ms(root_start_dt)
+                root_tags["real_end_ms"] = _ts_ms(root_end_dt)
+                root_tags["latency_ms"] = _ts_ms(root_end_dt) - _ts_ms(root_start_dt)
             root_baggage = {
                 "thread_id": session_id,
             }
@@ -689,20 +731,49 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
             # Process each turn
             for i, turn in enumerate(turns):
                 try:
-                    with client.start_span(name=f"turn_{i}", span_type="main") as turn_span:
+                    # turn 真实时间：start=user payload 时间；end=最后一条 assistant payload 时间
+                    turn_start_dt = _parse_ts(turn.get("user_message"))
+                    turn_end_dt = None
+                    for _a in turn.get("assistant_messages", []):
+                        _ad = _parse_ts(_a)
+                        if _ad:
+                            turn_end_dt = _ad
+                    if turn_start_dt is None:
+                        turn_start_dt = turn_end_dt
+
+                    with client.start_span(name=f"turn_{i}", span_type="main", start_time=turn_start_dt) as turn_span:
                         turn_span.set_runtime(Runtime(library="codex-cli"))
-                        turn_span.set_tags({
+                        _turn_tags = {
                             "thread_id": session_id,
                             "turn_index": i,
                             "turn_id": turn.get("turn_id", ""),
                             "source": "codex_cli",
-                        })
+                        }
+                        if turn_start_dt is not None and turn_end_dt is not None:
+                            _turn_tags["real_start_ms"] = _ts_ms(turn_start_dt)
+                            _turn_tags["real_end_ms"] = _ts_ms(turn_end_dt)
+                            _turn_tags["latency_ms"] = _ts_ms(turn_end_dt) - _ts_ms(turn_start_dt)
+                        turn_span.set_tags(_turn_tags)
 
                         # --- Model span for assistant response ---
                         if turn.get("assistant_messages"):
-                            with client.start_span(name="assistant_response", span_type="model") as model_span:
+                            # model span start：第一条 assistant payload 时间，回退到 turn 起点
+                            _model_start_dt = None
+                            for _a in turn.get("assistant_messages", []):
+                                _model_start_dt = _parse_ts(_a)
+                                if _model_start_dt:
+                                    break
+                            if _model_start_dt is None:
+                                _model_start_dt = turn_start_dt
+                            with client.start_span(name="assistant_response", span_type="model", start_time=_model_start_dt) as model_span:
                                 model_span.set_runtime(Runtime(library="codex-cli"))
                                 model_span.set_model_name(model_name)
+                                if _model_start_dt is not None and turn_end_dt is not None:
+                                    model_span.set_tags({
+                                        "real_start_ms": _ts_ms(_model_start_dt),
+                                        "real_end_ms": _ts_ms(turn_end_dt),
+                                        "latency_ms": _ts_ms(turn_end_dt) - _ts_ms(_model_start_dt),
+                                    })
 
                                 # Build input messages: history + current turn input
                                 turn_input = turn.get("input_messages", [])
@@ -770,7 +841,7 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
                         # --- Tool call spans ---
                         for tool_call in turn.get("tool_calls", []):
                             tool_name = tool_call.get("name", "unknown")
-                            with client.start_span(name=f"tool_{tool_name}", span_type="tool") as tool_span:
+                            with client.start_span(name=f"tool_{tool_name}", span_type="tool", start_time=turn_start_dt) as tool_span:
                                 tool_span.set_runtime(Runtime(library="codex-cli"))
                                 tool_span.set_tags({
                                     "tool_name": tool_name,
@@ -794,7 +865,7 @@ def send_turns_to_cozeloop(turns: List[Dict[str, Any]], session_id: str, model_n
                             agent_id = sc.get("agent_id") or "unknown"
                             nickname = sc.get("nickname") or agent_id
 
-                            with client.start_span(name=f"subagent_{nickname}", span_type="agent") as subagent_span:
+                            with client.start_span(name=f"subagent_{nickname}", span_type="agent", start_time=turn_start_dt) as subagent_span:
                                 subagent_span.set_runtime(Runtime(library="codex-cli"))
                                 subagent_span.set_tags({
                                     "agent_id": agent_id,

package/scripts/openclaw/dist/cozeloop-exporter.js

@@ -36,7 +36,7 @@ async function _refreshToken(refreshTok) {
         const body = JSON.stringify({ grant_type: "refresh_token", client_id: _CLIENT_ID, refresh_token: refreshTok });
         const req = https.request(`${_COZE_API}/api/permission/oauth2/token`, {
             method: "POST",
-            headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) },
+            headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body), "x-tt-env": "ppe_cozelab", "x-use-ppe": "1" },
         }, (res) => {
             let buf = "";
             res.on("data", c => buf += c);
@@ -170,6 +170,8 @@ export class CozeloopExporter {
             headers: {
                 "Authorization": authorization,
                 "cozeloop-workspace-id": workspaceId,
+                "x-tt-env": "ppe_cozelab",
+                "x-use-ppe": "1",
             },
         });
         this.provider = new BasicTracerProvider({ resource });