reverse-api-engineer 0.4.3__tar.gz → 0.4.5__tar.gz

{reverse_api_engineer-0.4.3 → reverse_api_engineer-0.4.5}/.claude/settings.local.json

@@ -113,7 +113,14 @@
       "Bash(npx rollup-plugin-visualizer:*)",
       "Bash(git pull:*)",
       "WebFetch(domain:docs.anthropic.com)",
-      "WebFetch(domain:docs.claude.com)"
+      "WebFetch(domain:docs.claude.com)",
+      "Bash(uv lock:*)",
+      "Bash(cd /Users/kalilbouzigues/Projects/browgents/reverse-api/chrome-extension/dist && zip -r ../packed/reverse-api-engineer-chrome.zip . && ls -lh ../packed/)",
+      "mcp__plugin_reverse-api-engineer_rae-playwright-mcp__browser_resize",
+      "mcp__plugin_reverse-api-engineer_rae-playwright-mcp__browser_take_screenshot",
+      "Bash(gh issue:*)",
+      "Bash(CLAUDECODE= uv run python3 /tmp/test_hook.py 2>&1)",
+      "Bash(CLAUDECODE=1 uv run python3 /tmp/test_hook4.py 2>&1)"
     ]
   }
 }

{reverse_api_engineer-0.4.3 → reverse_api_engineer-0.4.5}/.gitignore

@@ -99,4 +99,6 @@ collector_mode_plan.md
 chrome-extension/node_modules/
 chrome-extension/dist/
 chrome-extension-old
-debug/
+debug/
+
+.playwright-mcp/

{reverse_api_engineer-0.4.3 → reverse_api_engineer-0.4.5}/CHANGELOG.md

