zwarm 1.3.10__py3-none-any.whl → 2.0.0__py3-none-any.whl

zwarm/adapters/codex_mcp.py

@@ -8,12 +8,14 @@ Uses codex mcp-server for true iterative conversations:
 
 from __future__ import annotations
 
+import hashlib
 import json
 import logging
 import queue
 import subprocess
 import threading
 import time
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Literal
 
@@ -30,6 +32,344 @@ from zwarm.core.models import (
 logger = logging.getLogger(__name__)
 
 
+# =============================================================================
+# MessageCollector: Robust event collection with deduplication
+# =============================================================================
+
+
+@dataclass
+class MessageSegment:
+    """A segment within an assistant turn (for future segment-aware rendering)."""
+    id: str
+    kind: Literal["assistant_text", "progress", "tool_call", "tool_result", "error"]
+    text: str
+    status: Literal["open", "closed"] = "open"
+    source_event_ids: set[str] = field(default_factory=set)
+
+
+class MessageCollector:
+    """
+    Collects and deduplicates messages from MCP event stream.
+
+    Solves the transcript rendering bugs by:
+    1. Deduplicating events by ID
+    2. Using priority-based message selection (item_completed > task_complete > streaming)
+    3. Tracking message sources for debugging
+    4. Never mixing streaming deltas with finalized messages
+
+    Priority order (highest to lowest):
+    - item_completed with AgentMessage/agent_message → DEFINITIVE
+    - task_complete.last_agent_message → FALLBACK ONLY
+    - streaming deltas → ONLY IF NO DEFINITIVE SOURCE
+    """
+
+    def __init__(self):
+        # Deduplication
+        self._seen_event_ids: set[str] = set()
+        self._seen_content_hashes: set[str] = set()  # Content-based dedup
+
+        # Message collection (priority-ordered)
+        self._definitive_messages: list[str] = []  # From item_completed
+        self._fallback_message: str | None = None  # From task_complete
+        self._streaming_buffer: list[str] = []  # Streaming deltas
+
+        # Metadata
+        self._conversation_id: str | None = None
+        self._session_id: str | None = None
+        self._token_usage: dict[str, Any] = {}
+        self._is_complete: bool = False
+
+        # Debug tracking
+        self._message_sources: list[tuple[str, str]] = []  # (source, text_preview)
+
+    def _extract_event_id(self, event: dict) -> str | None:
+        """Extract a unique event ID for deduplication."""
+        # Try various ID fields that MCP events might have
+        for key in ("id", "event_id", "item_id", "message_id"):
+            if key in event:
+                return str(event[key])
+
+        # For nested events, try params
+        params = event.get("params", {})
+        msg = params.get("msg", {})
+        for key in ("id", "event_id", "item_id"):
+            if key in msg:
+                return str(msg[key])
+
+        return None
+
+    def _content_hash(self, text: str) -> str:
+        """Create a hash of content for deduplication."""
+        # Normalize whitespace for comparison
+        normalized = " ".join(text.split())
+        return hashlib.md5(normalized.encode()).hexdigest()[:16]
+
+    def _is_duplicate_content(self, text: str) -> bool:
+        """Check if this content was already collected."""
+        if not text or not text.strip():
+            return True  # Empty is "duplicate" (skip it)
+
+        content_hash = self._content_hash(text)
+        if content_hash in self._seen_content_hashes:
+            return True
+
+        self._seen_content_hashes.add(content_hash)
+        return False
+
+    def _add_definitive_message(self, text: str, source: str) -> None:
+        """Add a definitive message (from item_completed)."""
+        if not text or not text.strip():
+            return
+
+        if self._is_duplicate_content(text):
+            logger.debug(f"Skipping duplicate message from {source}: {text[:50]}...")
+            return
+
+        self._definitive_messages.append(text)
+        self._message_sources.append((source, text[:50]))
+        logger.debug(f"Added definitive message from {source}: {text[:50]}...")
+
+    def _set_fallback_message(self, text: str, source: str) -> None:
+        """Set fallback message (from task_complete). Only used if no definitive."""
+        if not text or not text.strip():
+            return
+
+        # Only set if we don't have definitive messages
+        if self._definitive_messages:
+            logger.debug(f"Ignoring fallback from {source}: have definitive messages")
+            return
+
+        if self._is_duplicate_content(text):
+            logger.debug(f"Skipping duplicate fallback from {source}")
+            return
+
+        self._fallback_message = text
+        self._message_sources.append((source, text[:50]))
+
+    def _add_streaming_delta(self, text: str) -> None:
+        """Add streaming delta. Only used if no definitive messages at end."""
+        if text:
+            self._streaming_buffer.append(text)
+
+    def process_event(self, event: dict) -> bool:
+        """
+        Process a single MCP event.
+
+        Returns True if processing should continue, False if complete.
+        """
+        # 1. Check for event ID and dedupe
+        event_id = self._extract_event_id(event)
+        if event_id and event_id in self._seen_event_ids:
+            logger.debug(f"Skipping duplicate event: {event_id}")
+            return True
+        if event_id:
+            self._seen_event_ids.add(event_id)
+
+        # 2. Handle codex/event notifications
+        if event.get("method") == "codex/event":
+            params = event.get("params", {})
+            msg = params.get("msg", {})
+            msg_type = msg.get("type")
+
+            self._handle_codex_event(msg, msg_type)
+
+            # Check for completion events
+            if msg_type in ("task_complete", "task_completed"):
+                self._is_complete = True
+                return False
+
+        return True
+
+    def _handle_codex_event(self, msg: dict, msg_type: str | None) -> None:
+        """Handle a codex/event notification."""
+        if not msg_type:
+            return
+
+        # Session configuration
+        if msg_type == "session_configured":
+            self._session_id = msg.get("session_id")
+            logger.debug(f"Session configured: {self._session_id}")
+
+        # Item completed - DEFINITIVE SOURCE
+        elif msg_type == "item_completed":
+            self._handle_item_completed(msg)
+
+        # Direct agent message - DEFINITIVE SOURCE
+        elif msg_type == "agent_message":
+            text = msg.get("message", "") or msg.get("text", "") or msg.get("content", "")
+            self._add_definitive_message(text, "agent_message_event")
+
+        # Task complete - FALLBACK SOURCE
+        elif msg_type in ("task_complete", "task_completed"):
+            last_msg = msg.get("last_agent_message")
+            if last_msg:
+                self._set_fallback_message(last_msg, "task_complete")
+
+        # Token usage
+        elif msg_type == "token_count":
+            info = msg.get("info") or {}
+            if info:
+                usage = info.get("total_token_usage", {})
+                if usage:
+                    self._token_usage = {
+                        "input_tokens": usage.get("input_tokens", 0),
+                        "output_tokens": usage.get("output_tokens", 0),
+                        "cached_input_tokens": usage.get("cached_input_tokens", 0),
+                        "reasoning_tokens": usage.get("reasoning_output_tokens", 0),
+                        "total_tokens": usage.get("total_tokens", 0),
+                    }
+
+        # Streaming deltas - LOWEST PRIORITY
+        elif msg_type in ("text_delta", "content_block_delta", "message_delta", "text"):
+            delta = msg.get("delta", {})
+            text = delta.get("text", "") or msg.get("text", "")
+            self._add_streaming_delta(text)
+
+        # Response event - MEDIUM PRIORITY (treat as definitive)
+        elif msg_type == "response":
+            text = msg.get("response", "") or msg.get("text", "")
+            self._add_definitive_message(text, "response_event")
+
+        # Message event - check role
+        elif msg_type == "message":
+            role = msg.get("role", "").lower()
+            if role in ("assistant", "agent", ""):
+                text = msg.get("text", "") or msg.get("content", "")
+                if text and role != "user":
+                    self._add_definitive_message(text, "message_event")
+
+        # Output event
+        elif msg_type == "output":
+            text = msg.get("output", "") or msg.get("text", "") or msg.get("content", "")
+            self._add_definitive_message(text, "output_event")
+
+        # Completion variants
+        elif msg_type in ("item.completed", "response.completed"):
+            item = msg.get("item", {})
+            if item.get("type") == "agent_message":
+                text = item.get("text", "")
+                self._add_definitive_message(text, f"{msg_type}_event")
+            elif "text" in msg:
+                self._add_definitive_message(msg["text"], f"{msg_type}_direct")
+
+        # Error
+        elif msg_type == "error":
+            error_msg = msg.get("error", msg.get("message", str(msg)))
+            raise RuntimeError(f"Codex error: {error_msg}")
+
+    def _handle_item_completed(self, msg: dict) -> None:
+        """Handle item_completed event - the primary source of messages."""
+        item = msg.get("item", {})
+        item_type = item.get("type")
+
+        # AgentMessage - primary format
+        if item_type == "AgentMessage":
+            content = item.get("content", [])
+            for block in content:
+                if isinstance(block, dict) and block.get("text"):
+                    self._add_definitive_message(block["text"], "AgentMessage")
+                elif isinstance(block, str):
+                    self._add_definitive_message(block, "AgentMessage_str")
+
+        # agent_message - variant spelling
+        elif item_type == "agent_message":
+            text = item.get("text", "") or item.get("message", "")
+            if text:
+                self._add_definitive_message(text, "agent_message")
+            content = item.get("content", [])
+            for block in content:
+                if isinstance(block, dict) and block.get("text"):
+                    self._add_definitive_message(block["text"], "agent_message_content")
+                elif isinstance(block, str):
+                    self._add_definitive_message(block, "agent_message_content_str")
+
+        # Generic message with assistant role
+        elif item_type == "message":
+            role = item.get("role", "")
+            if role == "assistant":
+                content = item.get("content", [])
+                for block in content:
+                    if isinstance(block, dict) and block.get("text"):
+                        self._add_definitive_message(block["text"], "message_assistant")
+                    elif isinstance(block, str):
+                        self._add_definitive_message(block, "message_assistant_str")
+            # Also check text field directly
+            text = item.get("text", "")
+            if text:
+                self._add_definitive_message(text, "message_text")
+
+        # Function call output (for context, truncated)
+        elif item_type == "function_call_output":
+            output = item.get("output", "")
+            if output and len(output) < 1000:
+                # Don't add to messages, just log
+                logger.debug(f"Tool output: {output[:100]}...")
+
+    def set_conversation_id(self, conv_id: str | None) -> None:
+        """Set conversation ID from final result."""
+        if conv_id:
+            self._conversation_id = conv_id
+
+    @property
+    def conversation_id(self) -> str | None:
+        """Get the conversation ID."""
+        return self._conversation_id or self._session_id
+
+    @property
+    def token_usage(self) -> dict[str, Any]:
+        """Get token usage stats."""
+        return self._token_usage
+
+    @property
+    def is_complete(self) -> bool:
+        """Check if collection is complete."""
+        return self._is_complete
+
+    def get_messages(self) -> list[str]:
+        """
+        Get the final deduplicated message list.
+
+        Priority:
+        1. Definitive messages (from item_completed)
+        2. Fallback message (from task_complete)
+        3. Streaming buffer (only if no definitive or fallback)
+        """
+        # Prefer definitive messages
+        if self._definitive_messages:
+            logger.debug(f"Returning {len(self._definitive_messages)} definitive messages")
+            return self._definitive_messages
+
+        # Fall back to task_complete message
+        if self._fallback_message:
+            logger.debug("Returning fallback message from task_complete")
+            return [self._fallback_message]
+
+        # Last resort: streaming buffer
+        if self._streaming_buffer:
+            full_text = "".join(self._streaming_buffer)
+            if full_text.strip():
+                logger.debug(f"Returning streaming buffer ({len(self._streaming_buffer)} chunks)")
+                return [full_text]
+
+        return []
+
+    def get_response(self) -> str:
+        """Get the final response as a single string."""
+        messages = self.get_messages()
+        return "\n".join(messages) if messages else ""
+
+    def get_debug_info(self) -> dict:
+        """Get debug information about message collection."""
+        return {
+            "seen_event_ids": len(self._seen_event_ids),
+            "seen_content_hashes": len(self._seen_content_hashes),
+            "definitive_messages": len(self._definitive_messages),
+            "has_fallback": self._fallback_message is not None,
+            "streaming_chunks": len(self._streaming_buffer),
+            "message_sources": self._message_sources,
+        }
+
+
 class MCPClient:
     """
     Robust MCP client for communicating with codex mcp-server.
@@ -42,7 +382,18 @@ class MCPClient:
     of spawning new reader threads on timeout.
     """
 
-    def __init__(self):
+    # Default config overrides for zwarm-managed codex sessions
+    # These override ~/.codex/config.toml to ensure consistent behavior
+    # Only used as fallback if no config_path is provided
+    DEFAULT_CONFIG_OVERRIDES: dict[str, str] = {
+        "model_reasoning_effort": "high",  # Use 'high' for compatibility with all models
+    }
+
+    def __init__(
+        self,
+        config_path: Path | None = None,
+        config_overrides: dict[str, str] | None = None,
+    ):
         self._proc: subprocess.Popen | None = None
         self._proc_pid: int | None = None  # Track PID to detect restarts
         self._request_id = 0
@@ -53,6 +404,10 @@ class MCPClient:
         self._stdout_queue: queue.Queue[str | None] = queue.Queue()
         self._lock = threading.Lock()  # Protect writes only
         self._start_count = 0  # Track how many times we've started
+        # Config path for full isolation (preferred)
+        self._config_path = config_path
+        # Fallback: merge default overrides with any custom ones (used if no config_path)
+        self._config_overrides = {**self.DEFAULT_CONFIG_OVERRIDES, **(config_overrides or {})}
 
     def start(self) -> None:
         """Start the MCP server process."""
@@ -69,9 +424,19 @@ class MCPClient:
                 )
 
             self._start_count += 1
