feat(chat): add --yolo flag to auto-approve tool calls

Gated by a typed I ACCEPT acknowledgement at boot; surfaces a red
banner and toolbar badge while active and logs each auto-approved
call.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: aorumbayev

docs/guides/chat.md

@@ -21,10 +21,15 @@ kagan chat                         # interactive REPL
 kagan chat --prompt "Plan a refactor"  # single-shot (send, print, exit)
 kagan chat --session-id <id>       # resume a previous session
 kagan chat --agent opencode        # override agent backend
+kagan chat --yolo                  # auto-approve every tool call
 ```
 
 The REPL persists conversation history across restarts. Type a message and press Enter to send. `Ctrl+D` or `/exit` to quit.
 
+### Yolo mode
+
+`--yolo` skips the per-tool-call permission prompt and auto-approves every request for the session. On boot it shows a disclaimer and requires you to type `I ACCEPT` exactly; anything else aborts. The boot banner border turns red and a `YOLO` badge appears in the bottom toolbar while it is active. Each auto-approved call is still logged as `● yolo auto-approve: <tool>` so you can see what ran. Use only inside disposable worktrees or sandboxes you trust the agent to operate on unattended.
+
 ______________________________________________________________________
 
 ## AI Panel

docs/reference/cli.md

@@ -57,9 +57,10 @@ Slash commands and usage: [Chat guide](../guides/chat.md).
 
 | Option          | Description                                |
 | --------------- | ------------------------------------------ |
-| `--prompt TEXT` | Single-shot mode (send once, print, exit)  |
-| `--session-id`  | Attach to an existing chat or task session |
-| `--agent`       | Override default orchestrator backend      |
+| `--prompt TEXT` | Single-shot mode (send once, print, exit)         |
+| `--session-id`  | Attach to an existing chat or task session        |
+| `--agent`       | Override default orchestrator backend             |
+| `--yolo`        | Auto-approve every tool call (typed ack required) |
 
 ______________________________________________________________________
 

src/kagan/cli/chat/_chat_acp.py

@@ -185,9 +185,10 @@ def _prompt_for_permission_option(options: list[Any], tool_call: Any) -> Any | N
 
 
 class _OrchestratorACPClient(ACPClientBase):
-    def __init__(self) -> None:
+    def __init__(self, *, yolo: bool = False) -> None:
         self._conn: Any = None
         self._streaming = False
+        self._yolo = yolo
         self._show_thoughts = _env_flag_enabled("KAGAN_CHAT_SHOW_THOUGHTS", default=False)
         self._tool_runs = ToolRunTracker()
         self._response_chunks = ResponseChunkBuffer()
@@ -304,6 +305,17 @@ async def request_permission(self, options: Any, session_id: str, tool_call: Any
             return _cancelled_permission_response()
 
         self._output_flusher.flush(force=True)
+
+        if self._yolo:
+            for option in permission_options:
+                if getattr(option, "kind", None) == "allow_once":
+                    title = _format_permission_tool(tool_call)
+                    _console.print(
+                        f"  [red]● yolo auto-approve:[/red] [dim]{_rich_escape(title)}[/dim]",
+                        highlight=False,
+                    )
+                    return _selected_permission_response(option)
+
         if not _stdio_is_interactive():
             _console.print("[yellow]Permission request denied in non-interactive mode.[/yellow]")
             return _cancelled_permission_response()

src/kagan/cli/chat/_yolo.py

@@ -0,0 +1,56 @@
+"""Yolo-mode disclaimer prompt — explicit acknowledgement gate."""
+
+import sys
+from typing import Any
+
+_DISCLAIMER_TITLE = "[bold red]:warning:  YOLO MODE :warning:[/bold red]"
+_DISCLAIMER_BODY = (
+    "You are about to start the chat with [bold]--yolo[/bold] enabled.\n\n"
+    "Every tool call requested by the agent will be [bold red]auto-approved "
+    "without prompting[/bold red]. This includes:\n"
+    "  • Editing or deleting files\n"
+    "  • Running shell commands\n"
+    "  • Making network requests\n"
+    "  • Calling MCP tools and external integrations\n\n"
+    "Use this only inside disposable sandboxes or worktrees you trust the\n"
+    "agent to operate on unattended. You assume full responsibility for any\n"
+    "destructive actions taken on your behalf."
+)
+_ACK_PHRASE = "I ACCEPT"
+
+
+def confirm_yolo_disclaimer(console: Any) -> bool:
+    """Display the yolo disclaimer and require an explicit typed acknowledgement.
+
+    Returns True only when the user types the acknowledgement phrase exactly.
+    Aborts (returns False) on EOF, Ctrl+C, non-interactive stdio, or any other
+    response.
+    """
+    console.print()
+    console.print(_DISCLAIMER_TITLE)
+    console.print(_DISCLAIMER_BODY)
+    console.print()
+
+    if not (sys.stdin.isatty() and sys.stdout.isatty()):
+        console.print(
+            "[yellow]--yolo requires an interactive terminal for "
+            "acknowledgement; aborting.[/yellow]"
+        )
+        return False
+
+    console.print(
+        f"[bold]Type [red]{_ACK_PHRASE}[/red] to continue, anything else to abort:[/bold]"
+    )
+    try:
+        answer = input("> ").strip()
+    except (EOFError, KeyboardInterrupt):
+        console.print("[yellow]Yolo mode declined.[/yellow]")
+        return False
+
+    if answer != _ACK_PHRASE:
+        console.print("[yellow]Yolo mode declined.[/yellow]")
+        return False
+
+    console.print("[bold red]Yolo mode active — all tool calls will be auto-approved.[/bold red]")
+    console.print()
+    return True

src/kagan/cli/chat/controller.py

@@ -158,11 +158,13 @@ def __init__(
         agent_backend: str = "claude-code",
         mcp_session_id: str | None = None,
         prefer_session_backend: bool = True,
+        yolo: bool = False,
     ) -> None:
         self.client = client
         self.agent_backend = agent_backend
         self._mcp_session_id = mcp_session_id
         self._prefer_session_backend = prefer_session_backend
+        self._yolo = yolo
         self._acp_conn: Any | None = None
         self._acp_client: _OrchestratorACPClient | None = None
         self._acp_session_id: str | None = None
@@ -669,7 +671,7 @@ async def _run_agent_session(self, *, prompt: str | None = None) -> None:
             backend_env_vars=backend.env_vars,
         )
 
-        self._acp_client = _OrchestratorACPClient()
+        self._acp_client = _OrchestratorACPClient(yolo=self._yolo)
 
         try:
             async with acp.spawn_agent_process(

src/kagan/cli/chat/repl.py

@@ -10,7 +10,7 @@
 from dataclasses import dataclass
 from importlib.metadata import version
 from pathlib import Path
-from typing import Final, Literal
+from typing import Any, Final, Literal
 
 from prompt_toolkit import PromptSession
 from prompt_toolkit.application.current import get_app
@@ -68,6 +68,7 @@ class ToolbarState:
     context_pct: float | None = None
     workspace_label: str = ""
     is_streaming: bool = False
+    yolo: bool = False
 
 
 _TOOLBAR_STATE = ToolbarState()
@@ -500,6 +501,8 @@ def _cycle_history(event, direction: Literal["up", "down"]) -> None:
 def _bottom_toolbar() -> FormattedText:
     status_left = _TOOLBAR_STATE.workspace_label or _display_path(Path.cwd())
     status_right_parts: list[str] = []
+    if _TOOLBAR_STATE.yolo:
+        status_right_parts.append("YOLO")
     if _TOOLBAR_STATE.agent_backend:
         status_right_parts.append(_TOOLBAR_STATE.agent_backend)
     if _TOOLBAR_STATE.context_pct is not None:
@@ -609,7 +612,10 @@ def _get_prompt_session() -> PromptSession[str]:
 
 
 def _write_boot_banner(
-    project_root: Path | None = None, *, agent_backend: str | None = None
+    project_root: Path | None = None,
+    *,
+    agent_backend: str | None = None,
+    yolo: bool = False,
 ) -> None:
     ver = version("kagan")
     cols = shutil.get_terminal_size().columns
@@ -622,11 +628,16 @@ def _write_boot_banner(
         (f" {_BOOT_TIP_TEXT}", "dim"),
     )
     safety = Text("Review agent output before you apply it.", style="dim")
+    body: list[Any] = [title, subtitle, tip, safety]
+    if yolo:
+        body.append(
+            Text("YOLO MODE — every tool call auto-approved.", style="bold red"),
+        )
 
     banner = Panel(
-        Group(title, subtitle, tip, safety),
+        Group(*body),
         box=box.ROUNDED,
-        border_style="green",
+        border_style="red" if yolo else "green",
         padding=(0, 2),
         expand=False,
         width=panel_width,
@@ -678,10 +689,15 @@ async def run_chat_async(
     prompt: str | None = None,
     session_id: str | None = None,
     agent: str | None = None,
+    yolo: bool = False,
 ) -> str | None:
+    from kagan.cli.chat._yolo import confirm_yolo_disclaimer
     from kagan.cli.chat.controller import ChatController
     from kagan.core import KaganCore, resolve_default_agent_backend
 
+    if yolo and not confirm_yolo_disclaimer(_console):
+        return None
+
     async with KaganCore() as client:
         backend = agent
         if not backend:
@@ -693,6 +709,7 @@ async def run_chat_async(
             agent_backend=backend,
             mcp_session_id=session_id,
             prefer_session_backend=agent is None,
+            yolo=yolo,
         )
 
         if not await controller.ensure_project():
@@ -704,8 +721,9 @@ async def run_chat_async(
         _TOOLBAR_STATE.agent_backend = controller.agent_backend
         _TOOLBAR_STATE.turn_count = controller._turn_count
         _TOOLBAR_STATE.context_pct = None
+        _TOOLBAR_STATE.yolo = yolo
 
-        _write_boot_banner(Path.cwd(), agent_backend=controller.agent_backend)
+        _write_boot_banner(Path.cwd(), agent_backend=controller.agent_backend, yolo=yolo)
 
         await controller.run(prompt=prompt)
 
@@ -716,5 +734,6 @@ def run_chat(
     prompt: str | None = None,
     session_id: str | None = None,
     agent: str | None = None,
+    yolo: bool = False,
 ) -> str | None:
-    return asyncio.run(run_chat_async(prompt=prompt, session_id=session_id, agent=agent))
+    return asyncio.run(run_chat_async(prompt=prompt, session_id=session_id, agent=agent, yolo=yolo))

src/kagan/cli/chat_cmd.py

@@ -47,11 +47,22 @@
 @click.option(
     "--agent", "agent", type=str, default=None, help="Override the default agent backend."
 )
+@click.option(
+    "--yolo",
+    "yolo",
+    is_flag=True,
+    default=False,
+    help=(
+        "Auto-approve every tool call without prompting. Requires explicit "
+        "acknowledgement of a safety disclaimer at startup."
+    ),
+)
 def chat(
     prompt_argument: str | None,
     prompt_text: str | None,
     session_id: str | None,
     agent: str | None,
+    yolo: bool,
 ) -> None:
     """Start an interactive chat or run a single prompt."""
     logger.debug("Chat command invoked")
@@ -66,6 +77,7 @@ def chat(
                 prompt=prompt_text if prompt_text is not None else prompt_argument,
                 session_id=session_id,
                 agent=agent,
+                yolo=yolo,
             )
         )
     except KeyboardInterrupt:

tests/core/test_cli_surface.py

@@ -445,18 +445,25 @@ async def _fake_run_chat_async(
         prompt: str | None = None,
         session_id: str | None = None,
         agent: str | None = None,
+        yolo: bool = False,
     ) -> None:
         captured["prompt"] = prompt
         captured["session_id"] = session_id
         captured["agent"] = agent
+        captured["yolo"] = yolo
 
     monkeypatch.setattr("kagan.cli.chat.run_chat_async", _fake_run_chat_async)
 
     runner = CliRunner()
     result = runner.invoke(cli, ["chat", "fix the bug"], env=_runner_env(tmp_path))
 
     assert result.exit_code == 0
-    assert captured == {"prompt": "fix the bug", "session_id": None, "agent": None}
+    assert captured == {
+        "prompt": "fix the bug",
+        "session_id": None,
+        "agent": None,
+        "yolo": False,
+    }
 
 
 def test_chat_rejects_positional_prompt_with_prompt_option(tmp_path: Path) -> None: