reverse-api-engineer 0.4.2__tar.gz → 0.4.4__tar.gz

{reverse_api_engineer-0.4.2 → reverse_api_engineer-0.4.4}/.claude/settings.local.json

@@ -111,7 +111,16 @@
       "Bash(pip show:*)",
       "Bash(npm uninstall:*)",
       "Bash(npx rollup-plugin-visualizer:*)",
-      "Bash(git pull:*)"
+      "Bash(git pull:*)",
+      "WebFetch(domain:docs.anthropic.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.2 → reverse_api_engineer-0.4.4}/.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.2 → reverse_api_engineer-0.4.4}/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.4] - 2026-03-15
+
+### Fixed
+- **Stream closed errors (#51)**: Fixed "Error in hook callback hook_0: Stream closed" by clearing inherited `CLAUDECODE` env var from CLI subprocess and extending stream close timeout
+- **Async generator cleanup**: Avoid early return inside `query()` loop to prevent cancel-scope errors
+- **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.3] - 2026-03-12
+
+### Fixed
+- **AskUserQuestion interactive prompt**: Fixed interactive questionary UI not rendering in engineer and agent modes. Switched from `ClaudeSDKClient` to `query()` function, as `ClaudeSDKClient` silently auto-approves `AskUserQuestion` without triggering the `can_use_tool` callback
+
 ## [0.4.2] - 2026-03-12
 
 ### Fixed

{reverse_api_engineer-0.4.2 → reverse_api_engineer-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reverse-api-engineer
-Version: 0.4.2
+Version: 0.4.4
 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.2 → reverse_api_engineer-0.4.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "reverse-api-engineer"
-version = "0.4.2"
+version = "0.4.4"
 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.2 → reverse_api_engineer-0.4.4}/src/reverse_api/auto_engineer.py

@@ -11,11 +11,14 @@ import httpx
 from claude_agent_sdk import (
     AssistantMessage,
     ClaudeAgentOptions,
-    ClaudeSDKClient,
+    HookMatcher,
+    PermissionResultAllow,
     ResultMessage,
     TextBlock,
+    ToolPermissionContext,
     ToolResultBlock,
     ToolUseBlock,
+    query,
 )
 
 from .engineer import ClaudeEngineer
@@ -226,9 +229,20 @@ 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:
+        """Handle tool permission requests, with interactive UI for AskUserQuestion."""
+        if tool_name == "AskUserQuestion":
+            questions = input_data.get("questions", [])
+            answers = await self._ask_user_interactive(questions)
+            return PermissionResultAllow(
+                updated_input={"questions": questions, "answers": answers},
+            )
+        # Auto-approve all other tools
+        return PermissionResultAllow(updated_input=input_data)
+
     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())
 
@@ -243,126 +257,124 @@ Your final response should confirm the files were created and provide a brief su
             ],
         }
 
+        # Required: dummy hook keeps the stream open for can_use_tool
+        async def _dummy_hook(input_data: dict[str, Any], tool_use_id: str | None, context: Any) -> dict[str, Any]:
+            return {"continue_": True}
+
+        async def _prompt_stream():
+            yield {
+                "type": "user",
+                "message": {"role": "user", "content": self._build_auto_prompt()},
+            }
+
         options = ClaudeAgentOptions(
             mcp_servers={"playwright": mcp_config},
-            permission_mode="bypassPermissions",  # Auto-accept browser tool usage
-            allowed_tools=[
-                "Read",
-                "Write",
-                "Bash",
-                "Glob",
-                "Grep",
-                "WebSearch",
-                "WebFetch",
-            ],
+            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": "", "CLAUDE_CODE_STREAM_CLOSE_TIMEOUT": "1800000"},
+            stderr=self._handle_cli_stderr,
         )
 
+        final_result: dict[str, Any] | None = None
+
         try:
-            async with ClaudeSDKClient(options=options) as client:
-                await client.query(self._build_auto_prompt())
-
-                # Process response and show progress with TUI
-                async for message in client.receive_response():
-                    # 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)
-
-                                # Calculate cost using shared pricing module
-                                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
-
-                                # Display usage breakdown
-                                self.ui.console.print(f"  [dim]Usage:[/dim]")  # noqa: F541
-                                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
+            # Do not break/return inside this loop — the SDK requires the
+            # async generator to be fully consumed to avoid cancel-scope errors.
+            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")
+                    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]")
+
+                        final_result = {
+                            "script_path": script_path,
+                            "usage": self.usage_metadata,
+                        }
+                        self.message_store.save_result(final_result)
 
         except Exception as e:
             error_msg = str(e)
             self.ui.error(error_msg)
             self.message_store.save_error(error_msg)
 
-            # Handle screenshot buffer size errors specifically
             if "buffer size" in error_msg.lower() or "1048576" in error_msg or "exceeded maximum buffer" in error_msg.lower():
-                self.ui.console.print("\n[yellow]⚠ Screenshot too large (exceeds 1MB limit)[/yellow]")
+                self.ui.console.print("\n[yellow]Screenshot too large (exceeds 1MB limit)[/yellow]")
                 self.ui.console.print("[dim]Tip: The AI should take element-specific screenshots instead of full-page screenshots.[/dim]")
                 self.ui.console.print(
                     "[dim]Consider using browser_snapshot() for accessibility tree information when screenshots aren't needed.[/dim]"
                 )
-            # Provide helpful error messages
             elif "MCP server" in error_msg or "npx" in error_msg:
                 self.ui.console.print("\n[dim]Make sure rae-playwright-mcp is installed: npm install -g rae-playwright-mcp[/dim]")
             else:
                 self.ui.console.print("\n[dim]Make sure Claude Code CLI is installed: npm install -g @anthropic-ai/claude-code[/dim]")
             return None
 
-        return None
+        return final_result
 
 
 class OpenCodeAutoEngineer(OpenCodeEngineer):
@@ -391,7 +403,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())
 
@@ -626,7 +638,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.2 → reverse_api_engineer-0.4.4}/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.2 → reverse_api_engineer-0.4.4}/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.2 → reverse_api_engineer-0.4.4}/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.2 → reverse_api_engineer-0.4.4}/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}