-            logger.info(f"Starting codex mcp-server... (start_count={self._start_count})")
+
+            # Build command - prefer config file for full isolation, fallback to overrides
+            cmd = ["codex", "mcp-server"]
+            if self._config_path and self._config_path.exists():
+                cmd.extend(["--config", str(self._config_path)])
+                logger.info(f"Starting codex mcp-server with config: {self._config_path} (start_count={self._start_count})")
+            else:
+                # Fallback to individual overrides
+                for key, value in self._config_overrides.items():
+                    cmd.extend(["-c", f'{key}="{value}"'])
+                logger.info(f"Starting codex mcp-server with overrides: {self._config_overrides} (start_count={self._start_count})")
             self._proc = subprocess.Popen(
-                ["codex", "mcp-server"],
+                cmd,
                 stdin=subprocess.PIPE,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
@@ -238,6 +603,12 @@ class MCPClient:
         """
         Call an MCP tool and collect streaming events.
 
+        Uses MessageCollector for robust deduplication and priority-based
+        message selection. This prevents the transcript rendering bugs:
+        - Message duplication
+        - Role contamination
+        - Turn mis-association
+
         Args:
             name: Tool name (codex, codex-reply)
             arguments: Tool arguments
@@ -260,14 +631,9 @@ class MCPClient:
         with self._lock:
             self._write(json.dumps(request) + "\n")
 
-        # Collect streaming events until final result
-        # Reader thread queues lines, we pull from queue with timeout
-        session_id = None
-        conversation_id = None  # Track conversation ID separately
-        agent_messages: list[str] = []
-        streaming_text: list[str] = []  # Accumulate streaming delta text
+        # Use MessageCollector for robust event handling
+        collector = MessageCollector()
         final_result = None
-        token_usage: dict[str, Any] = {}  # Track token usage
         start_time = time.time()
         all_events: list[dict] = []  # Keep ALL events for debugging
 
@@ -280,13 +646,10 @@ class MCPClient:
                 raise RuntimeError(f"MCP call timed out after {timeout}s ({event_count} events received)")
 
             # Read from queue with per-event timeout
-            # Empty string = timeout (process still alive, just waiting)
-            # None sentinel is handled inside _read_line (raises RuntimeError)
             line = self._read_line(timeout=30.0)
 
             if not line:
                 # Timeout waiting for event - process is still alive, just slow
-                # This is normal during long codex operations
                 logger.debug(f"Waiting for MCP event... (elapsed: {elapsed:.0f}s, events: {event_count})")
                 continue
 
@@ -303,192 +666,58 @@ class MCPClient:
                     final_result = event["result"]
                     # Extract conversation ID from final result
                     if isinstance(final_result, dict):
-                        conversation_id = final_result.get("conversationId") or final_result.get("conversation_id")
-                    logger.debug(f"Got final result after {event_count} events, conversation_id={conversation_id}")
+                        conv_id = final_result.get("conversationId") or final_result.get("conversation_id")
+                        collector.set_conversation_id(conv_id)
+                    logger.debug(f"Got final result after {event_count} events")
                     break
                 elif "error" in event:
                     error = event["error"]
                     raise RuntimeError(f"MCP tool error: {error.get('message', error)}")
 
-            # Process streaming events
-            if event.get("method") == "codex/event":
-                params = event.get("params", {})
-                msg = params.get("msg", {})
-                msg_type = msg.get("type")
-
-                # Log ALL event types to help debug missing messages
-                logger.debug(f"MCP event: type={msg_type}, keys={list(msg.keys())}")
-
-                if msg_type == "session_configured":
-                    session_id = msg.get("session_id")
-                    logger.debug(f"Session configured: {session_id}")
-
-                elif msg_type == "item_completed":
-                    item = msg.get("item", {})
-                    item_type = item.get("type")
-
-                    # Log ALL item_completed events to help debug
-                    logger.debug(f"item_completed: type={item_type}, keys={list(item.keys())}")
-
-                    # Agent text responses - codex uses "AgentMessage" type
-                    if item_type == "AgentMessage":
-                        content = item.get("content", [])
-                        for block in content:
-                            if isinstance(block, dict) and block.get("text"):
-                                agent_messages.append(block["text"])
-                            elif isinstance(block, str):
-                                agent_messages.append(block)
-
-                    # Also check for "agent_message" (lowercase) variant
-                    elif item_type == "agent_message":
-                        text = item.get("text", "") or item.get("message", "")
-                        if text:
-                            agent_messages.append(text)
-                        # Also check content array
-                        content = item.get("content", [])
-                        for block in content:
-                            if isinstance(block, dict) and block.get("text"):
-                                agent_messages.append(block["text"])
-                            elif isinstance(block, str):
-                                agent_messages.append(block)
-
-                    # Legacy format check
-                    elif item_type == "message" and item.get("role") == "assistant":
-                        content = item.get("content", [])
-                        for block in content:
-                            if isinstance(block, dict) and block.get("text"):
-                                agent_messages.append(block["text"])
-                            elif isinstance(block, str):
-                                agent_messages.append(block)
-
-                    # Generic message type - check for text/content
-                    elif item_type == "message":
-                        text = item.get("text", "")
-                        if text:
-                            agent_messages.append(text)
-                        content = item.get("content", [])
-                        if isinstance(content, str):
-                            agent_messages.append(content)
-                        elif isinstance(content, list):
-                            for block in content:
-                                if isinstance(block, dict) and block.get("text"):
-                                    agent_messages.append(block["text"])
-                                elif isinstance(block, str):
-                                    agent_messages.append(block)
-
-                    # Function call outputs (for context)
-                    elif item_type == "function_call_output":
-                        output = item.get("output", "")
-                        if output and len(output) < 1000:
-                            agent_messages.append(f"[Tool output]: {output[:500]}")
-
-                    # Log other item types we're not handling
-                    elif item_type not in ("function_call", "tool_call", "UserMessage", "user_message"):
-                        logger.debug(f"Unhandled item_completed type: {item_type}, item={item}")
-
-                elif msg_type == "agent_message":
-                    # Direct agent message event
-                    message = msg.get("message", "")
-                    if message:
-                        agent_messages.append(message)
-
-                elif msg_type in ("task_complete", "task_completed"):
-                    # Task is done - capture last_agent_message as fallback
-                    last_msg = msg.get("last_agent_message")
-                    if last_msg and last_msg not in agent_messages:
-                        agent_messages.append(last_msg)
-                    logger.debug(f"Task complete after {event_count} events")
+            # Process event through collector
+            try:
+                should_continue = collector.process_event(event)
+                if not should_continue:
+                    logger.debug(f"Collector signaled completion after {event_count} events")
                     break
+            except RuntimeError as e:
+                # Collector raises RuntimeError for codex errors
+                raise
 
-                elif msg_type == "token_count":
-                    # Capture token usage for cost tracking
-                    info = msg.get("info") or {}
-                    if info:
-                        usage = info.get("total_token_usage", {})
-                        if usage:
-                            token_usage = {
-                                "input_tokens": usage.get("input_tokens", 0),
-                                "output_tokens": usage.get("output_tokens", 0),
-                                "cached_input_tokens": usage.get("cached_input_tokens", 0),
-                                "reasoning_tokens": usage.get("reasoning_output_tokens", 0),
-                                "total_tokens": usage.get("total_tokens", 0),
-                            }
-                            logger.debug(f"Token usage: {token_usage}")
-
-                elif msg_type == "error":
-                    error_msg = msg.get("error", msg.get("message", str(msg)))
-                    raise RuntimeError(f"Codex error: {error_msg}")
-
-                # Handle streaming text events (various formats)
-                elif msg_type in ("text_delta", "content_block_delta", "message_delta"):
-                    delta = msg.get("delta", {})
-                    text = delta.get("text", "") or msg.get("text", "")
-                    if text:
-                        streaming_text.append(text)
-
-                elif msg_type == "text":
-                    text = msg.get("text", "")
-                    if text:
-                        streaming_text.append(text)
-
-                elif msg_type == "response":
-                    # Some versions send the full response this way
-                    response_text = msg.get("response", "") or msg.get("text", "")
-                    if response_text:
-                        agent_messages.append(response_text)
-
-                elif msg_type == "message":
-                    # Direct message event
-                    text = msg.get("text", "") or msg.get("content", "")
-                    if text:
-                        agent_messages.append(text)
-
-                else:
-                    # Log unknown event types at debug level to help diagnose
-                    if msg_type and msg_type not in ("session_started", "thinking", "tool_call", "function_call"):
-                        logger.debug(f"Unhandled MCP event type: {msg_type}, msg keys: {list(msg.keys())}")
-
-        # Merge streaming text into messages if we got any
-        if streaming_text:
-            full_streaming = "".join(streaming_text)
-            if full_streaming.strip():
-                agent_messages.append(full_streaming)
-                logger.debug(f"Captured {len(streaming_text)} streaming chunks ({len(full_streaming)} chars)")
-
-        # Try to extract content from final_result if we have no messages
-        if final_result and not agent_messages:
+        # Try to extract content from final_result if collector has no messages
+        messages = collector.get_messages()
+        if final_result and not messages:
             if "content" in final_result:
                 content = final_result["content"]
                 if isinstance(content, list):
                     for block in content:
                         if isinstance(block, dict) and block.get("text"):
-                            agent_messages.append(block["text"])
+                            messages.append(block["text"])
                         elif isinstance(block, str):
-                            agent_messages.append(block)
+                            messages.append(block)
                 elif isinstance(content, str):
-                    agent_messages.append(content)
-            # Also check for text field
-            if not agent_messages and "text" in final_result:
-                agent_messages.append(final_result["text"])
+                    messages.append(content)
+            if not messages and "text" in final_result:
+                messages.append(final_result["text"])
 
-        # Build result - prefer conversation_id from final result, fallback to session_id from events
-        effective_conversation_id = conversation_id or session_id
+        # Build result
         result = {
-            "conversationId": effective_conversation_id,
-            "messages": agent_messages,
-            "output": "\n".join(agent_messages) if agent_messages else "",
-            "usage": token_usage,  # Token usage for cost tracking
+            "conversationId": collector.conversation_id,
+            "messages": messages,
+            "output": "\n".join(messages) if messages else "",
+            "usage": collector.token_usage,
         }
 
         # Log detailed debug info if we didn't capture any messages
-        if not agent_messages:
+        if not messages:
+            debug_info = collector.get_debug_info()
             event_types = [e.get("method") or f"id:{e.get('id')}" for e in all_events[:20]]
             logger.warning(
                 f"MCP call returned no messages. "
-                f"conversation_id={effective_conversation_id}, "
-                f"session_id={session_id}, "
+                f"conversation_id={collector.conversation_id}, "
                 f"event_count={len(all_events)}, "
                 f"event_types={event_types}, "
+                f"collector_debug={debug_info}, "
                 f"final_result_keys={list(final_result.keys()) if final_result else 'None'}"
             )
             # Log codex/event details for debugging
@@ -498,7 +727,7 @@ class MCPClient:
                     msg = ce.get("params", {}).get("msg", {})
                     logger.debug(f"  codex/event: type={msg.get('type')}, keys={list(msg.keys())}")
 
-        logger.debug(f"MCP call complete: {len(agent_messages)} messages, conversation_id={effective_conversation_id}")
+        logger.debug(f"MCP call complete: {len(messages)} messages, conversation_id={collector.conversation_id}")
         return result
 
     def close(self) -> None:
@@ -530,11 +759,22 @@ class CodexMCPAdapter(ExecutorAdapter):
     This is the recommended way to have iterative conversations with Codex.
     The MCP client uses subprocess.Popen (not asyncio) so it persists across
     multiple asyncio.run() calls, preserving conversation state.
+
+    Config isolation: Pass config_path to use a local codex.toml instead of
+    the user's global ~/.codex/config.toml. This is the preferred approach.
+    Falls back to config_overrides if no config_path is provided.
     """
     DEFAULT_MODEL = "gpt-5.1-codex-mini"  # Default codex model
 
-    def __init__(self, model: str | None = None):
+    def __init__(
+        self,
+        model: str | None = None,
+        config_path: Path | None = None,
+        config_overrides: dict[str, str] | None = None,
+    ):
         self._model = model or self.DEFAULT_MODEL
+        self._config_path = config_path  # Path to local codex.toml for isolation
+        self._config_overrides = config_overrides or {}
         self._mcp_client: MCPClient | None = None
         self._sessions: dict[str, str] = {}  # session_id -> conversationId
         # Cumulative token usage for cost tracking
@@ -561,7 +801,10 @@ class CodexMCPAdapter(ExecutorAdapter):
     def _ensure_client(self) -> MCPClient:
         """Ensure MCP client is running and return it."""
         if self._mcp_client is None:
-            self._mcp_client = MCPClient()
+            self._mcp_client = MCPClient(
+                config_path=self._config_path,
+                config_overrides=self._config_overrides,
+            )
 
         if not self._mcp_client.is_alive:
             self._mcp_client.start()
@@ -575,6 +818,7 @@ class CodexMCPAdapter(ExecutorAdapter):
         cwd: str,
         sandbox: str,
         model: str | None = None,
+        reasoning_effort: str | None = None,
     ) -> dict[str, Any]:
         """
         Call codex MCP tool - traced by Weave.
@@ -592,7 +836,13 @@ class CodexMCPAdapter(ExecutorAdapter):
         if model:
             args["model"] = model
 
-        logger.info(f"Calling codex with task_len={len(task)}, cwd={cwd}, model={model or 'default'}")
+        # Pass reasoning_effort to override codex config defaults
+        # The config key is "model_reasoning_effort"
+        if reasoning_effort:
+            args["model_reasoning_effort"] = reasoning_effort
+
+        logger.info(f"Calling codex with task_len={len(task)}, cwd={cwd}, model={model or 'default'}, reasoning_effort={reasoning_effort or 'default'}")
+        logger.debug(f"Full codex args: {args}")
 
         result = client.call_tool("codex", args)
 
@@ -668,12 +918,55 @@ class CodexMCPAdapter(ExecutorAdapter):
         usage = result.get("usage", {})
         self._accumulate_usage(usage)
 
-        response = self._extract_response(result)
+        # Filter out the sent message from the response using content hashing
+        # The MCP may echo our prompt back, but we use robust content comparison
+        raw_messages = result.get("messages", [])
+
+        # Create hash of user message for comparison (normalized)
+        def normalize_for_comparison(text: str) -> str:
+            """Normalize text for comparison (lowercase, collapsed whitespace)."""
+            return " ".join(text.lower().split())
+
+        user_msg_normalized = normalize_for_comparison(message)
+        user_msg_hash = hashlib.md5(user_msg_normalized.encode()).hexdigest()
+
+        def is_user_message_echo(text: str) -> bool:
+            """Check if text is just an echo of the user message."""
+            if not text:
+                return True  # Empty is effectively an echo (skip it)
+
+            text_normalized = normalize_for_comparison(text)
+            text_hash = hashlib.md5(text_normalized.encode()).hexdigest()
+
+            # Exact match (case-insensitive, whitespace-normalized)
+            if text_hash == user_msg_hash:
+                return True
+
+            # Check if text IS the user message (not just starts with it)
+            # This avoids the bug where "Fix bug by X" gets filtered when user said "Fix bug"
+            if text_normalized == user_msg_normalized:
+                return True
+
+            return False
+
+        filtered_messages = [m for m in raw_messages if not is_user_message_echo(m)]
+
+        # Build filtered result for extraction
+        filtered_result = {
+            **result,
+            "messages": filtered_messages,
+            "output": "\n".join(filtered_messages) if filtered_messages else result.get("output", ""),
+        }
+
+        response = self._extract_response(filtered_result)
+        filtered_count = len(raw_messages) - len(filtered_messages)
+        if filtered_count > 0:
+            logger.debug(f"Filtered {filtered_count} user echo messages from response")
         logger.debug(f"codex-reply response length: {len(response)} chars")
 
         return {
             "response": response,
-            "raw_messages": result.get("messages", []),
+            "raw_messages": filtered_messages,  # Return filtered messages
             "usage": usage,
             "total_usage": self.total_usage,
             "conversation_lost": not result.get("messages") and not result.get("output"),
@@ -706,6 +999,7 @@ class CodexMCPAdapter(ExecutorAdapter):
                 cwd=str(working_dir.absolute()),
                 sandbox=sandbox,
                 model=effective_model,
+                reasoning_effort=kwargs.get("reasoning_effort"),
             )
 
             # Extract conversation ID and response