hanuscode 1.0.0__py3-none-any.whl

hanus/agent_runner.py

@@ -0,0 +1,1445 @@
+# hanus/agent_runner.py
+from __future__ import annotations
+import sys
+import textwrap as _tw
+from pathlib import Path
+from datetime import datetime
+
+try:
+    from colorama import init as _cinit
+    _cinit(autoreset=True)
+except ImportError:
+    pass
+
+try:
+    from hanus.config import HanusConfig
+    from hanus.ui import UI, _strip_xml, W, P
+    from hanus.permissions import PermissionManager, PermissionMode
+    from hanus.session_manager import SessionManager
+    from hanus.query_engine import QueryEngine
+    from hanus.plugin_manager import PluginManager
+    from hanus.tools import ToolExecutor
+    from hanus.profiles import ProfileManager
+    from hanus.tasks import TaskManager
+    from hanus.memory import MemoryManager
+    from hanus.context import ContextManager
+    from hanus.subagent import SubagentManager
+    from hanus.plan import PlanMode
+    from hanus.skill_manager import get_skill_manager
+    from hanus.monitor import get_monitor_manager
+    import hanus.connectors
+    import hanus.logger as log
+    from hanus.connectors.registry import ConnectorRegistry
+    from hanus.project_tools import list_files, build_context_from_folder
+except ImportError as e:
+    print(f"\033[91m[ERROR] Import error: {e}\033[0m")
+    print()
+    print("\033[93mTo install from GitHub:\033[0m")
+    print("  git clone https://github.com/hanuscode/hanuscode.git")
+    print("  cd hanuscode")
+    print("  pip install -e .")
+    print()
+    print("\033[93mOr if already cloned, from the project directory:\033[0m")
+    print("  pip install -e .")
+    print()
+    print("\033[93mBasic dependencies:\033[0m")
+    print("  pip install colorama requests pyyaml")
+    sys.exit(1)
+
+
+# ─── Helpers ──────────────────────────────────────────────────────────────────
+
+def _build_context(config):
+    return build_context_from_folder(
+        str(config.root_dir),
+        max_files=config.context_max_files,
+        include_content=config.context_include_content,
+        content_preview_chars=config.context_preview_chars,
+    )
+
+
+def _make_connector(config, ui):
+    try:
+        return ConnectorRegistry.get(config.provider, config.get_connector_config())
+    except Exception as e:
+        ui.error(f"Could not create connector '{config.provider}': {e}")
+        ui.info(f"Available: {ConnectorRegistry.available()}")
+        sys.exit(1)
+
+
+def _autosave(config, session_mgr, engine, ui, force=False):
+    if (config.auto_save_session or force) and session_mgr.current:
+        session_mgr.current.messages = engine.get_messages()
+        session_mgr.save()
+        if force:
+            ui.success("Session saved.")
+
+
+def _show_response(response, ui):
+    if not response.text:
+        return
+    ui.stream_start()
+    clean = _strip_xml(response.text)
+    for line in (clean.strip().splitlines() or [""]):
+        if line.strip():
+            for wl in (_tw.wrap(line, W - 4) or [line]):
+                print(f"  {wl}")
+        else:
+            print()
+    ui.stream_end()
+
+
+def _cmd_exact(s: str, target: str) -> bool:
+    return s.lower().strip() == target
+
+
+def _cmd_is(s: str, target: str) -> bool:
+    lower = s.lower().strip()
+    return lower == target or lower.startswith(target + " ")
+
+
+def _make_engine(config, connector, executor, session_mgr, plugin_mgr, ui, context_mgr=None):
+    return QueryEngine(
+        connector=connector,
+        tool_executor=executor,
+        session_manager=session_mgr,
+        permission_manager=executor.perms,
+        plugin_manager=plugin_mgr,
+        stream_callback=ui.stream_token,
+        tool_start_callback=ui.tool_start,
+        tool_end_callback=ui.tool_end,
+        thinking_callback=ui.thinking,
+        budget_usd=config.budget_usd,
+        context_manager=context_mgr,
+        ui=ui,
+    )
+
+
+# ─── Main ─────────────────────────────────────────────────────────────────────
+
+def main():
+    """Entry point principal - detecta argumentos CLI."""
+    cli_main()
+
+
+def cli_main():
+    """
+    CLI entry point with argument handling.
+    Supports both interactive and non-interactive modes.
+    """
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        prog="hanuscode",
+        description="Autonomous Programming Agent for Terminal and Web",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  hanuscode                           # Interactive mode in current directory
+  hanuscode --cmd "Analyze the code"  # Execute command and exit
+  hanuscode -c "Create a README"      # Short form
+  hanuscode --path /project --cmd "..." # In specific directory
+        """
+    )
+
+    parser.add_argument("--cmd", "-c", type=str, default=None,
+                        help="Command to execute (exits after completion)")
+    parser.add_argument("--path", "-p", type=str, default=None,
+                        help="Working directory (default: current directory)")
+    parser.add_argument("--profile", type=str, default=None,
+                        help="Profile to use: developer, security, auditor, architect")
+    parser.add_argument("--model", type=str, default=None,
+                        help="Model to use: provider/model")
+    parser.add_argument("--mode", type=str, default=None,
+                        choices=["default", "plan", "bypass"],
+                        help="Permission mode: default, plan, bypass")
+    parser.add_argument("--version", "-v", action="store_true",
+                        help="Show version")
+
+    args = parser.parse_args()
+
+    # Show version
+    if args.version:
+        print("hanuscode 1.0.0")
+        return
+
+    # Change directory if specified
+    if args.path:
+        path = Path(args.path).expanduser().resolve()
+        if not path.exists():
+            print(f"Error: Directory not found: {path}")
+            return
+        import os
+        os.chdir(path)
+
+    # Execute
+    run_with_args(
+        cmd=args.cmd,
+        profile=args.profile,
+        model=args.model,
+        mode=args.mode
+    )
+
+
+def run_with_args(cmd: str = None, profile: str = None, model: str = None, mode: str = None):
+    """
+    Execute hanuscode with CLI arguments.
+    If `cmd` is passed, executes the command and exits (non-interactive mode).
+    """
+    from hanus.terminal_prompt import get_prompt, restore_terminal
+
+    cwd = Path.cwd()
+    config = HanusConfig.load(project_dir=cwd)
+    ui = UI()
+
+    # Aplicar argumentos CLI
+    if mode:
+        try:
+            config.permission_mode = PermissionMode(mode.lower()).value
+        except ValueError:
+            ui.error(f"Invalid mode: {mode}. Options: default, plan, bypass")
+            sys.exit(1)
+
+    if model:
+        parts = model.split("/", 1)
+        if len(parts) == 2:
+            config.provider = parts[0].lower()
+            config.model_id = parts[1]
+        else:
+            config.model_id = model
+
+    # ── Profiles ──────────────────────────────────────────────────────────────
+    profile_mgr = ProfileManager()
+
+    # If profile specified via CLI, use it
+    if profile:
+        requested = profile_mgr.get(profile)
+        if requested:
+            profile_mgr.set_active(profile)
+            active_profile = requested
+            profile_mgr.apply_to_config(active_profile, config)
+        else:
+            ui.error(f"Profile not found: {profile}")
+            ui.info(f"Available: {[p.name for p in profile_mgr.list_profiles()]}")
+            sys.exit(1)
+    else:
+        active_profile = profile_mgr.get_active()
+        if active_profile:
+            profile_mgr.apply_to_config(active_profile, config)
+
+    # ── Non-interactive mode (--cmd) ────────────────────────────────────────────
+    if cmd:
+        _run_single_command(cmd, config, ui, active_profile, profile_mgr, cwd)
+        return
+
+    # ── Normal interactive mode ────────────────────────────────────────────────
+    tp = get_prompt()
+    try:
+        _main_loop()
+    finally:
+        restore_terminal()
+
+
+def _run_single_command(cmd: str, config, ui, active_profile, profile_mgr, cwd):
+    """Execute a single command and exit (non-interactive mode)."""
+    # ── Permissions ──────────────────────────────────────────────────────────────
+    perm_mode = PermissionMode(config.permission_mode)
+    perms = PermissionManager(mode=perm_mode)
+    # In CMD mode, approve everything automatically
+    perms.set_mode(PermissionMode.BYPASS)
+
+    # ── Task Manager ──────────────────────────────────────────────────────────
+    task_mgr = TaskManager(cwd)
+
+    # ── Memory Manager ────────────────────────────────────────────────────────
+    memory_mgr = MemoryManager(cwd)
+
+    # ── Context Manager ───────────────────────────────────────────────────────
+    # Usar configuración de ventana de contexto, con fallback a 200k tokens
+    context_window = config.context_window if config.context_window > 0 else 200000
+    context_mgr = ContextManager(
+        max_tokens=context_window,
+        preserve_recent=max(10, context_window // 5000)  # Preservar más mensajes en contextos grandes
+    )
+
+    executor = ToolExecutor(cwd, perms, task_manager=task_mgr)
+    executor.perms = perms
+    executor.memory = memory_mgr
+
+    # Callback for ask_user (in non-interactive mode, use default)
+    def ask_user_callback(question: str, header: str, options: list, multi_select: bool) -> dict:
+        # In CMD mode, select the first option by default
+        if options:
+            return {"answers": {question: options[0]}}
+        return {}
+
+    executor.ask_user_callback = ask_user_callback
+
+    session_mgr = SessionManager()
+    session_mgr.new_session(str(cwd), config.provider, config.model_id)
+
+    # ── Plugins ───────────────────────────────────────────────────────────────
+    pkg_plugins = Path(__file__).parent / "plugins"
+    plugins_local = cwd / "plugins"
+    plugin_mgr = PluginManager(pkg_plugins) if pkg_plugins.exists() else PluginManager(plugins_local)
+    if plugins_local.exists() and plugins_local.is_dir():
+        local_mgr = PluginManager(plugins_local)
+        for name, plugin in local_mgr.plugins.items():
+            plugin_mgr.plugins[name] = plugin
+
+    connector = _make_connector(config, ui)
+
+    # ── Subagent Manager ──────────────────────────────────────────────────────
+    subagent_mgr = SubagentManager(
+        connector=connector,
+        tool_executor=executor,
+        session_manager=session_mgr,
+        permission_manager=perms,
+        root_dir=cwd,
+    )
+    executor.subagents = subagent_mgr
+
+    # ── Plan Mode ─────────────────────────────────────────────────────────────
+    plan_mode = PlanMode(cwd)
+    executor.plan_mode = plan_mode
+
+    # ── Skill Manager ────────────────────────────────────────────────────────
+    skill_mgr = get_skill_manager()
+
+    # ── Monitor Manager ───────────────────────────────────────────────────────
+    monitor_mgr = get_monitor_manager()
+
+    # ── Engine ────────────────────────────────────────────────────────────────
+    engine = QueryEngine(
+        connector=connector,
+        tool_executor=executor,
+        session_manager=session_mgr,
+        permission_manager=perms,
+        plugin_manager=plugin_mgr,
+        stream_callback=ui.stream_token,
+        tool_start_callback=ui.tool_start,
+        tool_end_callback=ui.tool_end,
+        thinking_callback=ui.thinking,
+        budget_usd=config.budget_usd,
+        context_manager=context_mgr,
+        ui=ui,
+    )
+
+    # ── System prompt ─────────────────────────────────────────────────────────
+    plugin_docs = plugin_mgr.get_plugin_docs()
+    if active_profile:
+        system_prompt = active_profile.system_prompt
+        if plugin_docs:
+            system_prompt += f"\n\n## Available Plugins\n\n{plugin_docs}"
+    else:
+        system_prompt = config.load_system_prompt(plugin_docs)
+
+    engine.set_system_prompt(system_prompt)
+
+    # Load memory
+    memory_context = memory_mgr.load_memories()
+    if memory_context:
+        engine._messages.append({"role": "user", "content": memory_context})
+        engine._messages.append({"role": "assistant", "content": "Memory loaded."})
+
+    # Banner and info
+    ui.banner()
+    ml = "native" if connector.NATIVE_TOOLS else "XML"
+    profile_name = active_profile.meta.display if active_profile else "no profile"
+    ui.info(f"Profile: {profile_name}  |  {connector.provider_name}  |  Tools: {ml}  |  Dir: {cwd}")
+
+    context = _build_context(config)
+    engine.inject_context(context)
+
+    # ── Check if command is a plugin command ─────────────────────────────────────
+    if cmd.startswith("/"):
+        parts = cmd[1:].split(maxsplit=1)
+        plugin_name = parts[0].lower() if parts else ""
+        plugin_args = parts[1] if len(parts) > 1 else ""
+        if plugin_name in plugin_mgr.plugins:
+            result = plugin_mgr.run(plugin_name, plugin_args)
+            if result:
+                ui.plugin_result(plugin_name, result)
+            ui.goodbye()
+            sys.exit(0)
+
+    # ── Execute command ──────────────────────────────────────────────────────
+    ui.info(f"Executing: {cmd[:80]}{'...' if len(cmd) > 80 else ''}")
+    print()
+
+    try:
+        response = engine.send(cmd)
+
+        if response.text:
+            _show_response(response, ui)
+
+        if config.show_cost and session_mgr.current:
+            ui.show_cost_bar(
+                response.cost_usd, response.input_tokens, response.output_tokens,
+                session_mgr.current.total_cost_usd, config.budget_usd,
+            )
+
+        # Save session
+        if config.auto_save_session and session_mgr.current:
+            session_mgr.current.messages = engine.get_messages()
+            session_mgr.save()
+
+        print()
+        ui.success("Command completed.")
+        ui.goodbye()
+        sys.exit(0)
+
+    except KeyboardInterrupt:
+        ui.warning("\nInterrupted by user.")
+        sys.exit(130)
+
+    except Exception as e:
+        import traceback
+        ui.error(f"Error: {e}")
+        log.log_error("cmd mode", e)
+        if config.verbose:
+            print(traceback.format_exc())
+        sys.exit(1)
+
+
+def _main_loop():
+    """Main program logic (interactive mode)."""
+    from hanus.terminal_prompt import get_prompt
+
+    cwd    = Path.cwd()
+    config = HanusConfig.load(project_dir=cwd)
+    ui     = UI()
+
+    # ── Profiles ──────────────────────────────────────────────────────────────
+    profile_mgr = ProfileManager()
+    active_profile = profile_mgr.get_active()
+
+    if active_profile:
+        # Apply profile overrides to config
+        profile_mgr.apply_to_config(active_profile, config)
+        log.info(f"Active profile: {active_profile.name}")
+
+    # ── Permissions ──────────────────────────────────────────────────────────────
+    perm_mode = PermissionMode(config.permission_mode)
+    perms     = PermissionManager(mode=perm_mode)
+    perms.set_ask_callback(ui.ask_permission)
+
+    # ── Task Manager ──────────────────────────────────────────────────────────
+    task_mgr = TaskManager(config.root_dir)
+
+    # ── Memory Manager ────────────────────────────────────────────────────────
+    memory_mgr = MemoryManager(config.root_dir)
+
+    # ── Context Manager (context compression) ──────────────────────────────────
+    # Usar configuración de ventana de contexto, con fallback a 200k tokens
+    context_window = config.context_window if config.context_window > 0 else 200000
+    context_mgr = ContextManager(
+        max_tokens=context_window,
+        preserve_recent=max(10, context_window // 5000)  # Preservar más mensajes en contextos grandes
+    )
+
+    executor    = ToolExecutor(config.root_dir, perms, task_manager=task_mgr)
+    executor.perms = perms
+    executor.memory = memory_mgr
+
+    # ── Callback for ask_user ────────────────────────────────────────────────
+    def ask_user_callback(question: str, header: str, options: list, multi_select: bool) -> dict:
+        """Callback for the model to ask the user interactively."""
+        return ui.ask_user_question(question, header, options, multi_select)
+    executor.ask_user_callback = ask_user_callback
+
+    session_mgr = SessionManager()
+    session_mgr.new_session(str(config.root_dir), config.provider, config.model_id)
+
+    # ── Plugins: package as base + local on top ───────────────────────────
+    pkg_plugins   = Path(__file__).parent / "plugins"
+    plugins_local = config.root_dir / "plugins"
+    plugin_mgr    = PluginManager(pkg_plugins) if pkg_plugins.exists() else PluginManager(plugins_local)
+    if plugins_local.exists() and plugins_local.is_dir():
+        local_mgr = PluginManager(plugins_local)
+        for name, plugin in local_mgr.plugins.items():
+            plugin_mgr.plugins[name] = plugin
+
+    connector = _make_connector(config, ui)
+
+    # ── Progress callbacks for subagents ────────────────────────────────────
+    def subagent_progress_callback(agent_id: str, event: str, data: dict):
+        """Display subagent progress in UI."""
+        if event == "started":
+            ui.info(f"🤖 Subagent [{data.get('type', '?')}] started: {data.get('task', '')[:50]}...")
+        elif event == "tool_start":
+            ui.info(f"  ⚡ {data.get('tool', '?')}...")
+        elif event == "tool_end":
+            status = "✓" if data.get("success", False) else "✗"
+            ui.info(f"  {status} {data.get('tool', '?')}")
+        elif event == "completed":
+            tokens = data.get("tokens", 0)
+            ui.info(f"✓ Subagent completed ({tokens:,} tokens)")
+        elif event == "error":
+            ui.error(f"✗ Subagent error: {data.get('error', 'Unknown')}")
+
+    # ── Subagent Manager (task delegation) ────────────────────────────────
+    subagent_mgr = SubagentManager(
+        connector=connector,
+        tool_executor=executor,
+        session_manager=session_mgr,
+        permission_manager=perms,
+        root_dir=config.root_dir,
+        progress_callback=subagent_progress_callback,
+    )
+    executor.subagents = subagent_mgr
+
+    # ── Plan Mode (pre-execution planning) ───────────────────────────────
+    plan_mode = PlanMode(config.root_dir)
+
+    # ── Skill Manager ──────────────────────────────────────────────────────────
+    skill_mgr = get_skill_manager()
+
+    # ── Monitor Manager ─────────────────────────────────────────────────────────
+    monitor_mgr = get_monitor_manager()
+    executor.plan_mode = plan_mode
+
+    engine    = _make_engine(config, connector, executor, session_mgr, plugin_mgr, ui, context_mgr)
+
+    # ── System prompt from active profile ──────────────────────────────────
+    plugin_docs = plugin_mgr.get_plugin_docs()
+    if active_profile:
+        system_prompt = active_profile.system_prompt
+        if plugin_docs:
+            system_prompt += f"\n\n## Available Plugins\n\n{plugin_docs}"
+    else:
+        system_prompt = config.load_system_prompt(plugin_docs)
+
+    engine.set_system_prompt(system_prompt)
+
+    # ── Load persistent memory ─────────────────────────────────────────────
+    memory_context = memory_mgr.load_memories()
+    if memory_context:
+        engine._messages.append({"role": "user", "content": memory_context})
+        engine._messages.append({"role": "assistant", "content": "Memory loaded. I understand the previous context."})
+
+    # ── Banner and status ───────────────────────────────────────────────────────
+    ui.banner()
+    ml           = "native" if connector.NATIVE_TOOLS else "XML"
+    profile_name = active_profile.meta.display if active_profile else "no profile"
+    ui.info(f"Profile: {profile_name}  |  {connector.provider_name}  |  Tools: {ml}  |  Dir: {cwd}")
+    context = _build_context(config)
+    engine.inject_context(context)
+    ui.show_status(config, plugin_mgr, session_mgr.current)
+    ui.show_commands(plugin_mgr, skill_mgr)
+
+    # ═════════════════════════════════════════════════════════════════════════
+    # MAIN LOOP
+    # ═════════════════════════════════════════════════════════════════════════
+    _chrome_input = False  # Track if input came from Chrome
+    _telegram_input = False  # Track if input came from Telegram
+    _telegram_chat_id = None  # Store Telegram chat ID for responses
+    import select
+
+    # Import Chrome plugin ONCE at the start
+    try:
+        from hanus.plugins import chrome as chrome_plugin
+    except ImportError:
+        chrome_plugin = None
+
+    # Import Telegram plugin ONCE at the start
+    try:
+        from hanus.plugins import telegram as telegram_plugin
+    except ImportError:
+        telegram_plugin = None
+
+    # Register Telegram callbacks to access agent state
+    if telegram_plugin:
+        def _telegram_status_callback():
+            """Get current agent status."""
+            return {
+                "running": True,
+                "model": f"{config.provider}/{config.model_id}" if config else "unknown",
+                "project": str(config.root_dir) if config else "none",
+                "session": session_mgr.current if session_mgr else None,
+            }
+
+        def _telegram_project_callback(path=None):
+            """Get or set current project."""
+            if path:
+                config.root_dir = Path(path)
+                config.save()
+                return {"path": str(config.root_dir)}
+            return {"path": str(config.root_dir) if config else "none"}
+
+        def _telegram_model_callback(name=None):
+            """Get or set current model."""
+            if name:
+                parts = name.split("/")
+                if len(parts) == 2:
+                    config.provider = parts[0]
+                    config.model_id = parts[1]
+                    config.save()
+                    return f"{config.provider}/{config.model_id}"
+            return f"{config.provider}/{config.model_id}" if config else "unknown"
+
+        def _telegram_stop_callback():
+            """Stop current execution."""
+            # Signal stop via interrupt
+            import signal
+            import threading
+            import time
+            # This will be handled by the main loop
+            pass
+
+        def _telegram_history_callback(n=10):
+            """Get recent message history."""
+            if not engine:
+                return []
+            messages = engine.get_messages()[-n:] if engine else []
+            return [{"role": m.get("role", ""), "content": m.get("content", "")[:200]} for m in messages]
+
+        def _telegram_logs_callback(n=20):
+            """Get recent logs."""
+            log_file = Path.home() / ".hanus" / "logs" / "hanus.log"
+            if not log_file.exists():
+                return []
+            try:
+                lines = log_file.read_text().splitlines()[-n:]
+                return lines
+            except:
+                return []
+
+        # Register callbacks
+        telegram_plugin.register_callbacks(
+            status_callback=_telegram_status_callback,
+            project_callback=_telegram_project_callback,
+            model_callback=_telegram_model_callback,
+            stop_callback=_telegram_stop_callback,
+            history_callback=_telegram_history_callback,
+            logs_callback=_telegram_logs_callback,
+        )
+
+    def _get_input_with_chrome_poll(timeout=0.5):
+        """Get input from user, Chrome, or Telegram, with polling."""
+        while True:
+            # Check Chrome messages first
+            if chrome_plugin:
+                try:
+                    pending = chrome_plugin.get_pending_chat_messages()
+                    if pending:
+                        return ("chrome", pending)
+                except Exception as e:
+                    pass
+
+            # Check Telegram messages
+            if telegram_plugin:
+                try:
+                    if telegram_plugin.has_pending_messages():
+                        pending = telegram_plugin.get_pending_messages()
+                        if pending:
+                            return ("telegram", pending)
+                except Exception as e:
+                    pass
+
+            # Check if user input is available
+            if select.select([sys.stdin], [], [], timeout)[0]:
+                line = sys.stdin.readline().strip()
+                return ("user", line)
+
+    while True:
+        try:
+            _chrome_input = False
+            _telegram_input = False
+            _telegram_chat_id = None
+            user_input = None
+
+            # Get input from Chrome, Telegram, or user
+            source, data = _get_input_with_chrome_poll()
+
+            if source == "chrome":
+                # Process Chrome message(s)
+                user_input = data[-1]['message']
+                _chrome_input = True
+                for msg in data:
+                    print(f"\n{P.CYAN}📱 [Chrome] Mensaje:{P.R} {msg['message']}")
+                print(f"{P.CYAN}▶ Procesando mensaje de Chrome...{P.R}\n")
+            elif source == "telegram":
+                # Process Telegram message(s)
+                user_input = data[-1]['message']
+                _telegram_chat_id = data[-1].get('chat_id')
+                _telegram_input = True
+                for msg in data:
+                    username = msg.get('username', 'User')
+                    print(f"\n{P.CYAN}📱 [Telegram] @{username}:{P.R} {msg['message']}")
+                print(f"{P.CYAN}▶ Processing Telegram message...{P.R}\n")
+            else:
+                # User input
+                user_input = data
+
+            if not user_input:
+                continue
+
+            log.info(f"USER: {user_input[:120]}")
+
+            # ── Exit ─────────────────────────────────────────────────────────
+            # Normalize input to detect exit commands
+            normalized = user_input.lower().strip()
+            # Also detect with extra spaces or control characters
+            normalized = ''.join(c for c in normalized if c.isalnum() or c.isspace()).strip()
+            if normalized in ("salir", "q", "exit", "quit"):
+                _autosave(config, session_mgr, engine, ui)
+                ui.goodbye()
+                break
+
+            # ── /profile — profile management ────────────────────────────────
+            if _cmd_is(user_input, "/profile"):
+                parts = user_input.strip().split(maxsplit=2)
+                sub   = parts[1].lower() if len(parts) > 1 else ""
+                arg   = parts[2].strip() if len(parts) > 2 else ""
+
+                if not sub or sub == "info":
+                    # /profile → show active profile
+                    ui.show_profile(active_profile)
+                    continue
+
+                if sub == "list":
+                    # /profile list → list all
+                    ui.show_profile(active_profile, all_profiles=profile_mgr.list_profiles())
+                    continue
+
+                if sub == "new":
+                    # /profile new <name> [description]
+                    if not arg:
+                        ui.error("Usage: /profile new <name>")
+                        continue
+                    name_parts = arg.split(maxsplit=1)
+                    pname      = name_parts[0].lower().replace(" ", "_")
+                    desc       = name_parts[1] if len(name_parts) > 1 else f"Profile {pname}"
+                    base_input = input(f"  Based on profile (developer/security/empty): ").strip()
+                    new_p = profile_mgr.create(pname, pname.title(), desc,
+                                               base=base_input or None)
+                    ui.success(f"Profile '{pname}' created.")
+                    prompt_path = profile_mgr.edit_prompt_path(pname)
+                    ui.info(f"Edit prompt at: {prompt_path}")
+                    continue
+
+                if sub == "edit":
+                    # /profile edit <name>
+                    pname       = arg or (active_profile.name if active_profile else "")
+                    prompt_path = profile_mgr.edit_prompt_path(pname)
+                    if prompt_path:
+                        ui.info(f"Edit prompt at:\n  {prompt_path}")
+                        # Try to open with system editor
+                        import os
+                        editor = os.environ.get("EDITOR", "")
+                        if editor:
+                            import subprocess
+                            subprocess.Popen([editor, str(prompt_path)])
+                            ui.info(f"Opening with {editor}...")
+                    else:
+                        ui.error(f"Profile '{pname}' not found.")
+                    continue
+
+                if sub == "reload":
+                    # /profile reload → reload active profile prompt
+                    if active_profile:
+                        active_profile = profile_mgr.get(active_profile.name)
+                        if active_profile:
+                            system_prompt = active_profile.system_prompt
+                            if plugin_docs:
+                                system_prompt += f"\n\n## Available Plugins\n\n{plugin_docs}"
+                            engine.set_system_prompt(system_prompt)
+                            ui.success(f"Profile '{active_profile.name}' reloaded.")
+                        continue
+
+                if sub == "reinstall":
+                    # /profile reinstall → reinstall builtin profiles
+                    reinstalled = profile_mgr.reinstall_builtins()
+                    if reinstalled:
+                        ui.success(f"Profiles reinstalled: {', '.join(reinstalled)}")
+                    else:
+                        ui.info("No profiles were reinstalled.")
+                    continue
+
+                # /profile <name> → switch profile
+                pname   = sub  # sub is the profile name
+                new_p   = profile_mgr.get(pname)
+                if not new_p:
+                    available = [m.name for m in profile_mgr.list_profiles()]
+                    ui.error(f"Profile '{pname}' not found. Available: {available}")
+                    ui.info("Create one with: /profile new <name>")
+                    continue
+
+                # Switch active profile
+                profile_mgr.set_active(pname)
+                active_profile = new_p
+                profile_mgr.apply_to_config(active_profile, config)
+
+                # Rebuild connector if provider changed
+                connector = _make_connector(config, ui)
+                engine.connector = connector
+
+                # Rebuild system prompt with new profile
+                system_prompt = active_profile.system_prompt
+                if plugin_docs:
+                    system_prompt += f"\n\n## Available Plugins\n\n{plugin_docs}"
+                engine.set_system_prompt(system_prompt)
+
+                # Adjust permissions according to profile
+                if active_profile.meta.permission_mode:
+                    try:
+                        nm = PermissionMode(active_profile.meta.permission_mode)
+                        perms.set_mode(nm)
+                    except ValueError:
+                        pass
+
+                ui.success(f"Profile changed to: {active_profile.meta.display}")
+                ui.show_profile(active_profile)
+                log.info(f"Profile changed to: {pname}")
+
+                # Ask if new session
+                try:
+                    ans = input("  Start fresh session with new profile? [Y/n] ").strip().lower()
+                except (EOFError, KeyboardInterrupt):
+                    ans = "y"
+                if not ans or ans.startswith("y"):
+                    engine.clear(system_prompt, _build_context(config))
+                    session_mgr.new_session(str(config.root_dir), config.provider, config.model_id)
+                    ui.success("New session started with active profile.")
+                continue
+
+            # ── Rest of commands ──────────────────────────────────────────────
+            if _cmd_exact(user_input, "/reload"):
+                ui.info("Reloading context...")
+                ctx = _build_context(config)
+                engine._messages.append({"role": "user", "content": f"[Context updated]\n\n{ctx}"})
+                ui.success("Context reloaded.")
+                continue
+
+            if _cmd_exact(user_input, "/stream"):
+                enabled = ui.toggle_streaming()
+                status = "enabled" if enabled else "disabled"
+                ui.success(f"Streaming {status}")
+                continue
+
+            if _cmd_exact(user_input, "/multiline"):
+                # Mode for pasting multiple lines
+                multiline_input = ui.prompt_multiline("Paste your code/text (empty line to finish)")
+                if multiline_input:
+                    user_input = multiline_input
+                    # Don't continue, process input normally
+                else:
+                    continue
+
+            # ── /ask — simple chat without tools ────────────────────────────────────
+            if _cmd_is(user_input, "/ask"):
+                parts = user_input.split(maxsplit=1)
+                if len(parts) < 2:
+                    ui.info("Usage: /ask <question>")
+                    ui.info("Send a simple question without executing any tools.")
+                    continue
+
+                question = parts[1].strip()
+                engine.set_chat_mode(True)  # Enable chat mode (no tools)
+                try:
+                    response = engine.send(question)
+                    if response.text:
+                        _show_response(response, ui)
+                finally:
+                    engine.set_chat_mode(False)  # Disable chat mode
+                continue
+
+            if _cmd_exact(user_input, "/files"):
+                ui.show_files(list_files(str(config.root_dir))); continue
+
+            if _cmd_exact(user_input, "/status"):
+                ui.show_status(config, plugin_mgr, session_mgr.current); continue
+
+            if _cmd_exact(user_input, "/plugins"):
+                ui.show_plugins(plugin_mgr); continue
+
+            if _cmd_exact(user_input, "/history"):
+                ui.show_history(engine.get_messages()); continue
+
+            if _cmd_exact(user_input, "/clear"):
+                engine.clear(system_prompt, _build_context(config))
+                ui.success("Conversation cleared."); continue
+
+            if _cmd_exact(user_input, "/sessions"):
+                ui.show_sessions(session_mgr.list_sessions()); continue
+
+            if _cmd_is(user_input, "/resume"):
+                parts = user_input.split(maxsplit=1)
+                sid   = parts[1].strip() if len(parts) > 1 else None
+                sd    = session_mgr.load_by_id(sid) if sid else session_mgr.load_latest(str(config.root_dir))
+                if sd:
+                    session_mgr.current = sd
+                    engine.set_messages(sd.messages)
+                    ui.success(f"Session resumed: {sd.name}")
+                else:
+                    ui.error("Session not found.")
+                continue
+
+            if _cmd_exact(user_input, "/undo"):
+                rev = session_mgr.undo_last()
+                ui.success(f"Reverted: {rev}") if rev else ui.warning("No changes to undo.")
+                continue
+
+            if _cmd_exact(user_input, "/new"):
+                engine.clear(system_prompt, _build_context(config))
+                session_mgr.new_session(str(config.root_dir), config.provider, config.model_id)
+                ui.success("New session started.")
+                log.info("New session started")
+                continue
+
+            if _cmd_is(user_input, "/mode"):
+                parts = user_input.strip().split(maxsplit=1)
+                if len(parts) > 1:
+                    try:
+                        nm = PermissionMode(parts[1].strip().lower())
+                        perms.set_mode(nm); config.permission_mode = nm.value
+                        ui.success(f"Mode: {nm.value.upper()}")
+                    except ValueError:
+                        ui.error(f"Options: {[m.value for m in PermissionMode]}")
+                else:
+                    ui.info(f"Current mode: {perms.mode.value}")
+                continue
+
+            if _cmd_is(user_input, "/plugins"):
+                from hanus.plugin_manager import run_plugin_command
+                parts = user_input.strip().split(maxsplit=1)
+                args = parts[1] if len(parts) > 1 else ""
+                result = run_plugin_command(args, plugin_mgr)
+                print(result)
+                # Refresh system prompt if plugins changed
+                if any(x in args.lower() for x in ["enable", "disable", "toggle", "reload"]):
+                    plugin_docs = plugin_mgr.get_plugin_docs()
+                    system_prompt = config.load_system_prompt(plugin_docs)
+                    engine.set_system_prompt(system_prompt)
+                    ui.info("System prompt updated.")
+                continue
+
+            if _cmd_exact(user_input, "/models"):
+                ui.show_models(connector); continue
+
+            if _cmd_is(user_input, "/model"):
+                parts = user_input.strip().split(maxsplit=2)
+                if len(parts) == 1:
+                    ui.info(f"Current: {config.provider}/{config.model_id}")
+                    ui.info(f"Providers: {ConnectorRegistry.available()}")
+                elif len(parts) == 2:
+                    arg = parts[1].strip()
+                    if arg.lower() in ConnectorRegistry.available():
+                        config.provider = arg.lower()
+                    else:
+                        config.model_id = arg
+                    connector = _make_connector(config, ui)
+                    engine.connector = connector
+                    engine.set_system_prompt(system_prompt)
+                    ml = "native" if connector.NATIVE_TOOLS else "XML"
+                    ui.success(f"Model: {config.provider}/{config.model_id} ({ml})")
+                else:
+                    config.provider = parts[1].strip().lower()
+                    config.model_id = parts[2].strip()
+                    connector = _make_connector(config, ui)
+                    engine.connector = connector
+                    engine.set_system_prompt(system_prompt)
+                    ml = "native" if connector.NATIVE_TOOLS else "XML"
+                    ui.success(f"Model: {config.provider}/{config.model_id} ({ml})")
+                continue
+
+            if _cmd_is(user_input, "/budget"):
+                parts = user_input.strip().split(maxsplit=1)
+                if len(parts) > 1:
+                    try:
+                        config.budget_usd = float(parts[1]); engine.budget_usd = config.budget_usd
+                        ui.success(f"Budget: ${config.budget_usd:.2f}")
+                    except ValueError:
+                        ui.error("Usage: /budget 20.0")
+                else:
+                    spent = session_mgr.current.total_cost_usd if session_mgr.current else 0
+                    lim = f"/ ${config.budget_usd:.2f}" if config.budget_usd > 0 else "(no limit)"
+                    ui.info(f"Spent: ${spent:.4f} {lim}")
+                continue
+
+            if _cmd_is(user_input, "/config"):
+                parts = user_input.strip().split(maxsplit=2)
+                subcmd = parts[1].lower() if len(parts) > 1 else "show"
+
+                if subcmd == "show" or subcmd == "list":
+                    # Show current configuration
+                    print(f"\n{P.HEADER}── CONFIGURATION ─{P.R}")
+                    print(f"  Provider:      {config.provider}")
+                    print(f"  Model:         {config.model_id}")
+                    print(f"  Max Tokens:    {config.max_tokens}")
+                    print(f"  Context:       {config.context_window:,} tokens")
+                    print(f"  Permission:    {config.permission_mode}")
+                    print(f"  Budget:        ${config.budget_usd:.2f}")
+                    print(f"  Root Dir:      {config.root_dir}")
+                    print(f"  Ollama URL:    {config.ollama_url}")
+                    print(f"  Auto-save:     {config.auto_save_session}")
+                    print(f"  Verbose:       {config.verbose}")
+                    print(f"  Show Cost:     {config.show_cost}")
+                    print()
+
+                elif subcmd == "export":
+                    # Export configuration to global config file
+                    from hanus.config import CONFIG_DIR, GLOBAL_CONFIG
+                    try:
+                        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+                        config_yaml = f"""# ═══════════════════════════════════════════════════════════════════════════════
+# HANUSCODE CONFIGURATION
+# Generated: {datetime.now().isoformat()}
+# ═══════════════════════════════════════════════════════════════════════════════
+
+# AI Model
+provider: {config.provider}
+model_id: {config.model_id}
+max_tokens: {config.max_tokens}
+context_window: {config.context_window}
+
+# API Keys (set via environment variables for security)
+# anthropic_api_key: ""
+# openai_api_key: ""
+# gemini_api_key: ""
+# glm_api_key: ""
+ollama_url: "{config.ollama_url}"
+
+# Permissions
+permission_mode: {config.permission_mode}
+max_tool_calls: {config.max_tool_calls}
+
+# Context
+context_max_files: {config.context_max_files}
+context_include_content: {str(config.context_include_content).lower()}
+context_preview_chars: {config.context_preview_chars}
+max_file_read_chars: {config.max_file_read_chars}
+context_compress_threshold: {config.context_compress_threshold}
+
+# Execution
+shell_timeout: {config.shell_timeout}
+python_exec_timeout: {config.python_exec_timeout}
+
+# Budget
+budget_usd: {config.budget_usd}
+budget_warn_pct: {config.budget_warn_pct}
+
+# Sessions
+auto_save_session: {str(config.auto_save_session).lower()}
+
+# UI
+show_cost: {str(config.show_cost).lower()}
+verbose: {str(config.verbose).lower()}
+"""
+                        GLOBAL_CONFIG.write_text(config_yaml, encoding="utf-8")
+                        ui.success(f"Configuration exported to: {GLOBAL_CONFIG}")
+                    except Exception as e:
+                        ui.error(f"Failed to export config: {e}")
+
+                elif subcmd == "set":
+                    if len(parts) < 3:
+                        ui.info("Usage: /config set <key> <value>")
+                        ui.info("Keys: provider, model_id, permission_mode, budget_usd, max_tokens, ollama_url")
+                        continue
+                    key_val = parts[2].split(maxsplit=1)
+                    if len(key_val) < 2:
+                        ui.error("Usage: /config set <key> <value>")
+                        continue
+                    key, value = key_val[0].lower(), key_val[1]
+                    # Apply config change
+                    if hasattr(config, key):
+                        try:
+                            cur = getattr(config, key)
+                            if isinstance(cur, bool):
+                                setattr(config, key, value.lower() in ("true", "1", "yes"))
+                            elif isinstance(cur, int):
+                                setattr(config, key, int(value))
+                            elif isinstance(cur, float):
+                                setattr(config, key, float(value))
+                            else:
+                                setattr(config, key, value)
+                            ui.success(f"Set {key} = {getattr(config, key)}")
+                            # Special handling for provider/model
+                            if key == "provider":
+                                connector = _make_connector(config, ui)
+                                engine.connector = connector
+                        except Exception as e:
+                            ui.error(f"Failed to set {key}: {e}")
+                    else:
+                        ui.error(f"Unknown config key: {key}")
+
+                elif subcmd == "reset":
+                    # Reset to defaults
+                    config.permission_mode = "bypass"
+                    config.budget_usd = 0.0
+                    config.max_tokens = 8096
+                    config.context_window = 200000
+                    config.show_cost = True
+                    config.verbose = False
+                    ui.success("Configuration reset to defaults")
+
+                elif subcmd == "path":
+                    from hanus.config import CONFIG_DIR, GLOBAL_CONFIG
+                    print(f"\n{P.HEADER}── CONFIG PATHS ─{P.R}")
+                    print(f"  Global config: {GLOBAL_CONFIG}")
+                    print(f"  Config dir:    {CONFIG_DIR}")
+                    print(f"  Exists:        {GLOBAL_CONFIG.exists()}")
+                    print()
+
+                else:
+                    ui.info("Usage: /config [show|export|set|reset|path]")
+                continue
+
+            if _cmd_exact(user_input, "/audit"):
+                ui.show_audit(perms.get_audit()); continue
+
+            if _cmd_exact(user_input, "/stats"):
+                ui.show_stats(session_mgr.current); continue
+
+            if _cmd_exact(user_input, "/save"):
+                _autosave(config, session_mgr, engine, ui, force=True); continue
+
+            if _cmd_is(user_input, "/tasks"):
+                parts = user_input.strip().split(maxsplit=1)
+                subcmd = parts[1].lower() if len(parts) > 1 else "list"
+
+                if subcmd == "list" or subcmd == "status":
+                    tasks = task_mgr.list_tasks()
+                    if not tasks:
+                        ui.info("No pending tasks.")
+                    else:
+                        print(f"\n{P.HEADER}── TASKS ─{P.R}")
+                        for t in tasks:
+                            status_icon = {"pending": "⏳", "in_progress": "🔄", "completed": "✅", "failed": "❌"}.get(t.status.value, "•")
+                            print(f"  {status_icon} [{t.id}] {t.subject}")
+                            if t.description:
+                                print(f"      {P.MUTED}{t.description[:60]}{'...' if len(t.description) > 60 else ''}{P.R}")
+                        print()
+                elif subcmd == "clear":
+                    for t in task_mgr.list_tasks():
+                        if t.status.value in ("completed", "failed"):
+                            task_mgr.delete_task(t.id)
+                    ui.success("Completed tasks cleared.")
+                else:
+                    ui.info("Commands: /tasks list | /tasks clear")
+                continue
+
+            if _cmd_is(user_input, "/logs"):
+                _show_logs(ui); continue
+
+            if _cmd_is(user_input, "/plugin"):
+                parts  = user_input.strip().split(maxsplit=2)
+                name   = parts[1] if len(parts) > 1 else ""
+                args   = parts[2] if len(parts) > 2 else ""
+                result = plugin_mgr.run(name, args)
+                if result:
+                    ui.plugin_result(name, result)
+                    engine._messages.append({"role": "user", "content": f"[Plugin {name}]\n{result}"})
+                continue
+
+            # ── /skill — gestión de skills ─────────────────────────────────────────
+            if _cmd_is(user_input, "/skill"):
+                parts = user_input.strip().split(maxsplit=2)
+                subcmd = parts[1].lower() if len(parts) > 1 else "list"
+
+                if subcmd == "list":
+                    skills = skill_mgr.list_skills()
+                    if not skills:
+                        ui.info("No skills installed. Install with: /skill install <url>")
+                    else:
+                        print(f"\n{P.HEADER}── SKILLS ─{P.R}")
+                        for s in sorted(skills, key=lambda x: x.name):
+                            icon = "📝" if s.skill_type.value == "markdown" else "🐍"
+                            builtin = "builtin" if s.is_builtin else "user"
+                            print(f"  {icon} /{s.name:<15} {s.description[:40]:<40} [{builtin}]")
+                        print()
+
+                elif subcmd == "install":
+                    if len(parts) < 3:
+                        ui.error("Usage: /skill install <url>")
+                        ui.info("Supports: .py, .md files, GitHub Gists")
+                    else:
+                        url = parts[2]
+                        if "gist.github.com" in url:
+                            result = skill_mgr.install_from_gist(url)
+                        else:
+                            result = skill_mgr.install(url)
+                        ui.info(result)
+
+                elif subcmd == "create":
+                    # /skill create <name> <description>
+                    if len(parts) < 3:
+                        ui.error("Usage: /skill create <name> <description>")
+                    else:
+                        create_parts = parts[2].split(maxsplit=1)
+                        name = create_parts[0]
+                        desc = create_parts[1] if len(create_parts) > 1 else name
+                        result = skill_mgr.create_markdown(name, desc)
+                        ui.info(result)
+
+                elif subcmd == "remove" or subcmd == "delete":
+                    if len(parts) < 3:
+                        ui.error("Usage: /skill remove <name>")
+                    else:
+                        result = skill_mgr.remove(parts[2])
+                        ui.info(result)
+
+                elif subcmd == "reload":
+                    skill_mgr.reload()
+                    ui.success(f"Skills reloaded: {len(skill_mgr.list_skills())} available")
+
+                elif subcmd == "info":
+                    if len(parts) < 3:
+                        ui.error("Usage: /skill info <name>")
+                    else:
+                        skill = skill_mgr.get(parts[2])
+                        if skill:
+                            print(skill.get_doc())
+                        else:
+                            ui.error(f"Skill '{parts[2]}' not found")
+
+                else:
+                    # Try to execute skill: /skill <name> [args]
+                    skill_name = subcmd
+                    skill_args = parts[2] if len(parts) > 2 else ""
+                    skill = skill_mgr.get(skill_name)
+
+                    if skill:
+                        result = skill.run(skill_args)
+                        print(result)
+                        # For markdown skills, inject into conversation
+                        if skill.skill_type.value == "markdown":
+                            engine._messages.append({"role": "user", "content": result})
+                    else:
+                        ui.error(f"Skill '{skill_name}' not found")
+                        ui.info("Commands: list, install, create, remove, info, reload")
+                continue
+
+            # ── /monitor — background process monitoring ───────────────────────────
+            if _cmd_is(user_input, "/monitor"):
+                parts = user_input.strip().split(maxsplit=2)
+                subcmd = parts[1].lower() if len(parts) > 1 else "list"
+
+                if subcmd == "list":
+                    monitors = monitor_mgr.list()
+                    if not monitors:
+                        ui.info("No monitors running. Start with: /monitor start <command>")
+                    else:
+                        print(f"\n{P.HEADER}── MONITORS ─{P.R}")
+                        for m in monitors:
+                            print(monitor_mgr.format_status(m))
+                        print()
+
+                elif subcmd == "start":
+                    if len(parts) < 3:
+                        ui.error("Usage: /monitor start <command>")
+                        ui.info("Example: /monitor start 'npm run build'")
+                    else:
+                        command = parts[2]
+                        name = command.split()[0] if command else "task"
+
+                        def on_event(evt):
+                            # Callback for events
+                            if evt.event_type == "line":
+                                print(f"  [{name}] {evt.content}")
+                            elif evt.event_type == "complete":
+                                print(f"\n✓ Monitor completed: {name}")
+                            elif evt.event_type == "error":
+                                print(f"\n✗ Monitor failed: {name} - {evt.content}")
+
+                        monitor_id = monitor_mgr.start(name, command, on_event=on_event, cwd=config.root_dir)
+                        ui.success(f"Monitor started: {monitor_id}")
+                        ui.info("Check progress with: /monitor list")
+
+                elif subcmd == "stop":
+                    if len(parts) < 3:
+                        ui.error("Usage: /monitor stop <id>")
+                    else:
+                        result = monitor_mgr.stop(parts[2])
+                        ui.info(result)
+
+                elif subcmd == "events":
+                    if len(parts) < 3:
+                        ui.error("Usage: /monitor events <id>")
+                    else:
+                        events = monitor_mgr.get_events(parts[2])
+                        for evt in events:
+                            print(f"  [{evt.event_type}] {evt.content}")
+
+                elif subcmd == "wait":
+                    if len(parts) < 3:
+                        ui.error("Usage: /monitor wait <id>")
+                    else:
+                        ui.info(f"Waiting for {parts[2]} to complete...")
+                        task = monitor_mgr.wait(parts[2])
+                        if task:
+                            print(monitor_mgr.format_status(task))
+
+                else:
+                    ui.info("Commands: list, start, stop, events, wait")
+                continue
+
+            # ── Invoke skill or plugin directly: /name [args] ──────────────────────
+            if user_input.startswith("/") and len(user_input) > 1:
+                first_space = user_input.find(" ")
+                if first_space > 0:
+                    potential_name = user_input[1:first_space].lower()
+                    cmd_args = user_input[first_space:].strip()
+                else:
+                    potential_name = user_input[1:].lower()
+                    cmd_args = ""
+
+                # First check if it's a plugin
+                if potential_name in plugin_mgr.plugins:
+                    result = plugin_mgr.run(potential_name, cmd_args)
+                    if result:
+                        ui.plugin_result(potential_name, result)
+                    continue
+
+                # Then check if it's a skill
+                skill = skill_mgr.get(potential_name)
+                if skill:
+                    result = skill.run(cmd_args)
+                    print(result)
+                    # For markdown skills, inject into conversation
+                    if skill.skill_type.value == "markdown":
+                        engine._messages.append({"role": "user", "content": result})
+                    continue
+
+            # ── Agent query ────────────────────────────────────────────
+            try:
+                # Start background input collection (allows typing while agent works)
+                tp = get_prompt()
+                tp.start_background_input()
+
+                response = engine.send(user_input)
+
+                # Stop background input and collect any typed text
+                background_input = tp.stop_background_input()
+
+                # If agent finished but there's pending input, ask user what to do
+                if background_input and response.stop_reason in ("done", "finished", "max_iterations"):
+                    ui.info(f"Agent finished, but you typed: '{background_input[:50]}...'")
+                    try:
+                        choice = input("  Send this as new message? [Y/n]: ").strip().lower()
+                    except (EOFError, KeyboardInterrupt):
+                        choice = "n"
+
+                    if choice in ("", "y", "yes"):
+                        # Send as new message
+                        engine.set_pending_input(background_input)
+                        user_input = background_input
+                        # Re-run with the new input
+                        response = engine.send(user_input)
+                    else:
+                        ui.info("Pending input cancelled.")
+                        background_input = ""
+
+                elif background_input:
+                    # Agent didn't finish, store input for next iteration
+                    engine.set_pending_input(background_input)
+
+            except KeyboardInterrupt:
+                engine.interrupt()
+                ui.warning("Model interrupted. You can continue typing.")
+                log.info("Interrupted by Ctrl+C")
+                # Stop background input on interrupt
+                tp = get_prompt()
+                tp.stop_background_input()
+                continue
+
+            if response.stop_reason == "interrupted":
+                ui.warning("Response interrupted.")
+            else:
+                _show_response(response, ui)
+
+            # Send response back to Chrome extension if input came from there
+            if _chrome_input and response.text:
+                try:
+                    from hanus.plugins.chrome import send_chat_response
+                    # Send response to Chrome
+                    response_text = response.text[:4000]  # Limit message size
+                    if send_chat_response(response_text):
+                        print(f"{P.CYAN}📱 [Chrome] Respuesta enviada a la extensión{P.R}")
+                    else:
+                        print(f"{P.YELLOW}📱 [Chrome] No se pudo enviar la respuesta (extensión no conectada){P.R}")
+                except Exception as e:
+                    log.info(f"[Chrome] Response error: {e}")
+
+            # Send response back to Telegram if input came from there
+            if _telegram_input and response.text and _telegram_chat_id:
+                try:
+                    from hanus.plugins.telegram import send_response
+                    # Send response to Telegram
+                    response_text = response.text[:4000]  # Limit message size
+                    send_response(_telegram_chat_id, response_text)
+                    print(f"{P.CYAN}📱 [Telegram] Response sent to chat {P.R}")
+                except Exception as e:
+                    log.info(f"[Telegram] Response error: {e}")
+
+            if config.show_cost and session_mgr.current:
+                ui.show_cost_bar(
+                    response.cost_usd, response.input_tokens, response.output_tokens,
+                    session_mgr.current.total_cost_usd, config.budget_usd,
+                )
+            if config.auto_save_session:
+                _autosave(config, session_mgr, engine, ui)
+            if config.budget_usd > 0 and session_mgr.current:
+                spent = session_mgr.current.total_cost_usd
+                if spent >= config.budget_usd * config.budget_warn_pct:
+                    ui.warning(f"Budget at {spent/config.budget_usd*100:.0f}%  "
+                               f"(${spent:.4f}/${config.budget_usd:.2f})")
+
+        except KeyboardInterrupt:
+            print()
+            ui.warning("Ctrl+C — type 'exit' to quit or Enter to continue.")
+            continue
+
+        except Exception as e:
+            import traceback
+            ui.error(f"{type(e).__name__}: {e}")
+            log.log_error("main loop", e)
+            if config.verbose:
+                print(traceback.format_exc())
+            try:
+                ans = input("  Continue? [Y/n] ").strip().lower()
+            except Exception:
+                ans = "n"
+            if ans.startswith("n"):
+                break
+
+
+def _show_logs(ui):
+    import time as _t
+    log_dir  = Path.home() / ".hanus" / "logs"
+    log_file = log_dir / f"hanus_{_t.strftime('%Y%m%d')}.log"
+    if not log_file.exists():
+        ui.info("No logs today.")
+        return
+    lines = log_file.read_text(encoding="utf-8", errors="replace").splitlines()[-40:]
+    print()
+    for line in lines:
+        print(f"  {line}")
+    print()
+
+
+if __name__ == "__main__":
+    # If executed directly, use CLI arguments
+    import argparse
+    parser = argparse.ArgumentParser(
+        prog="hanuscode",
+        description="Autonomous Programming Agent"
+    )
+    parser.add_argument("--cmd", "-c", default=None, help="Command to execute")
+    parser.add_argument("--path", "-p", default=None, help="Working directory")
+    parser.add_argument("--profile", default=None, help="Profile to use")
+    parser.add_argument("--model", default=None, help="Model: provider/model")
+    parser.add_argument("--mode", default=None, choices=["default", "plan", "bypass"])
+    args = parser.parse_args()
+
+    if args.path:
+        import os
+        os.chdir(Path(args.path).expanduser().resolve())
+
+    run_with_args(
+        cmd=args.cmd,
+        profile=args.profile,
+        model=args.model,
+        mode=args.mode
+    )