emdash-cli 0.1.25__py3-none-any.whl → 0.1.35__py3-none-any.whl

emdash_cli/commands/agent.py

@@ -35,7 +35,9 @@ SLASH_COMMANDS = {
     "/research [goal]": "Deep research on a topic",
     # Status commands
     "/status": "Show index and PROJECT.md status",
+    "/agents": "List, create, or show agents (e.g., /agents create my-agent)",
     # Session management
+    "/session": "Save, load, or list sessions (e.g., /session save my-task)",
     "/spec": "Show current specification",
     "/reset": "Reset session state",
     "/save": "Save current spec to disk",
@@ -373,6 +375,121 @@ def _show_plan_approval_menu() -> tuple[str, str]:
     return choice, feedback
 
 
+def _show_plan_mode_approval_menu() -> tuple[str, str]:
+    """Show plan mode entry approval menu.
+
+    Returns:
+        Tuple of (choice, feedback) where feedback is only set for 'reject'
+    """
+    from prompt_toolkit import Application
+    from prompt_toolkit.key_binding import KeyBindings
+    from prompt_toolkit.layout import Layout, HSplit, Window, FormattedTextControl
+    from prompt_toolkit.styles import Style
+
+    options = [
+        ("approve", "Enter plan mode and explore"),
+        ("reject", "Skip planning, proceed directly"),
+    ]
+
+    selected_index = [0]
+    result = [None]
+
+    kb = KeyBindings()
+
+    @kb.add("up")
+    @kb.add("k")
+    def move_up(event):
+        selected_index[0] = (selected_index[0] - 1) % len(options)
+
+    @kb.add("down")
+    @kb.add("j")
+    def move_down(event):
+        selected_index[0] = (selected_index[0] + 1) % len(options)
+
+    @kb.add("enter")
+    def select(event):
+        result[0] = options[selected_index[0]][0]
+        event.app.exit()
+
+    @kb.add("1")
+    @kb.add("y")
+    def select_approve(event):
+        result[0] = "approve"
+        event.app.exit()
+
+    @kb.add("2")
+    @kb.add("n")
+    def select_reject(event):
+        result[0] = "reject"
+        event.app.exit()
+
+    @kb.add("c-c")
+    @kb.add("q")
+    @kb.add("escape")
+    def cancel(event):
+        result[0] = "reject"
+        event.app.exit()
+
+    def get_formatted_options():
+        lines = [("class:title", "Enter plan mode?\n\n")]
+        for i, (key, desc) in enumerate(options):
+            if i == selected_index[0]:
+                lines.append(("class:selected", f"  ❯ {key:8} "))
+                lines.append(("class:selected-desc", f"- {desc}\n"))
+            else:
+                lines.append(("class:option", f"    {key:8} "))
+                lines.append(("class:desc", f"- {desc}\n"))
+        lines.append(("class:hint", "\n↑/↓ to move, Enter to select, y/n for quick select"))
+        return lines
+
+    style = Style.from_dict({
+        "title": "#ffcc00 bold",
+        "selected": "#00cc66 bold",
+        "selected-desc": "#00cc66",
+        "option": "#888888",
+        "desc": "#666666",
+        "hint": "#444444 italic",
+    })
+
+    layout = Layout(
+        HSplit([
+            Window(
+                FormattedTextControl(get_formatted_options),
+                height=6,
+            ),
+        ])
+    )
+
+    app = Application(
+        layout=layout,
+        key_bindings=kb,
+        style=style,
+        full_screen=False,
+    )
+
+    console.print()
+
+    try:
+        app.run()
+    except (KeyboardInterrupt, EOFError):
+        result[0] = "reject"
+
+    choice = result[0] or "reject"
+
+    feedback = ""
+    if choice == "reject":
+        from prompt_toolkit import PromptSession
+        console.print()
+        console.print("[dim]Reason for skipping plan mode (optional):[/dim]")
+        try:
+            session = PromptSession()
+            feedback = session.prompt("feedback > ").strip()
+        except (KeyboardInterrupt, EOFError):
+            return "reject", ""
+
+    return choice, feedback
+
+
 def _render_with_interrupt(renderer: SSERenderer, stream) -> dict:
     """Render stream with ESC key interrupt support.
 
@@ -465,12 +582,17 @@ def _run_interactive(
     current_mode = AgentMode(options.get("mode", "code"))
     session_id = None
     current_spec = None
+    # Attached images for next message
+    attached_images: list[dict] = []
+    # Loaded messages from saved session (for restoration)
+    loaded_messages: list[dict] = []
 
     # Style for prompt
     PROMPT_STYLE = Style.from_dict({
         "prompt.mode.plan": "#ffcc00 bold",
         "prompt.mode.code": "#00cc66 bold",
         "prompt.prefix": "#888888",
+        "prompt.image": "#00ccff",
         "completion-menu": "bg:#1a1a2e #ffffff",
         "completion-menu.completion": "bg:#1a1a2e #ffffff",
         "completion-menu.completion.current": "bg:#4a4a6e #ffffff bold",
@@ -517,6 +639,63 @@ def _run_interactive(
         """Insert a newline character with Alt+Enter or Ctrl+J."""
         event.current_buffer.insert_text("\n")
 
+    @kb.add("c-v")  # Ctrl+V to paste (check for images)
+    def paste_with_image_check(event):
+        """Paste text or attach image from clipboard."""
+        nonlocal attached_images
+        from ..clipboard import get_clipboard_image, get_image_from_path
+
+        # Try to get image from clipboard
+        image_data = get_clipboard_image()
+        if image_data:
+            base64_data, img_format = image_data
+            attached_images.append({"data": base64_data, "format": img_format})
+            # Refresh prompt to show updated image list
+            event.app.invalidate()
+            return
+
+        # Check if clipboard contains an image file path
+        clipboard_data = event.app.clipboard.get_data()
+        if clipboard_data and clipboard_data.text:
+            text = clipboard_data.text.strip()
+            # Remove escape characters from dragged paths (e.g., "path\ with\ spaces")
+            clean_path = text.replace("\\ ", " ")
+            # Check if it looks like an image file path
+            if clean_path.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp')):
+                image_data = get_image_from_path(clean_path)
+                if image_data:
+                    base64_data, img_format = image_data
+                    attached_images.append({"data": base64_data, "format": img_format})
+                    event.app.invalidate()
+                    return
+
+        # No image, do normal paste
+        event.current_buffer.paste_clipboard_data(clipboard_data)
+
+    def check_for_image_path(buff):
+        """Check if buffer contains an image path and attach it."""
+        nonlocal attached_images
+        text = buff.text.strip()
+        if not text:
+            return
+        # Clean escaped spaces from dragged paths
+        clean_text = text.replace("\\ ", " ")
+        if clean_text.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp')):
+            from ..clipboard import get_image_from_path
+            from prompt_toolkit.application import get_app
+            image_data = get_image_from_path(clean_text)
+            if image_data:
+                base64_data, img_format = image_data
+                attached_images.append({"data": base64_data, "format": img_format})
+                # Clear the buffer
+                buff.text = ""
+                buff.cursor_position = 0
+                # Refresh prompt to show image indicator
+                try:
+                    get_app().invalidate()
+                except Exception:
+                    pass
+
     session = PromptSession(
         history=history,
         completer=SlashCommandCompleter(),
@@ -527,15 +706,19 @@ def _run_interactive(
         key_bindings=kb,
     )
 
+    # Watch for image paths being pasted/dropped
+    session.default_buffer.on_text_changed += check_for_image_path
+
     def get_prompt():
-        """Get formatted prompt based on current mode."""
-        mode_colors = {
-            AgentMode.PLAN: "class:prompt.mode.plan",
-            AgentMode.CODE: "class:prompt.mode.code",
-        }
-        mode_name = current_mode.value
-        color_class = mode_colors.get(current_mode, "class:prompt.mode.code")
-        return [(color_class, f"[{mode_name}]"), ("", " "), ("class:prompt.prefix", "> ")]
+        """Get formatted prompt."""
+        nonlocal attached_images
+        parts = []
+        # Show attached images above prompt
+        if attached_images:
+            image_tags = " ".join(f"[Image #{i+1}]" for i in range(len(attached_images)))
+            parts.append(("class:prompt.image", f" {image_tags}\n"))
+        parts.append(("class:prompt.prefix", "> "))
+        return parts
 
     def show_help():
         """Show available commands."""
@@ -564,11 +747,21 @@ def _run_interactive(
 
         elif command == "/plan":
             current_mode = AgentMode.PLAN
-            console.print("[yellow]Switched to plan mode[/yellow]")
+            # Reset session so next chat creates a new session with plan mode
+            if session_id:
+                session_id = None
+                console.print("[bold green]✓ Plan mode activated[/bold green] [dim](session reset)[/dim]")
+            else:
+                console.print("[bold green]✓ Plan mode activated[/bold green]")
 
         elif command == "/code":
             current_mode = AgentMode.CODE
-            console.print("[green]Switched to code mode[/green]")
+            # Reset session so next chat creates a new session with code mode
+            if session_id:
+                session_id = None
+                console.print("[green]Switched to code mode (session reset)[/green]")
+            else:
+                console.print("[green]Switched to code mode[/green]")
 
         elif command == "/mode":
             console.print(f"Current mode: [bold]{current_mode.value}[/bold]")
@@ -670,6 +863,256 @@ def _run_interactive(
 
             console.print()
 
+        elif command == "/agents":
+            # Agents management: list, create, show
+            from emdash_core.agent.toolkits import list_agent_types, get_custom_agent
+
+            # Parse subcommand
+            subparts = args.split(maxsplit=1) if args else []
+            subcommand = subparts[0].lower() if subparts else "list"
+            subargs = subparts[1] if len(subparts) > 1 else ""
+
+            if subcommand in ("list", ""):
+                # List all agents
+                console.print("\n[bold cyan]Available Agents[/bold cyan]\n")
+
+                all_agents = list_agent_types(Path.cwd())
+                builtin = ["Explore", "Plan"]
+
+                console.print("[bold]Built-in Agents[/bold]")
+                for agent_name in builtin:
+                    if agent_name == "Explore":
+                        console.print("  [green]Explore[/green] - Fast codebase exploration (read-only)")
+                    elif agent_name == "Plan":
+                        console.print("  [green]Plan[/green] - Design implementation plans")
+
+                # Custom agents
+                custom = [a for a in all_agents if a not in builtin]
+                if custom:
+                    console.print("\n[bold]Custom Agents[/bold] [dim](.emdash/agents/)[/dim]")
+                    for name in custom:
+                        agent = get_custom_agent(name, Path.cwd())
+                        desc = agent.description if agent else ""
+                        if desc:
+                            console.print(f"  [cyan]{name}[/cyan] - {desc}")
+                        else:
+                            console.print(f"  [cyan]{name}[/cyan]")
+                else:
+                    console.print("\n[dim]No custom agents found.[/dim]")
+                    console.print("[dim]Create with: /agents create <name>[/dim]")
+
+                console.print()
+
+            elif subcommand == "create":
+                # Create a new custom agent
+                if not subargs:
+                    console.print("[yellow]Usage: /agents create <name>[/yellow]")
+                    console.print("[dim]Example: /agents create code-reviewer[/dim]")
+                else:
+                    agent_name = subargs.strip().lower().replace(" ", "-")
+                    agents_dir = Path.cwd() / ".emdash" / "agents"
+                    agent_file = agents_dir / f"{agent_name}.md"
+
+                    if agent_file.exists():
+                        console.print(f"[yellow]Agent '{agent_name}' already exists[/yellow]")
+                        console.print(f"[dim]Edit: {agent_file}[/dim]")
+                    else:
+                        # Create directory if needed
+                        agents_dir.mkdir(parents=True, exist_ok=True)
+
+                        # Create template
+                        template = f'''---
+description: Custom agent for specific tasks
+tools: [grep, glob, read_file, semantic_search]
+---
+
+# System Prompt
+
+You are a specialized assistant for {agent_name.replace("-", " ")} tasks.
+
+## Your Mission
+
+Describe what this agent should accomplish:
+- Task 1
+- Task 2
+- Task 3
+
+## Approach
+
+1. **Step One**
+   - Details about the first step
+
+2. **Step Two**
+   - Details about the second step
+
+## Output Format
+
+Describe how the agent should format its responses.
+
+# Examples
+
+## Example 1
+User: Example user request
+Agent: Example agent response describing what it would do
+'''
+                        agent_file.write_text(template)
+                        console.print(f"[green]Created agent: {agent_name}[/green]")
+                        console.print(f"[dim]Edit to customize: {agent_file}[/dim]")
+                        console.print(f"\n[dim]Spawn with Task tool: subagent_type='{agent_name}'[/dim]")
+
+            elif subcommand == "show":
+                # Show details of an agent
+                if not subargs:
+                    console.print("[yellow]Usage: /agents show <name>[/yellow]")
+                else:
+                    agent_name = subargs.strip()
+                    builtin = ["Explore", "Plan"]
+
+                    if agent_name in builtin:
+                        console.print(f"\n[bold cyan]{agent_name}[/bold cyan] [dim](built-in)[/dim]\n")
+                        if agent_name == "Explore":
+                            console.print("Fast codebase exploration agent (read-only)")
+                            console.print("\n[bold]Tools:[/bold] glob, grep, read_file, list_files, semantic_search")
+                        elif agent_name == "Plan":
+                            console.print("Implementation planning agent")
+                            console.print("\n[bold]Tools:[/bold] glob, grep, read_file, list_files, semantic_search")
+                        console.print()
+                    else:
+                        agent = get_custom_agent(agent_name, Path.cwd())
+                        if agent:
+                            console.print(f"\n[bold cyan]{agent.name}[/bold cyan] [dim](custom)[/dim]\n")
+                            if agent.description:
+                                console.print(f"[bold]Description:[/bold] {agent.description}")
+                            if agent.tools:
+                                console.print(f"[bold]Tools:[/bold] {', '.join(agent.tools)}")
+                            if agent.file_path:
+                                console.print(f"[bold]File:[/bold] {agent.file_path}")
+                            if agent.system_prompt:
+                                console.print(f"\n[bold]System Prompt:[/bold]")
+                                # Show first 500 chars of system prompt
+                                preview = agent.system_prompt[:500]
+                                if len(agent.system_prompt) > 500:
+                                    preview += "..."
+                                console.print(Panel(preview, border_style="dim"))
+                            console.print()
+                        else:
+                            console.print(f"[yellow]Agent '{agent_name}' not found[/yellow]")
+                            console.print("[dim]Use /agents to list available agents[/dim]")
+
+            else:
+                console.print(f"[yellow]Unknown subcommand: {subcommand}[/yellow]")
+                console.print("[dim]Usage: /agents [list|create|show] [name][/dim]")
+
+        elif command == "/session":
+            # Session management: list, save, load, delete, clear
+            from ..session_store import SessionStore
+
+            store = SessionStore(Path.cwd())
+
+            # Parse subcommand
+            subparts = args.split(maxsplit=1) if args else []
+            subcommand = subparts[0].lower() if subparts else "list"
+            subargs = subparts[1].strip() if len(subparts) > 1 else ""
+
+            if subcommand == "list" or subcommand == "":
+                # List all sessions
+                sessions = store.list_sessions()
+                if sessions:
+                    console.print("\n[bold cyan]Saved Sessions[/bold cyan]\n")
+                    for s in sessions:
+                        mode_color = "green" if s.mode == "code" else "yellow"
+                        active_marker = " [bold green]*[/bold green]" if store.get_active_session() == s.name else ""
+                        console.print(f"  [cyan]{s.name}[/cyan]{active_marker} [{mode_color}]{s.mode}[/{mode_color}]")
+                        console.print(f"    [dim]{s.message_count} messages | {s.updated_at[:10]}[/dim]")
+                        if s.summary:
+                            summary = s.summary[:60] + "..." if len(s.summary) > 60 else s.summary
+                            console.print(f"    [dim]{summary}[/dim]")
+                    console.print()
+                else:
+                    console.print("\n[dim]No saved sessions.[/dim]")
+                    console.print("[dim]Save with: /session save <name>[/dim]\n")
+
+            elif subcommand == "save":
+                if not subargs:
+                    console.print("[yellow]Usage: /session save <name>[/yellow]")
+                    console.print("[dim]Example: /session save auth-feature[/dim]")
+                else:
+                    # Get current messages from the API session
+                    if session_id:
+                        try:
+                            # Export messages from server
+                            export_resp = client.get(f"/api/agent/chat/{session_id}/export")
+                            if export_resp.status_code == 200:
+                                data = export_resp.json()
+                                messages = data.get("messages", [])
+                            else:
+                                messages = []
+                        except Exception:
+                            messages = []
+                    else:
+                        messages = []
+
+                    success, msg = store.save_session(
+                        name=subargs,
+                        messages=messages,
+                        mode=current_mode.value,
+                        spec=current_spec,
+                        model=model,
+                    )
+                    if success:
+                        store.set_active_session(subargs)
+                        console.print(f"[green]{msg}[/green]")
+                    else:
+                        console.print(f"[yellow]{msg}[/yellow]")
+
+            elif subcommand == "load":
+                if not subargs:
+                    console.print("[yellow]Usage: /session load <name>[/yellow]")
+                else:
+                    session_data = store.load_session(subargs)
+                    if session_data:
+                        # Reset current session
+                        session_id = None
+                        current_spec = session_data.spec
+                        if session_data.mode == "plan":
+                            current_mode = AgentMode.PLAN
+                        else:
+                            current_mode = AgentMode.CODE
+
+                        # Store loaded messages for replay
+                        nonlocal loaded_messages
+                        loaded_messages = session_data.messages
+
+                        store.set_active_session(subargs)
+                        console.print(f"[green]Loaded session '{subargs}'[/green]")
+                        console.print(f"[dim]{len(session_data.messages)} messages restored, mode: {current_mode.value}[/dim]")
+                        if current_spec:
+                            console.print("[dim]Spec restored[/dim]")
+                    else:
+                        console.print(f"[yellow]Session '{subargs}' not found[/yellow]")
+
+            elif subcommand == "delete":
+                if not subargs:
+                    console.print("[yellow]Usage: /session delete <name>[/yellow]")
+                else:
+                    success, msg = store.delete_session(subargs)
+                    if success:
+                        console.print(f"[green]{msg}[/green]")
+                    else:
+                        console.print(f"[yellow]{msg}[/yellow]")
+
+            elif subcommand == "clear":
+                # Clear current session state
+                session_id = None
+                current_spec = None
+                loaded_messages = []
+                store.set_active_session(None)
+                console.print("[green]Session cleared[/green]")
+
+            else:
+                console.print(f"[yellow]Unknown subcommand: {subcommand}[/yellow]")
+                console.print("[dim]Usage: /session [list|save|load|delete|clear] [name][/dim]")
+
         else:
             console.print(f"[yellow]Unknown command: {command}[/yellow]")
             console.print("[dim]Type /help for available commands[/dim]")
@@ -695,14 +1138,13 @@ def _run_interactive(
     except Exception:
         pass
 
+    # Welcome banner
     console.print()
-    console.print(f"[bold cyan]EmDash Agent[/bold cyan] [dim]v{__version__}[/dim]")
-    console.print(f"Mode: [bold]{current_mode.value}[/bold] | Model: [dim]{model or 'default'}[/dim]")
+    console.print(f"[bold cyan]Mendy10 Emdash Code[/bold cyan] [dim]v{__version__}[/dim]")
     if git_repo:
-        console.print(f"Repo: [bold green]{git_repo}[/bold green] | Path: [dim]{cwd}[/dim]")
+        console.print(f"[dim]Repo:[/dim] [bold green]{git_repo}[/bold green] [dim]| Mode:[/dim] [bold]{current_mode.value}[/bold] [dim]| Model:[/dim] {model or 'default'}")
     else:
-        console.print(f"Path: [dim]{cwd}[/dim]")
-    console.print("Type your task or [cyan]/help[/cyan] for commands. Use Ctrl+C to exit.")
+        console.print(f"[dim]Mode:[/dim] [bold]{current_mode.value}[/bold] [dim]| Model:[/dim] {model or 'default'}")
     console.print()
 
     while True:
@@ -713,6 +1155,16 @@ def _run_interactive(
             if not user_input:
                 continue
 
+            # Check if input is an image file path (dragged file)
+            clean_input = user_input.replace("\\ ", " ")
+            if clean_input.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp')):
+                from ..clipboard import get_image_from_path
+                image_data = get_image_from_path(clean_input)
+                if image_data:
+                    base64_data, img_format = image_data
+                    attached_images.append({"data": base64_data, "format": img_format})
+                    continue  # Prompt again for actual message
+
             # Handle slash commands
             if user_input.startswith("/"):
                 if not handle_slash_command(user_input):
@@ -731,15 +1183,28 @@ def _run_interactive(
 
             # Run agent with current mode
             try:
+                # Prepare images for API call
+                images_to_send = attached_images if attached_images else None
+
                 if session_id:
-                    stream = client.agent_continue_stream(session_id, user_input)
+                    stream = client.agent_continue_stream(
+                        session_id, user_input, images=images_to_send
+                    )
                 else:
+                    # Pass loaded_messages from saved session if available
                     stream = client.agent_chat_stream(
                         message=user_input,
                         model=model,
                         max_iterations=max_iterations,
                         options=request_options,
+                        images=images_to_send,
+                        history=loaded_messages if loaded_messages else None,
                     )
+                    # Clear loaded_messages after first use
+                    loaded_messages = []
+
+                # Clear attached images after sending
+                attached_images = []
 
                 # Render the stream and capture any spec output
                 result = _render_with_interrupt(renderer, stream)
@@ -752,22 +1217,56 @@ def _run_interactive(
                 if result and result.get("spec"):
                     current_spec = result["spec"]
 
-                # Handle clarification with options (interactive selection)
-                clarification = result.get("clarification")
-                if clarification and clarification.get("options") and session_id:
+                # Handle clarifications (may be chained - loop until no more)
+                while True:
+                    clarification = result.get("clarification")
+                    if not (clarification and session_id):
+                        break
+
                     response = _get_clarification_response(clarification)
-                    if response:
-                        # Continue session with user's choice
-                        stream = client.agent_continue_stream(session_id, response)
+                    if not response:
+                        break
+
+                    # Show the user's selection in the chat
+                    console.print()
+                    console.print(f"[dim]Selected:[/dim] [bold]{response}[/bold]")
+                    console.print()
+
+                    # Use dedicated clarification answer endpoint
+                    try:
+                        stream = client.clarification_answer_stream(session_id, response)
                         result = _render_with_interrupt(renderer, stream)
 
                         # Update mode if user chose code
                         if "code" in response.lower():
                             current_mode = AgentMode.CODE
+                    except Exception as e:
+                        console.print(f"[red]Error continuing session: {e}[/red]")
+                        break
+
+                # Handle plan mode entry request (show approval menu)
+                plan_mode_requested = result.get("plan_mode_requested")
+                if plan_mode_requested is not None and session_id:
+                    choice, feedback = _show_plan_mode_approval_menu()
+
+                    if choice == "approve":
+                        current_mode = AgentMode.PLAN
+                        console.print()
+                        console.print("[bold green]✓ Plan mode activated[/bold green]")
+                        console.print()
+                        # Use the planmode approve endpoint
+                        stream = client.planmode_approve_stream(session_id)
+                        result = _render_with_interrupt(renderer, stream)
+                        # After approval, check if there's now a plan submitted
+                        if result.get("plan_submitted"):
+                            plan_submitted = result.get("plan_submitted")
+                    elif choice == "reject":
+                        # Use the planmode reject endpoint - stay in code mode
+                        stream = client.planmode_reject_stream(session_id, feedback)
+                        _render_with_interrupt(renderer, stream)
 
                 # Handle plan mode completion (show approval menu)
                 # Only show menu when agent explicitly submits a plan via exit_plan tool
-                content = result.get("content", "")
                 plan_submitted = result.get("plan_submitted")
                 should_show_plan_menu = (
                     current_mode == AgentMode.PLAN and
@@ -779,20 +1278,13 @@ def _run_interactive(
 
                     if choice == "approve":
                         current_mode = AgentMode.CODE
-                        # Reset mode state to CODE
-                        from emdash_core.agent.tools.modes import ModeState, AgentMode as CoreMode
-                        ModeState.get_instance().current_mode = CoreMode.CODE
-                        stream = client.agent_continue_stream(
-                            session_id,
-                            "The plan has been approved. Start implementing it now."
-                        )
+                        # Use the plan approve endpoint which properly resets mode on server
+                        stream = client.plan_approve_stream(session_id)
                         _render_with_interrupt(renderer, stream)
                     elif choice == "reject":
                         if feedback:
-                            stream = client.agent_continue_stream(
-                                session_id,
-                                f"The plan was rejected. Please revise based on this feedback: {feedback}"
-                            )
+                            # Use the plan reject endpoint which keeps mode as PLAN on server
+                            stream = client.plan_reject_stream(session_id, feedback)
                             _render_with_interrupt(renderer, stream)
                         else:
                             console.print("[dim]Plan rejected[/dim]")