@@ -5,6 +5,23 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.5] - 2026-03-15
+
+### Fixed
+- **Stream closed errors (#51)**: Reverted from `query()` to `ClaudeSDKClient` which maintains a persistent bidirectional connection, eliminating "Error in hook callback hook_0: Stream closed" errors. The original AUQ fix (v0.4.3) unnecessarily switched APIs — only the `can_use_tool` callback signature needed updating
+- **CLAUDECODE env var leak**: Clear inherited `CLAUDECODE` env var from CLI subprocess to prevent nested session interference when running inside Claude Code
+- **CLI stderr noise**: Filter minified JS stack traces into a single clean error line (use `DEBUG=1` for full output)
+
+### Changed
+- **claude-agent-sdk**: Bumped minimum version to 0.1.48
+- **Agent mode**: No longer prompts for URL (agent navigates autonomously)
+- **Header UI**: Version and task labels now use mode-specific colors (agent=coral, engineer=blue, collector=gold)
+
+## [0.4.4] - 2026-03-15
+
+### Fixed
+- **Stream closed errors (#51)**: Partial fix using `query()` with env var workarounds (superseded by v0.4.5)
+
 ## [0.4.3] - 2026-03-12
 
 ### Fixed

{reverse_api_engineer-0.4.3 → reverse_api_engineer-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reverse-api-engineer
-Version: 0.4.3
+Version: 0.4.5
 Summary: A tool to capture browser traffic for API reverse engineering
 Project-URL: Homepage, https://github.com/kalil0321/reverse-api-engineer
 Project-URL: Repository, https://github.com/kalil0321/reverse-api-engineer
@@ -22,7 +22,7 @@ Requires-Python: >=3.11
 Requires-Dist: aiohttp>=3.12.15
 Requires-Dist: anthropic>=0.40.0
 Requires-Dist: brotli>=1.2.0
-Requires-Dist: claude-agent-sdk>=0.1.0
+Requires-Dist: claude-agent-sdk>=0.1.48
 Requires-Dist: click>=8.1.0
 Requires-Dist: playwright-stealth>=1.0.0
 Requires-Dist: playwright>=1.40.0

{reverse_api_engineer-0.4.3 → reverse_api_engineer-0.4.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reverse-api-engineer"
-version = "0.4.3"
+version = "0.4.5"
 description = "A tool to capture browser traffic for API reverse engineering"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -24,7 +24,7 @@ dependencies = [
     "playwright>=1.40.0",
     "playwright-stealth>=1.0.0",
     "click>=8.1.0",
-    "claude-agent-sdk>=0.1.0",
+    "claude-agent-sdk>=0.1.48",
     "rich>=13.0.0",
     "questionary>=2.0.0",
     "requests>=2.32.5",

{reverse_api_engineer-0.4.3 → reverse_api_engineer-0.4.5}/src/reverse_api/auto_engineer.py

@@ -11,14 +11,13 @@ import httpx
 from claude_agent_sdk import (
     AssistantMessage,
     ClaudeAgentOptions,
-    HookMatcher,
+    ClaudeSDKClient,
     PermissionResultAllow,
     ResultMessage,
     TextBlock,
     ToolPermissionContext,
     ToolResultBlock,
     ToolUseBlock,
-    query,
 )
 
 from .engineer import ClaudeEngineer
@@ -229,9 +228,7 @@ Your final response should confirm the files were created and provide a brief su
 - Any limitations or caveats
 """
 
-    async def _handle_tool_permission(
-        self, tool_name: str, input_data: dict[str, Any], context: ToolPermissionContext
-    ) -> PermissionResultAllow:
+    async def _handle_tool_permission(self, tool_name: str, input_data: dict[str, Any], context: ToolPermissionContext) -> PermissionResultAllow:
         """Handle tool permission requests, with interactive UI for AskUserQuestion."""
         if tool_name == "AskUserQuestion":
             questions = input_data.get("questions", [])
@@ -244,7 +241,7 @@ Your final response should confirm the files were created and provide a brief su
 
     async def analyze_and_generate(self) -> dict[str, Any] | None:
         """Run auto mode with MCP browser integration."""
-        self.ui.header(self.run_id, self.prompt, self.model)
+        self.ui.header(self.run_id, self.prompt, self.model, mode="agent")
         self.ui.start_analysis()
         self.message_store.save_prompt(self._build_auto_prompt())
 
@@ -259,104 +256,93 @@ Your final response should confirm the files were created and provide a brief su
             ],
         }
 
-        # Required workaround: dummy hook keeps the stream open for can_use_tool
-        # See: https://platform.claude.com/docs/en/agent-sdk/user-input
-        async def _dummy_hook(input_data: dict[str, Any], tool_use_id: str | None, context: Any) -> dict[str, Any]:
-            return {"continue_": True}
-
-        prompt_text = self._build_auto_prompt()
-
-        async def _prompt_stream() -> Any:
-            yield {
-                "type": "user",
-                "message": {"role": "user", "content": prompt_text},
-            }
-
         options = ClaudeAgentOptions(
             mcp_servers={"playwright": mcp_config},
+            permission_mode="bypassPermissions",
             can_use_tool=self._handle_tool_permission,
-            hooks={"PreToolUse": [HookMatcher(matcher=None, hooks=[_dummy_hook])]},
             cwd=str(self.scripts_dir.parent.parent),  # Project root
             model=self.model,
+            env={"CLAUDECODE": ""},
+            stderr=self._handle_cli_stderr,
         )
 
         try:
-            async for message in query(prompt=_prompt_stream(), options=options):
-                # Check for usage metadata
-                if hasattr(message, "usage") and isinstance(message.usage, dict):
-                    self.usage_metadata.update(message.usage)
-
-                if isinstance(message, AssistantMessage):
-                    last_tool_name = None
-                    for block in message.content:
-                        if isinstance(block, ToolUseBlock):
-                            last_tool_name = block.name
-                            self.ui.tool_start(block.name, block.input)
-                            self.message_store.save_tool_start(block.name, block.input)
-                        elif isinstance(block, ToolResultBlock):
-                            is_error = block.is_error if block.is_error else False
-
-                            # Extract output from ToolResultBlock
-                            output = None
-                            if hasattr(block, "content"):
-                                output = block.content
-                            elif hasattr(block, "result"):
-                                output = block.result
-                            elif hasattr(block, "output"):
-                                output = block.output
-
-                            tool_name = last_tool_name or "Tool"
-                            self.ui.tool_result(tool_name, is_error, output)
-                            self.message_store.save_tool_result(tool_name, is_error, str(output) if output else None)
-                        elif isinstance(block, TextBlock):
-                            self.ui.thinking(block.text)
-                            self.message_store.save_thinking(block.text)
-
-                elif isinstance(message, ResultMessage):
-                    if message.is_error:
-                        self.ui.error(message.result or "Unknown error")
-                        self.message_store.save_error(message.result or "Unknown error")
-                        return None
-                    else:
-                        script_path = str(self.scripts_dir / self._get_client_filename())
-                        local_path = str(self.local_scripts_dir / self._get_client_filename()) if self.local_scripts_dir else None
-                        self.ui.success(script_path, local_path)
-
-                        # Calculate estimated cost if we have usage data
-                        if self.usage_metadata:
-                            input_tokens = self.usage_metadata.get("input_tokens", 0)
-                            output_tokens = self.usage_metadata.get("output_tokens", 0)
-                            cache_creation_tokens = self.usage_metadata.get("cache_creation_input_tokens", 0)
-                            cache_read_tokens = self.usage_metadata.get("cache_read_input_tokens", 0)
-
-                            from .pricing import calculate_cost
-
-                            cost = calculate_cost(
-                                model_id=self.model,
-                                input_tokens=input_tokens,
-                                output_tokens=output_tokens,
-                                cache_creation_tokens=cache_creation_tokens,
-                                cache_read_tokens=cache_read_tokens,
-                            )
-                            self.usage_metadata["estimated_cost_usd"] = cost
-
-                            self.ui.console.print("  [dim]Usage:[/dim]")
-                            if input_tokens > 0:
-                                self.ui.console.print(f"  [dim]  input: {input_tokens:,} tokens[/dim]")
-                            if cache_creation_tokens > 0:
-                                self.ui.console.print(f"  [dim]  cache creation: {cache_creation_tokens:,} tokens[/dim]")
-                            if cache_read_tokens > 0:
-                                self.ui.console.print(f"  [dim]  cache read: {cache_read_tokens:,} tokens[/dim]")
-                            if output_tokens > 0:
-                                self.ui.console.print(f"  [dim]  output: {output_tokens:,} tokens[/dim]")
-                            self.ui.console.print(f"  [dim]  total cost: ${cost:.4f}[/dim]")
-
-                        result: dict[str, Any] = {
-                            "script_path": script_path,
-                            "usage": self.usage_metadata,
-                        }
-                        self.message_store.save_result(result)
-                        return result
+            async with ClaudeSDKClient(options=options) as client:
+                await client.query(self._build_auto_prompt())
+
+                async for message in client.receive_response():
+                    if hasattr(message, "usage") and isinstance(message.usage, dict):
+                        self.usage_metadata.update(message.usage)
+
+                    if isinstance(message, AssistantMessage):
+                        last_tool_name = None
+                        for block in message.content:
+                            if isinstance(block, ToolUseBlock):
+                                last_tool_name = block.name
+                                self.ui.tool_start(block.name, block.input)
+                                self.message_store.save_tool_start(block.name, block.input)
+                            elif isinstance(block, ToolResultBlock):
+                                is_error = block.is_error if block.is_error else False
+
+                                output = None
+                                if hasattr(block, "content"):
+                                    output = block.content
+                                elif hasattr(block, "result"):
+                                    output = block.result
+                                elif hasattr(block, "output"):
+                                    output = block.output
+
+                                tool_name = last_tool_name or "Tool"
+                                self.ui.tool_result(tool_name, is_error, output)
+                                self.message_store.save_tool_result(tool_name, is_error, str(output) if output else None)
+                            elif isinstance(block, TextBlock):
+                                self.ui.thinking(block.text)
+                                self.message_store.save_thinking(block.text)
+
+                    elif isinstance(message, ResultMessage):
+                        if message.is_error:
+                            self.ui.error(message.result or "Unknown error")
+                            self.message_store.save_error(message.result or "Unknown error")
+                            return None
+                        else:
+                            script_path = str(self.scripts_dir / self._get_client_filename())
+                            local_path = str(self.local_scripts_dir / self._get_client_filename()) if self.local_scripts_dir else None
+                            self.ui.success(script_path, local_path)
+
+                            if self.usage_metadata:
+                                input_tokens = self.usage_metadata.get("input_tokens", 0)
+                                output_tokens = self.usage_metadata.get("output_tokens", 0)
+                                cache_creation_tokens = self.usage_metadata.get("cache_creation_input_tokens", 0)
+                                cache_read_tokens = self.usage_metadata.get("cache_read_input_tokens", 0)
+
+                                from .pricing import calculate_cost
+
+                                cost = calculate_cost(
+                                    model_id=self.model,
+                                    input_tokens=input_tokens,
+                                    output_tokens=output_tokens,
+                                    cache_creation_tokens=cache_creation_tokens,
+                                    cache_read_tokens=cache_read_tokens,
+                                )
+                                self.usage_metadata["estimated_cost_usd"] = cost
+
+                                self.ui.console.print("  [dim]Usage:[/dim]")
+                                if input_tokens > 0:
+                                    self.ui.console.print(f"  [dim]  input: {input_tokens:,} tokens[/dim]")
+                                if cache_creation_tokens > 0:
+                                    self.ui.console.print(f"  [dim]  cache creation: {cache_creation_tokens:,} tokens[/dim]")
+                                if cache_read_tokens > 0:
+                                    self.ui.console.print(f"  [dim]  cache read: {cache_read_tokens:,} tokens[/dim]")
+                                if output_tokens > 0:
+                                    self.ui.console.print(f"  [dim]  output: {output_tokens:,} tokens[/dim]")
+                                self.ui.console.print(f"  [dim]  total cost: ${cost:.4f}[/dim]")
+
+                            result: dict[str, Any] = {
+                                "script_path": script_path,
+                                "usage": self.usage_metadata,
+                            }
+                            self.message_store.save_result(result)
+                            return result
 
         except Exception as e:
             error_msg = str(e)
@@ -404,7 +390,7 @@ class OpenCodeAutoEngineer(OpenCodeEngineer):
 
     async def analyze_and_generate(self) -> dict[str, Any] | None:
         """Run auto mode with OpenCode MCP integration."""
-        self.opencode_ui.header(self.run_id, self.prompt, self.opencode_model)
+        self.opencode_ui.header(self.run_id, self.prompt, self.opencode_model, mode="agent")
         self.opencode_ui.start_analysis()
         self.message_store.save_prompt(self._build_auto_prompt())
 
@@ -639,7 +625,7 @@ class CopilotAutoEngineer:
             return None
 
         eng = self._engineer
-        eng.ui.header(eng.run_id, eng.prompt, eng.copilot_model, eng.sdk)
+        eng.ui.header(eng.run_id, eng.prompt, eng.copilot_model, eng.sdk, mode="agent")
         eng.ui.start_analysis()
 
         auto_prompt = ClaudeAutoEngineer._build_auto_prompt(eng)

{reverse_api_engineer-0.4.3 → reverse_api_engineer-0.4.5}/src/reverse_api/base_engineer.py

@@ -1,5 +1,6 @@
 """Abstract base class for API reverse engineering."""
 
+import os
 from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Any
@@ -12,6 +13,8 @@ from .sync import FileSyncWatcher, get_available_directory
 from .tui import THEME_PRIMARY, THEME_SECONDARY, ClaudeUI
 from .utils import generate_folder_name, get_docs_dir, get_history_path, get_scripts_dir
 
+DEBUG = os.environ.get("DEBUG", "0") == "1"
+
 
 class BaseEngineer(ABC):
     """Abstract base class for API reverse engineering implementations."""
@@ -60,6 +63,24 @@ class BaseEngineer(ABC):
         self.existing_client_path = self._get_existing_client_path()
         self.sync_watcher: FileSyncWatcher | None = None
         self.local_scripts_dir: Path | None = None
+        self._stderr_error_shown = False
+
+    def _handle_cli_stderr(self, line: str) -> None:
+        """Filter CLI subprocess stderr. Shows full output in DEBUG mode, otherwise shows a single clean error."""
+        if DEBUG:
+            self.ui.console.print(f"[dim]  stderr: {line.rstrip()}[/dim]")
+            return
+
+        # Known noisy errors from the CLI control protocol — show once
+        if "Error in hook callback" in line or "Stream closed" in line:
+            if not self._stderr_error_shown:
+                self._stderr_error_shown = True
+                self.ui.console.print("  [dim]![/dim] [dim]cli stream error (set DEBUG=1 for details)[/dim]")
+            return
+
+        # Suppress other common noise (stack traces, source maps)
+        if line.startswith("      at ") or "| " in line[:20]:
+            return
 
     def start_sync(self):
         """Start real-time file sync if enabled."""
@@ -532,16 +553,20 @@ Your OpenAPI spec should be production-ready and suitable for:
             mode_description = f"reverse engineer API calls and generate production-ready {language_name} code that replicates"
             task_description = f"{language_name} API client"
 
-        attempt_log_section = "" if self.output_mode == "docs" else (
-            "If your first attempt doesn't work, analyze what went wrong and try again. "
-            "Document each attempt and what you learned.\n\n"
-            "<attempt_log>\n"
-            "For each attempt (up to 5), document:\n"
-            "- Attempt number\n"
-            "- What approach you tried\n"
-            "- What error or issue occurred (if any)\n"
-            "- What you changed for the next attempt\n"
-            "</attempt_log>\n\n"
+        attempt_log_section = (
+            ""
+            if self.output_mode == "docs"
+            else (
+                "If your first attempt doesn't work, analyze what went wrong and try again. "
+                "Document each attempt and what you learned.\n\n"
+                "<attempt_log>\n"
+                "For each attempt (up to 5), document:\n"
+                "- Attempt number\n"
+                "- What approach you tried\n"
+                "- What error or issue occurred (if any)\n"
+                "- What you changed for the next attempt\n"
+                "</attempt_log>\n\n"
+            )
         )
         after_verb = "documenting" if self.output_mode == "docs" else "testing"
         output_type = "spec" if self.output_mode == "docs" else "code"

{reverse_api_engineer-0.4.3 → reverse_api_engineer-0.4.5}/src/reverse_api/browser.py

@@ -210,11 +210,11 @@ class ManualBrowser:
         self.output_dir = output_dir
         self.use_real_chrome = use_real_chrome
         self.enable_action_recording = enable_action_recording
-        
+
         self.har_dir = get_har_dir(run_id, output_dir)
         self.har_path = self.har_dir / "recording.har"
         self.metadata_path = self.har_dir / "metadata.json"
-        
+
         self._playwright = None
         self._browser: Browser | None = None
         self._context: BrowserContext | None = None
@@ -226,15 +226,15 @@ class ManualBrowser:
 
     def _inject_action_recorder(self, page: Page) -> None:
         """Inject action recording script into page.
-        
+
         Uses console.log + page.on('console') for reliable capture.
         Works best with stealth Chromium mode (not real Chrome).
         """
         if not self.enable_action_recording:
             return
-        
+
         # Simple JS that logs actions to console with a special prefix
-        recorder_js = '''
+        recorder_js = """
         window.__recordedActions = [];
         window.__lastUrl = null;
         
@@ -378,34 +378,35 @@ class ManualBrowser:
                 }
             }
         }
-        '''
-        
+        """
+
         # Listen to console for actions
         import json
+
         last_url = [None]  # Mutable to track last URL
-        
+
         def on_console(msg):
             text = msg.text
-            if text.startswith('__ACTION__'):
+            if text.startswith("__ACTION__"):
                 try:
                     action_json = text[10:]  # Remove '__ACTION__' prefix
                     action_data = json.loads(action_json)
-                    
+
                     # Filter duplicate navigations
-                    if action_data.get('type') == 'navigate':
-                        url = action_data.get('url', '')
+                    if action_data.get("type") == "navigate":
+                        url = action_data.get("url", "")
                         if url == last_url[0]:
                             return  # Skip duplicate
                         last_url[0] = url
-                    
+
                     if self.action_recorder:
                         self.action_recorder.add_action(RecordedAction(**action_data))
                 except Exception as e:
                     console.print(f" [dim]action parse error: {e}[/dim]")
-        
+
         page.on("console", on_console)
         page.add_init_script(recorder_js)
-        
+
         console.print(" [dim]action recording enabled[/dim]")
 
     def _save_metadata(self, end_time: str) -> None:

{reverse_api_engineer-0.4.3 → reverse_api_engineer-0.4.5}/src/reverse_api/cli.py

@@ -54,7 +54,7 @@ config_manager = ConfigManager(get_config_path())
 session_manager = SessionManager(get_history_path())
 
 # Mode definitions
-MODES = ["manual", "engineer", "agent", "collector"]
+MODES = ["agent", "manual", "engineer", "collector"]
 MODE_DESCRIPTIONS = {
     "manual": "full pipeline",
     "engineer": "reverse engineer only",
@@ -68,7 +68,7 @@ def prompt_interactive_options(
     url: str | None = None,
     reverse_engineer: bool | None = None,
     model: str | None = None,
-    current_mode: str = "manual",
+    current_mode: str = "agent",
 ) -> dict:
     """Prompt user for essential options interactively (Browgents style).
 
@@ -267,29 +267,15 @@ def prompt_interactive_options(
             "model": model or config_manager.get("claude_code_model", "claude-sonnet-4-6"),
         }
 
-    # Agent mode: similar to manual but uses autonomous browser
+    # Agent mode: autonomous browser, no URL needed (agent navigates on its own)
     if result_mode == "agent":
-        if url is None:
-            try:
-                url = questionary.text(
-                    " > url",
-                    instruction="(Enter for none)",
-                    qmark="",
-                    style=questionary.Style(
-                        [
-                            ("question", f"fg:{THEME_SECONDARY}"),
-                            ("instruction", f"fg:{THEME_DIM} italic"),
-                        ]
-                    ),
-                ).ask()
-                if url is None:  # questionary returns None on Ctrl+C
-                    raise click.Abort()
-            except KeyboardInterrupt:
-                raise click.Abort()
-
         if model is None:
             model = config_manager.get("claude_code_model", "claude-sonnet-4-6")
 
+        mode_color = MODE_COLORS.get("agent", THEME_PRIMARY)
+        console = Console()
+        console.print(f"  [{mode_color}]autonomous[/{mode_color}] [dim]agent will navigate on its own[/dim]")
+
         return {
             "mode": result_mode,
             "prompt": prompt,
@@ -372,7 +358,7 @@ def repl_loop():
         model = config_manager.get("claude_code_model", "claude-sonnet-4-6")
 
     display_banner(console, sdk=sdk, model=model)
-    console.print("  [dim]shift+tab to cycle modes: manual | engineer | agent | collector[/dim]")
+    console.print("  [dim]shift+tab to cycle modes: agent | manual | engineer | collector[/dim]")
     display_footer(console)
 
     # Show update message if background check has completed
@@ -386,14 +372,14 @@ def repl_loop():
     finally:
         update_executor.shutdown(wait=False)
 
-    current_mode = "manual"
+    current_mode = "agent"
 
     while True:
         try:
             options = prompt_interactive_options(current_mode=current_mode)
 
             # Update current mode for next iteration
-            current_mode = options.get("mode", "manual")
+            current_mode = options.get("mode", "agent")
 
             if "command" in options:
                 cmd = options["command"]
@@ -430,7 +416,7 @@ def repl_loop():
                     console.print(" [dim]Available commands: /settings, /history, /messages, /help, /exit[/dim]")
                 continue
 
-            mode = options.get("mode", "manual")
+            mode = options.get("mode", "agent")
 
             # Handle different modes
             if mode == "engineer":
@@ -1106,9 +1092,9 @@ def handle_help(mode_color=THEME_PRIMARY):
     modes_table.add_column(style=f"{mode_color} bold", justify="left", width=15)
     modes_table.add_column(style="dim", justify="left")
 
+    modes_table.add_row("agent", "Autonomous agent + capture")
     modes_table.add_row("manual", "Full pipeline: browser + reverse engineering")
     modes_table.add_row("engineer", "Reverse engineer only (enter run_id)")
-    modes_table.add_row("agent", "Autonomous agent + capture")
 
     console.print(" [bold white]Modes[/bold white] [dim]Shift+Tab to cycle[/dim]")
     console.print(modes_table)

{reverse_api_engineer-0.4.3 → reverse_api_engineer-0.4.5}/src/reverse_api/collector.py

@@ -66,7 +66,7 @@ class Collector:
         Returns:
             Result dict with output_path and collected_items, or None on error
         """
-        self.ui.header(self.run_id, self.prompt, self.model)
+        self.ui.header(self.run_id, self.prompt, self.model, mode="collector")
         self.ui.start_collecting()
 
         self._folder_name = generate_folder_name(self.prompt)
@@ -288,7 +288,7 @@ When complete, briefly summarize what was collected.
     def _export_readme(self, readme_path: Path, items: list[dict[str, Any]], sources: set[str]) -> None:
         """Generate README with collection metadata."""
         folder_name = self._folder_name or "collection"
-        readme_content = f"""# {folder_name.replace('_', ' ').title()}
+        readme_content = f"""# {folder_name.replace("_", " ").title()}
 
 ## Query
 {self.prompt}

{reverse_api_engineer-0.4.3 → reverse_api_engineer-0.4.5}/src/reverse_api/collector_ui.py

@@ -15,12 +15,12 @@ class CollectorUI:
         self.verbose = verbose
         self._items_collected = 0
 
-    def header(self, run_id: str, prompt: str, model: str | None = None) -> None:
+    def header(self, run_id: str, prompt: str, model: str | None = None, **kwargs) -> None:
         """Display the collector session header."""
         from . import __version__
 
         self.console.print()
-        self.console.print(f" [white]reverse-api[/white] [dim]v{__version__}[/dim]")
+        self.console.print(f" [white]reverse-api[/white] [{COLLECTOR_COLOR}]v{__version__}[/{COLLECTOR_COLOR}]")
         self.console.print(f" [dim]━[/dim] [white]{run_id}[/white]")
         self.console.print(f" [{COLLECTOR_COLOR}]collector[/{COLLECTOR_COLOR}] [dim]|[/dim] [dim]model[/dim] [white]{model or '---'}[/white]")
         self.console.print(f" [{COLLECTOR_COLOR}]task[/{COLLECTOR_COLOR}]      [white]{prompt[:80]}{'...' if len(prompt) > 80 else ''}[/white]")
@@ -86,6 +86,7 @@ class CollectorUI:
     def error(self, message: str) -> None:
         """Display error message."""
         from .tui import ERROR_CTA
+
         self.console.print()
         self.console.print(f" [dim]![/dim] [red]error:[/red] {message}")
         self.console.print(f" [dim]{ERROR_CTA}[/dim]")

{reverse_api_engineer-0.4.3 → reverse_api_engineer-0.4.5}/src/reverse_api/copilot_engineer.py

@@ -69,7 +69,7 @@ class CopilotEngineer(BaseEngineer):
             )
             return None
 
-        self.ui.header(self.run_id, self.prompt, self.copilot_model, self.sdk)
+        self.ui.header(self.run_id, self.prompt, self.copilot_model, self.sdk, mode="engineer")
         self.ui.start_analysis()
 
         prompt = self._build_analysis_prompt()