diff --git a/README.md b/README.md
index 3d367b2..a27a88f 100644
--- a/README.md
+++ b/README.md
@@ -9,9 +9,9 @@ Once enabled, every Codex turn shows up in Langfuse as a trace you can inspect,
 After each Codex turn, the plugin reads the session's rollout transcript and uploads it to Langfuse as a [trace](https://langfuse.com/docs/observability/data-model). The structure mirrors how Codex actually works:
 
 - **Turn** (`Codex Turn`, an [agent observation](https://langfuse.com/docs/observability/features/observation-types)) — one trace per turn, from your prompt to the final answer.
-- **Generations** — one per model response within the turn, with the model name, reasoning, assistant text, the tool calls it requested, and token usage.
-- **Tool calls** — `exec_command`, `apply_patch`, `spawn_agent`, MCP tools, web search, etc., each with its input, output, and error status. Failed commands are flagged as errors.
-- **Subagents** — subagent threads are resolved from their own rollout files and nested under the spawning turn.
+- **Generations** — one per model response within the turn, named `LLM` (or `LLM Subagent` inside subagent threads), with the model recorded on the observation plus reasoning, assistant text, the tool calls it requested, and token usage.
+- **Tool calls** — shell commands, `apply_patch`, `spawn_agent`, MCP tools, web searches, etc., each with its input, output, and error status. Observation names include what was called — the shell command (`exec_command: git status`), the search query (`web_search: …`), or the MCP server and tool (`server.tool`) — and failed commands are flagged as errors.
+- **Subagents** — subagent threads are resolved from their own rollout files and nested under the spawning turn as `Codex Subagent Turn`.
 - **Sessions** — all turns from one Codex session are grouped via the Codex thread id, so you can replay the whole session in Langfuse's [Sessions](https://langfuse.com/docs/observability/features/sessions) view.
 
 Interrupted turns (where you cancel mid-response) are still uploaded and flagged as interrupted.
diff --git a/plugins/tracing/dist/index.mjs b/plugins/tracing/dist/index.mjs
index 83fc783..b894005 100644
--- a/plugins/tracing/dist/index.mjs
+++ b/plugins/tracing/dist/index.mjs
@@ -46762,6 +46762,35 @@ function parseSession(lines) {
 				};
 				s.toolCalls.push(tc);
 				toolCallsById.set(tc.callId, tc);
+			} else if (p.type === "local_shell_call") {
+				const call = p;
+				const s = ensureStep(ts);
+				const tc = {
+					callId: call.call_id ?? call.id ?? `local_shell_${ts}_${s.toolCalls.length}`,
+					name: "local_shell",
+					args: call.action ?? void 0,
+					startTime: ts
+				};
+				s.toolCalls.push(tc);
+				toolCallsById.set(tc.callId, tc);
+			} else if (p.type === "web_search_call") {
+				const call = p;
+				const callId = call.id ?? `web_search_${ts}`;
+				const existing = toolCallsById.get(callId);
+				if (existing) {
+					existing.args = existing.args ?? call.action ?? void 0;
+					existing.endTime = Math.max(existing.endTime ?? ts, ts);
+				} else {
+					const s = ensureStep(ts);
+					const tc = {
+						callId,
+						name: "web_search",
+						args: call.action ?? void 0,
+						startTime: ts
+					};
+					s.toolCalls.push(tc);
+					toolCallsById.set(callId, tc);
+				}
 			} else if (p.type === "function_call_output" || p.type === "custom_tool_call_output") {
 				const out = p;
 				const tc = toolCallsById.get(out.call_id);
@@ -46807,6 +46836,28 @@ function parseSession(lines) {
 			});
 			else {
 				if (et === "collab_agent_spawn_end" && typeof p.new_thread_id === "string") turn.subagentThreadIds.push(p.new_thread_id);
+				if ((et === "mcp_tool_call_begin" || et === "mcp_tool_call_end") && typeof p.call_id === "string") {
+					const tc = toolCallsById.get(p.call_id);
+					const inv = p.invocation;
+					if (tc && typeof inv?.server === "string" && typeof inv?.tool === "string") tc.mcp = {
+						server: inv.server,
+						tool: inv.tool
+					};
+				}
+				if (et === "web_search_end" && typeof p.call_id === "string") {
+					let tc = toolCallsById.get(p.call_id);
+					if (!tc) {
+						tc = {
+							callId: p.call_id,
+							name: "web_search",
+							args: void 0,
+							startTime: ts
+						};
+						ensureStep(ts).toolCalls.push(tc);
+						toolCallsById.set(tc.callId, tc);
+					}
+					tc.args = tc.args ?? p.action ?? (typeof p.query === "string" ? { query: p.query } : void 0);
+				}
 				if (typeof p.call_id === "string" && et.endsWith("_end")) {
 					const tc = toolCallsById.get(p.call_id);
 					if (tc) {
@@ -46960,10 +47011,56 @@ function buildGenerationOutput(step, clip) {
 	}));
 	return Object.keys(output).length > 0 ? output : void 0;
 }
+/** Tools that execute a shell command; the command makes a better span name. */
+const SHELL_TOOL_NAMES = new Set([
+	"shell",
+	"exec_command",
+	"local_shell",
+	"container.exec"
+]);
+/** Collapse a value to a short single line usable inside a span name. */
+function previewText(value, max = 60) {
+	const oneLine = value.trim().replace(/\s+/g, " ");
+	return oneLine.length > max ? `${oneLine.slice(0, max - 1)}…` : oneLine;
+}
+function extractCommandText(args) {
+	if (args == null || typeof args !== "object") return void 0;
+	const cmd = args.command ?? args.cmd;
+	if (typeof cmd === "string" && cmd.trim()) return cmd;
+	if (Array.isArray(cmd) && cmd.length > 0 && cmd.every((c) => typeof c === "string")) {
+		const parts = cmd;
+		if (parts.length === 3 && /^(ba|z|fi)?sh$/.test(parts[0]) && /^-l?c$/.test(parts[1])) return parts[2];
+		return parts.join(" ");
+	}
+}
+/**
+* Observation name for a tool call: the tool name enriched with what it was
+* called with (shell command, search query, MCP server/tool), so the trace
+* tree shows *what* ran, not just which tool.
+*/
+function toolObservationName(tc) {
+	if (tc.mcp) return `${tc.mcp.server}.${tc.mcp.tool}`;
+	const name = tc.name || "tool";
+	if (SHELL_TOOL_NAMES.has(name)) {
+		const command = extractCommandText(tc.args);
+		if (command) return `${name}: ${previewText(command)}`;
+	}
+	if (name === "web_search" && tc.args != null && typeof tc.args === "object") {
+		const a = tc.args;
+		const detail = [
+			a.query,
+			a.url,
+			a.pattern
+		].find((v) => typeof v === "string" && v);
+		if (detail) return `${name}: ${previewText(detail)}`;
+	}
+	return name;
+}
 /** Emit a single turn (and its subagents) as a Langfuse observation tree. */
 async function emitTurn(turn, sessionMeta, ctx) {
 	const clip = makeClip(ctx.config.max_chars);
-	const root = startObservation("Codex Turn", {
+	const isSubagent = sessionMeta.isSubagentThread === true || ctx.parentObservation != null;
+	const root = startObservation(isSubagent ? "Codex Subagent Turn" : "Codex Turn", {
 		input: turn.userInput != null ? clip(turn.userInput) : void 0,
 		output: turn.finalOutput != null ? clip(turn.finalOutput) : void 0,
 		level: turn.aborted ? "WARNING" : void 0,
@@ -46985,7 +47082,7 @@ async function emitTurn(turn, sessionMeta, ctx) {
 	let previousToolResults = void 0;
 	for (let i = 0; i < turn.steps.length; i++) {
 		const step = turn.steps[i];
-		const generation = startObservation(turn.model ?? "codex.generation", {
+		const generation = startObservation(isSubagent ? "LLM Subagent" : "LLM", {
 			input: i === 0 ? turn.userInput != null ? clip(turn.userInput) : void 0 : previousToolResults,
 			output: buildGenerationOutput(step, clip),
 			model: turn.model,
@@ -47018,12 +47115,15 @@ async function emitTurn(turn, sessionMeta, ctx) {
 	root.end(new Date(turn.endTime));
 }
 function emitToolCall(tc, parent, clip, fallbackEnd) {
-	startObservation(tc.name || "tool", {
+	startObservation(toolObservationName(tc), {
 		input: tc.args,
 		output: tc.output != null ? clip(toText(tc.output)) : void 0,
 		level: tc.error ? "ERROR" : void 0,
 		statusMessage: tc.error ? clip(tc.error) : void 0,
-		metadata: { "codex.call_id": tc.callId }
+		metadata: {
+			"codex.call_id": tc.callId,
+			"codex.tool_name": tc.name || "tool"
+		}
 	}, {
 		asType: "tool",
 		startTime: new Date(tc.startTime),
@@ -47055,7 +47155,7 @@ async function convertRollout(rolloutFile, options) {
 		const seededParent = await seededTraceParent(options.config, sessionMeta, turnIndex + 1);
 		await propagateAttributes({
 			sessionId: sessionMeta.sessionId,
-			traceName: "Codex Turn",
+			traceName: sessionMeta.isSubagentThread ? "Codex Subagent Turn" : "Codex Turn",
 			...options.config.user_id ? { userId: options.config.user_id } : {},
 			...options.config.tags ? { tags: options.config.tags } : {},
 			...options.config.metadata ? { metadata: options.config.metadata } : {}
diff --git a/plugins/tracing/src/parse.ts b/plugins/tracing/src/parse.ts
index 9dbdda7..877ad96 100644
--- a/plugins/tracing/src/parse.ts
+++ b/plugins/tracing/src/parse.ts
@@ -5,7 +5,9 @@ import type {
   ResponseItemFunctionCall,
   ResponseItemFunctionCallOutput,
   ResponseItemCustomToolCall,
+  ResponseItemLocalShellCall,
   ResponseItemMessage,
+  ResponseItemWebSearchCall,
   RolloutLine,
   SessionMeta,
   TokenUsage,
@@ -224,6 +226,41 @@ export function parseSession(lines: RolloutLine[]): {
         };
         s.toolCalls.push(tc);
         toolCallsById.set(tc.callId, tc);
+      } else if (p.type === "local_shell_call") {
+        // Built-in local shell tool: the command lives in `action`, and
+        // exec_command_end / function_call_output enrich it like any function
+        // call.
+        const call = p as unknown as ResponseItemLocalShellCall;
+        const s = ensureStep(ts);
+        const tc: ToolCall = {
+          callId: call.call_id ?? call.id ?? `local_shell_${ts}_${s.toolCalls.length}`,
+          name: "local_shell",
+          args: call.action ?? undefined,
+          startTime: ts,
+        };
+        s.toolCalls.push(tc);
+        toolCallsById.set(tc.callId, tc);
+      } else if (p.type === "web_search_call") {
+        // Server-side web search: there is no output item, and the
+        // web_search_end event may be recorded before or after this item, so
+        // merge with an existing call when one was already registered.
+        const call = p as unknown as ResponseItemWebSearchCall;
+        const callId = call.id ?? `web_search_${ts}`;
+        const existing = toolCallsById.get(callId);
+        if (existing) {
+          existing.args = existing.args ?? call.action ?? undefined;
+          existing.endTime = Math.max(existing.endTime ?? ts, ts);
+        } else {
+          const s = ensureStep(ts);
+          const tc: ToolCall = {
+            callId,
+            name: "web_search",
+            args: call.action ?? undefined,
+            startTime: ts,
+          };
+          s.toolCalls.push(tc);
+          toolCallsById.set(callId, tc);
+        }
       } else if (p.type === "function_call_output" || p.type === "custom_tool_call_output") {
         const out = p as unknown as ResponseItemFunctionCallOutput;
         const tc = toolCallsById.get(out.call_id);
@@ -273,6 +310,32 @@ export function parseSession(lines: RolloutLine[]): {
         if (et === "collab_agent_spawn_end" && typeof p.new_thread_id === "string") {
           turn!.subagentThreadIds.push(p.new_thread_id);
         }
+        // MCP tool calls are function calls with a mangled name
+        // (`server__tool`); the begin/end events carry the clean server/tool
+        // split, which makes a much better observation name.
+        if (
+          (et === "mcp_tool_call_begin" || et === "mcp_tool_call_end") &&
+          typeof p.call_id === "string"
+        ) {
+          const tc = toolCallsById.get(p.call_id);
+          const inv = p.invocation;
+          if (tc && typeof inv?.server === "string" && typeof inv?.tool === "string") {
+            tc.mcp = { server: inv.server, tool: inv.tool };
+          }
+        }
+        // Web searches run server-side inside the model response. The end
+        // event can be recorded before the web_search_call response item, so
+        // register the call here if it is not known yet.
+        if (et === "web_search_end" && typeof p.call_id === "string") {
+          let tc = toolCallsById.get(p.call_id);
+          if (!tc) {
+            tc = { callId: p.call_id, name: "web_search", args: undefined, startTime: ts };
+            ensureStep(ts).toolCalls.push(tc);
+            toolCallsById.set(tc.callId, tc);
+          }
+          tc.args =
+            tc.args ?? p.action ?? (typeof p.query === "string" ? { query: p.query } : undefined);
+        }
         // Tool execution lifecycle events (exec_command_end, patch_apply_end,
         // mcp_tool_call_end, collab_*_end, …) match a call by id and add
         // timing, status, and output.
diff --git a/plugins/tracing/src/trace.ts b/plugins/tracing/src/trace.ts
index 89e04cd..6f965aa 100644
--- a/plugins/tracing/src/trace.ts
+++ b/plugins/tracing/src/trace.ts
@@ -155,6 +155,51 @@ function buildGenerationOutput(step: ModelStep, clip: Clip): Record<string, unkn
   return Object.keys(output).length > 0 ? output : undefined;
 }
 
+/** Tools that execute a shell command; the command makes a better span name. */
+const SHELL_TOOL_NAMES = new Set(["shell", "exec_command", "local_shell", "container.exec"]);
+
+/** Collapse a value to a short single line usable inside a span name. */
+function previewText(value: string, max = 60): string {
+  const oneLine = value.trim().replace(/\s+/g, " ");
+  return oneLine.length > max ? `${oneLine.slice(0, max - 1)}…` : oneLine;
+}
+
+function extractCommandText(args: unknown): string | undefined {
+  if (args == null || typeof args !== "object") return undefined;
+  const cmd =
+    (args as { command?: unknown; cmd?: unknown }).command ?? (args as { cmd?: unknown }).cmd;
+  if (typeof cmd === "string" && cmd.trim()) return cmd;
+  if (Array.isArray(cmd) && cmd.length > 0 && cmd.every((c) => typeof c === "string")) {
+    const parts = cmd as string[];
+    // Codex wraps most commands as ["bash", "-lc", "<script>"]; show the script.
+    if (parts.length === 3 && /^(ba|z|fi)?sh$/.test(parts[0]) && /^-l?c$/.test(parts[1])) {
+      return parts[2];
+    }
+    return parts.join(" ");
+  }
+  return undefined;
+}
+
+/**
+ * Observation name for a tool call: the tool name enriched with what it was
+ * called with (shell command, search query, MCP server/tool), so the trace
+ * tree shows *what* ran, not just which tool.
+ */
+function toolObservationName(tc: ToolCall): string {
+  if (tc.mcp) return `${tc.mcp.server}.${tc.mcp.tool}`;
+  const name = tc.name || "tool";
+  if (SHELL_TOOL_NAMES.has(name)) {
+    const command = extractCommandText(tc.args);
+    if (command) return `${name}: ${previewText(command)}`;
+  }
+  if (name === "web_search" && tc.args != null && typeof tc.args === "object") {
+    const a = tc.args as { query?: unknown; url?: unknown; pattern?: unknown };
+    const detail = [a.query, a.url, a.pattern].find((v) => typeof v === "string" && v);
+    if (detail) return `${name}: ${previewText(detail as string)}`;
+  }
+  return name;
+}
+
 /** Emit a single turn (and its subagents) as a Langfuse observation tree. */
 async function emitTurn(
   turn: Turn,
@@ -169,8 +214,12 @@ async function emitTurn(
 ): Promise<void> {
   const clip = makeClip(ctx.config.max_chars);
 
+  // A turn belongs to a subagent when its rollout is marked as a subagent
+  // thread or when it is being nested under a spawning turn.
+  const isSubagent = sessionMeta.isSubagentThread === true || ctx.parentObservation != null;
+
   const root = startObservation(
-    "Codex Turn",
+    isSubagent ? "Codex Subagent Turn" : "Codex Turn",
     {
       input: turn.userInput != null ? clip(turn.userInput) : undefined,
       output: turn.finalOutput != null ? clip(turn.finalOutput) : undefined,
@@ -198,7 +247,7 @@ async function emitTurn(
   for (let i = 0; i < turn.steps.length; i++) {
     const step = turn.steps[i];
     const generation = startObservation(
-      turn.model ?? "codex.generation",
+      isSubagent ? "LLM Subagent" : "LLM",
       {
         input:
           i === 0
@@ -254,13 +303,13 @@ function emitToolCall(
   fallbackEnd: number,
 ): void {
   const tool = startObservation(
-    tc.name || "tool",
+    toolObservationName(tc),
     {
       input: tc.args,
       output: tc.output != null ? clip(toText(tc.output)) : undefined,
       level: tc.error ? "ERROR" : undefined,
       statusMessage: tc.error ? clip(tc.error) : undefined,
-      metadata: { "codex.call_id": tc.callId },
+      metadata: { "codex.call_id": tc.callId, "codex.tool_name": tc.name || "tool" },
     },
     {
       asType: "tool",
@@ -312,7 +361,7 @@ export async function convertRollout(
     await propagateAttributes(
       {
         sessionId: sessionMeta.sessionId,
-        traceName: "Codex Turn",
+        traceName: sessionMeta.isSubagentThread ? "Codex Subagent Turn" : "Codex Turn",
         ...(options.config.user_id ? { userId: options.config.user_id } : {}),
         ...(options.config.tags ? { tags: options.config.tags } : {}),
         ...(options.config.metadata ? { metadata: options.config.metadata } : {}),
diff --git a/plugins/tracing/src/types.ts b/plugins/tracing/src/types.ts
index f54e1d1..5f1de5a 100644
--- a/plugins/tracing/src/types.ts
+++ b/plugins/tracing/src/types.ts
@@ -63,6 +63,25 @@ export type ResponseItemCustomToolCallOutput = {
   output: unknown;
 };
 
+/** Server-side web search performed by the model (no separate output item). */
+export type ResponseItemWebSearchCall = {
+  type: "web_search_call";
+  id?: string | null;
+  status?: string | null;
+  /** `{ type: "search", query }`, `{ type: "open_page", url }`, … */
+  action?: Record<string, unknown> | null;
+};
+
+/** Shell execution for models using the built-in local shell tool. */
+export type ResponseItemLocalShellCall = {
+  type: "local_shell_call";
+  id?: string | null;
+  call_id?: string | null;
+  status?: string | null;
+  /** `{ type: "exec", command: string[], … }` */
+  action?: Record<string, unknown> | null;
+};
+
 export type ResponseItemReasoning = {
   type: "reasoning";
   summary?: unknown[];
@@ -81,6 +100,8 @@ export type ResponseItem =
   | ResponseItemFunctionCallOutput
   | ResponseItemCustomToolCall
   | ResponseItemCustomToolCallOutput
+  | ResponseItemWebSearchCall
+  | ResponseItemLocalShellCall
   | ResponseItemReasoning
   | ResponseItemOther;
 
@@ -109,6 +130,11 @@ export type EventMsgPayload = {
   } | null;
   /** collab_agent_spawn_end */
   new_thread_id?: string | null;
+  /** mcp_tool_call_begin / mcp_tool_call_end */
+  invocation?: { server?: string; tool?: string; arguments?: unknown } | null;
+  /** web_search_end */
+  query?: string;
+  action?: Record<string, unknown> | null;
   /** exec_command_end / patch_apply_end */
   status?: string;
   exit_code?: number;
@@ -158,6 +184,8 @@ export type ToolCall = {
   endTime?: number;
   output?: unknown;
   error?: string;
+  /** Server/tool split for MCP calls, taken from mcp_tool_call_* events. */
+  mcp?: { server: string; tool: string };
 };
 
 /** A single model response within a turn (one LLM call). */
diff --git a/plugins/tracing/test/fixtures/sessions/2026/06/03/rollout-tools-main.jsonl b/plugins/tracing/test/fixtures/sessions/2026/06/03/rollout-tools-main.jsonl
new file mode 100644
index 0000000..746832e
--- /dev/null
+++ b/plugins/tracing/test/fixtures/sessions/2026/06/03/rollout-tools-main.jsonl
@@ -0,0 +1,18 @@
+{"timestamp":"2026-06-03T12:00:00.000Z","type":"session_meta","payload":{"id":"sess-tools","cli_version":"0.123.0","model_provider":"openai"}}
+{"timestamp":"2026-06-03T12:00:01.000Z","type":"event_msg","payload":{"type":"task_started","turn_id":"turn-tools"}}
+{"timestamp":"2026-06-03T12:00:01.200Z","type":"turn_context","payload":{"model":"gpt-5.4"}}
+{"timestamp":"2026-06-03T12:00:01.300Z","type":"event_msg","payload":{"type":"user_message","message":"Search the web, check git status, and file an issue"}}
+{"timestamp":"2026-06-03T12:00:02.000Z","type":"event_msg","payload":{"type":"web_search_begin","call_id":"ws-1"}}
+{"timestamp":"2026-06-03T12:00:02.500Z","type":"event_msg","payload":{"type":"web_search_end","call_id":"ws-1","query":"langfuse codex plugin","action":{"type":"search","query":"langfuse codex plugin"}}}
+{"timestamp":"2026-06-03T12:00:02.600Z","type":"response_item","payload":{"type":"web_search_call","id":"ws-1","status":"completed","action":{"type":"search","query":"langfuse codex plugin"}}}
+{"timestamp":"2026-06-03T12:00:03.000Z","type":"response_item","payload":{"type":"local_shell_call","call_id":"call-ls","status":"completed","action":{"type":"exec","command":["bash","-lc","git status"]}}}
+{"timestamp":"2026-06-03T12:00:03.500Z","type":"event_msg","payload":{"type":"exec_command_end","call_id":"call-ls","status":"completed","exit_code":0,"stdout":"clean","aggregated_output":"clean"}}
+{"timestamp":"2026-06-03T12:00:03.600Z","type":"response_item","payload":{"type":"function_call_output","call_id":"call-ls","output":"clean"}}
+{"timestamp":"2026-06-03T12:00:04.000Z","type":"response_item","payload":{"type":"function_call","name":"linear__create_issue","call_id":"call-mcp","arguments":"{\"title\":\"Ship it\"}"}}
+{"timestamp":"2026-06-03T12:00:04.100Z","type":"event_msg","payload":{"type":"mcp_tool_call_begin","call_id":"call-mcp","invocation":{"server":"linear","tool":"create_issue","arguments":{"title":"Ship it"}}}}
+{"timestamp":"2026-06-03T12:00:04.500Z","type":"event_msg","payload":{"type":"mcp_tool_call_end","call_id":"call-mcp","invocation":{"server":"linear","tool":"create_issue"},"status":"completed","result":{"content":[{"type":"text","text":"issue created"}]}}}
+{"timestamp":"2026-06-03T12:00:04.600Z","type":"response_item","payload":{"type":"function_call_output","call_id":"call-mcp","output":"issue created"}}
+{"timestamp":"2026-06-03T12:00:05.000Z","type":"response_item","payload":{"type":"message","role":"assistant","content":[{"type":"output_text","text":"Done: searched, checked git, filed the issue."}]}}
+{"timestamp":"2026-06-03T12:00:05.100Z","type":"event_msg","payload":{"type":"agent_message","message":"Done: searched, checked git, filed the issue."}}
+{"timestamp":"2026-06-03T12:00:05.200Z","type":"event_msg","payload":{"type":"token_count","info":{"last_token_usage":{"input_tokens":200,"output_tokens":40,"total_tokens":240,"cached_input_tokens":0,"reasoning_output_tokens":0},"total_token_usage":{"input_tokens":200,"output_tokens":40,"total_tokens":240,"cached_input_tokens":0,"reasoning_output_tokens":0}}}}
+{"timestamp":"2026-06-03T12:00:05.300Z","type":"event_msg","payload":{"type":"task_complete","turn_id":"turn-tools"}}
diff --git a/plugins/tracing/test/parse.test.ts b/plugins/tracing/test/parse.test.ts
index ebf609e..9dbbc90 100644
--- a/plugins/tracing/test/parse.test.ts
+++ b/plugins/tracing/test/parse.test.ts
@@ -153,6 +153,64 @@ describe("parseSession", () => {
     expect(turns[0].userInput).toBe("real question");
   });
 
+  it("captures web search, local shell, and MCP tool calls", () => {
+    const { turns } = parseSession(loadFixture("rollout-tools-main.jsonl"));
+
+    expect(turns).toHaveLength(1);
+    const tools = turns[0].steps.flatMap((s) => s.toolCalls);
+    expect(tools).toHaveLength(3);
+
+    // web_search_end (event) precedes the web_search_call item in the fixture;
+    // the two must merge into a single call.
+    const webSearch = tools.find((t) => t.name === "web_search");
+    expect(webSearch?.args).toEqual({ type: "search", query: "langfuse codex plugin" });
+    expect(webSearch?.endTime).toBe(Date.parse("2026-06-03T12:00:02.600Z"));
+
+    const shell = tools.find((t) => t.name === "local_shell");
+    expect(shell?.args).toMatchObject({ command: ["bash", "-lc", "git status"] });
+    expect(shell?.output).toBe("clean");
+
+    const mcp = tools.find((t) => t.name === "linear__create_issue");
+    expect(mcp?.mcp).toEqual({ server: "linear", tool: "create_issue" });
+  });
+
+  it("merges a web_search_call item with a later web_search_end event", () => {
+    const lines: RolloutLine[] = [
+      { timestamp: "2026-06-03T12:00:00.000Z", type: "session_meta", payload: { id: "s" } },
+      {
+        timestamp: "2026-06-03T12:00:01.000Z",
+        type: "event_msg",
+        payload: { type: "task_started", turn_id: "t" },
+      },
+      {
+        timestamp: "2026-06-03T12:00:02.000Z",
+        type: "response_item",
+        payload: {
+          type: "web_search_call",
+          id: "ws-1",
+          status: "completed",
+          action: { type: "search", query: "q" },
+        },
+      },
+      {
+        timestamp: "2026-06-03T12:00:02.500Z",
+        type: "event_msg",
+        payload: { type: "web_search_end", call_id: "ws-1", query: "q" },
+      },
+      {
+        timestamp: "2026-06-03T12:00:03.000Z",
+        type: "event_msg",
+        payload: { type: "task_complete", turn_id: "t" },
+      },
+    ];
+    const { turns } = parseSession(lines);
+    const tools = turns[0].steps.flatMap((s) => s.toolCalls);
+    expect(tools).toHaveLength(1);
+    expect(tools[0].name).toBe("web_search");
+    expect(tools[0].args).toEqual({ type: "search", query: "q" });
+    expect(tools[0].endTime).toBe(Date.parse("2026-06-03T12:00:02.500Z"));
+  });
+
   it("parses custom tool calls and their outputs", () => {
     const lines: RolloutLine[] = [
       { timestamp: "2026-06-03T12:00:00.000Z", type: "session_meta", payload: { id: "s" } },
diff --git a/plugins/tracing/test/trace.test.ts b/plugins/tracing/test/trace.test.ts
index 2c2c003..8e21ae4 100644
--- a/plugins/tracing/test/trace.test.ts
+++ b/plugins/tracing/test/trace.test.ts
@@ -83,10 +83,12 @@ describe("convertRollout", () => {
     // Backdated to the turn's task_started timestamp.
     expect(startMs(root!)).toBe(Date.parse("2026-06-03T10:00:01.000Z"));
 
-    // Two generations, both children of the root.
+    // Two generations, both children of the root, named "LLM" (the model name
+    // lives in the model attribute, not the observation name).
     const generations = spans.filter((s) => obsType(s) === "generation");
     expect(generations).toHaveLength(2);
     for (const gen of generations) {
+      expect(gen.name).toBe("LLM");
       expect(parentId(gen)).toBe(root!.spanContext().spanId);
       expect(attr(gen, "langfuse.observation.model.name")).toBe("gpt-5.4");
     }
@@ -99,7 +101,8 @@ describe("convertRollout", () => {
     // One tool span, nested under a generation, with the captured command output.
     const tools = spans.filter((s) => obsType(s) === "tool");
     expect(tools).toHaveLength(1);
-    expect(tools[0].name).toBe("exec_command");
+    expect(tools[0].name).toBe("exec_command: ls");
+    expect(attr(tools[0], "langfuse.observation.metadata.codex.tool_name")).toBe("exec_command");
     expect(attr(tools[0], "langfuse.observation.output")).toContain("file1.txt");
     expect(generations.map((g) => g.spanContext().spanId)).toContain(parentId(tools[0]));
   });
@@ -109,19 +112,23 @@ describe("convertRollout", () => {
     await convertRollout(path.join(dir, "rollout-parent.jsonl"), { config: baseConfig });
 
     const spans = exporter.getFinishedSpans();
-    const turnRoots = spans.filter((s) => s.name === "Codex Turn" && obsType(s) === "agent");
-    // Parent turn + nested subagent turn.
-    expect(turnRoots).toHaveLength(2);
-
-    const parent = turnRoots.find((s) => parentId(s) === undefined);
-    const child = turnRoots.find((s) => parentId(s) !== undefined);
+    const parent = spans.find((s) => s.name === "Codex Turn" && obsType(s) === "agent");
+    const child = spans.find((s) => s.name === "Codex Subagent Turn" && obsType(s) === "agent");
     expect(parent).toBeDefined();
     expect(child).toBeDefined();
+    expect(parentId(parent!)).toBeUndefined();
+    expect(parentId(child!)).toBeDefined();
 
     // The subagent turn is nested somewhere under the parent's trace.
     expect(child!.spanContext().traceId).toBe(parent!.spanContext().traceId);
     expect(attr(child!, "langfuse.observation.input")).toContain("tell a joke");
 
+    // Subagent generations are distinguishable from main-thread ones.
+    const childGeneration = spans.find(
+      (s) => obsType(s) === "generation" && parentId(s) === child!.spanContext().spanId,
+    );
+    expect(childGeneration?.name).toBe("LLM Subagent");
+
     // Aborted turn is flagged on the parent root.
     expect(attr(parent!, "langfuse.observation.level")).toBe("WARNING");
 
@@ -133,6 +140,28 @@ describe("convertRollout", () => {
     expect(attr(failedTool!, "langfuse.observation.status_message")).toContain("command failed");
   });
 
+  it("captures web search, local shell, and MCP tool calls with specific names", async () => {
+    const dir = stageFixtures();
+    await convertRollout(path.join(dir, "rollout-tools-main.jsonl"), { config: baseConfig });
+
+    const spans = exporter.getFinishedSpans();
+    const toolNames = spans
+      .filter((s) => obsType(s) === "tool")
+      .map((s) => s.name)
+      .sort();
+    expect(toolNames).toEqual([
+      "linear.create_issue",
+      "local_shell: git status",
+      "web_search: langfuse codex plugin",
+    ]);
+
+    const webSearch = spans.find((s) => s.name.startsWith("web_search"))!;
+    expect(attr(webSearch, "langfuse.observation.input")).toContain("langfuse codex plugin");
+
+    const shell = spans.find((s) => s.name.startsWith("local_shell"))!;
+    expect(attr(shell, "langfuse.observation.output")).toContain("clean");
+  });
+
   it("skips turns already recorded in the sidecar (dedup)", async () => {
     const dir = stageFixtures();
     const file = path.join(dir, "rollout-basic-main.jsonl");
@@ -155,7 +184,7 @@ describe("deterministic trace ids (trace_seed)", () => {
   const turnRoots = () =>
     exporter
       .getFinishedSpans()
-      .filter((s) => s.name === "Codex Turn")
+      .filter((s) => s.name === "Codex Turn" || s.name === "Codex Subagent Turn")
       .sort((a, b) => startMs(a) - startMs(b));
 
   it("derives the N-th main-thread turn's trace id from `${seed}:${N}`", async () => {