devduck 0.1.0__py3-none-any.whl → 0.1.1766644714__py3-none-any.whl

devduck/__init__.py

@@ -3,242 +3,372 @@
 🦆 devduck - extreme minimalist self-adapting agent
 one file. self-healing. runtime dependencies. adaptive.
 """
+import os
 import sys
 import subprocess
-import os
+import threading
 import platform
 import socket
+import logging
+import tempfile
+import time
+import warnings
+import json
 from pathlib import Path
 from datetime import datetime
 from typing import Dict, Any
+from logging.handlers import RotatingFileHandler
+from strands import Agent, tool
 
-os.environ["BYPASS_TOOL_CONSENT"] = "true"
-os.environ["STRANDS_TOOL_CONSOLE_MODE"] = "enabled"
+# Import system prompt helper for loading prompts from files
+try:
+    from devduck.tools.system_prompt import _get_system_prompt
+except ImportError:
+    # Fallback if tools module not available yet
+    def _get_system_prompt(repository=None, variable_name="SYSTEM_PROMPT"):
+        return os.getenv(variable_name, "")
 
 
-# 🔧 Self-healing dependency installer
-def ensure_deps():
-    """Install dependencies at runtime if missing"""
-    deps = ["strands-agents", "strands-agents[ollama]", "strands-agents[openai]", "strands-agents[anthropic]", "strands-agents-tools"]
+warnings.filterwarnings("ignore", message=".*pkg_resources is deprecated.*")
+warnings.filterwarnings("ignore", message=".*cache_prompt is deprecated.*")
 
-    for dep in deps:
-        try:
-            if "strands" in dep:
-                import strands
+os.environ["BYPASS_TOOL_CONSENT"] = os.getenv("BYPASS_TOOL_CONSENT", "true")
+os.environ["STRANDS_TOOL_CONSOLE_MODE"] = "enabled"
+os.environ["EDITOR_DISABLE_BACKUP"] = "true"
 
-                break
-        except ImportError:
-            print(f"🦆 Installing {dep}...")
-            subprocess.check_call(
-                [sys.executable, "-m", "pip", "install", dep],
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
-            )
+LOG_DIR = Path(tempfile.gettempdir()) / "devduck" / "logs"
+LOG_DIR.mkdir(parents=True, exist_ok=True)
 
+LOG_FILE = LOG_DIR / "devduck.log"
+logger = logging.getLogger("devduck")
+logger.setLevel(logging.DEBUG)
 
-# 🌍 Environment adaptation
-def adapt_to_env():
-    """Self-adapt based on environment"""
-    env_info = {
-        "os": platform.system(),
-        "arch": platform.machine(),
-        "python": sys.version_info,
-        "cwd": str(Path.cwd()),
-        "home": str(Path.home()),
-        "shell": os.environ.get("SHELL", "unknown"),
-        "hostname": socket.gethostname(),
-    }
+file_handler = RotatingFileHandler(
+    LOG_FILE, maxBytes=10 * 1024 * 1024, backupCount=3, encoding="utf-8"
+)
+file_handler.setLevel(logging.DEBUG)
+file_formatter = logging.Formatter(
+    "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+file_handler.setFormatter(file_formatter)
 
-    # Adaptive configurations - using common models
-    if env_info["os"] == "Darwin":  # macOS
-        ollama_host = "http://localhost:11434"
-        model = "qwen3:1.7b"  # Lightweight for macOS
-    elif env_info["os"] == "Linux":
-        ollama_host = "http://localhost:11434"
-        model = "qwen3:30b"  # More power on Linux
-    else:  # Windows
-        ollama_host = "http://localhost:11434"
-        model = "qwen3:8b"  # Conservative for Windows
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.WARNING)
+console_formatter = logging.Formatter("🦆 %(levelname)s: %(message)s")
+console_handler.setFormatter(console_formatter)
 
-    return env_info, ollama_host, model
+logger.addHandler(file_handler)
+logger.addHandler(console_handler)
 
+logger.info("DevDuck logging system initialized")
 
-# 🔍 Self-awareness: Read own source code
-def get_own_source_code():
-    """
-    Read and return the source code of this agent file.
 
-    Returns:
-        str: The complete source code for self-awareness
-    """
+def get_own_source_code():
+    """Read own source code for self-awareness"""
     try:
-        # Read this file (__init__.py)
-        current_file = __file__
-        with open(current_file, "r", encoding="utf-8") as f:
-            init_code = f.read()
-            return f"# devduck/__init__.py\n```python\n{init_code}\n```"
+        with open(__file__, "r", encoding="utf-8") as f:
+            return f"# Source path: {__file__}\n\ndevduck/__init__.py\n```python\n{f.read()}\n```"
     except Exception as e:
-        return f"Error reading own source code: {e}"
+        return f"Error reading source: {e}"
 
 
-# 🛠️ System prompt tool (with .prompt file persistence)
-def system_prompt_tool(
-    action: str,
-    prompt: str | None = None,
-    context: str | None = None,
-    variable_name: str = "SYSTEM_PROMPT",
+def view_logs_tool(
+    action: str = "view",
+    lines: int = 100,
+    pattern: str = None,
 ) -> Dict[str, Any]:
     """
-    Manage the agent's system prompt dynamically with file persistence.
+    View and manage DevDuck logs.
 
     Args:
-        action: "view", "update", "add_context", or "reset"
-        prompt: New system prompt text (required for "update")
-        context: Additional context to prepend (for "add_context")
-        variable_name: Environment variable name (default: SYSTEM_PROMPT)
+        action: Action to perform - "view", "tail", "search", "clear", "stats"
+        lines: Number of lines to show (for view/tail)
+        pattern: Search pattern (for search action)
 
     Returns:
         Dict with status and content
     """
-    from pathlib import Path
-    import tempfile
-
-    def _get_prompt_file_path() -> Path:
-        """Get the .prompt file path in temp directory."""
-        temp_dir = Path(tempfile.gettempdir()) / ".devduck"
-        temp_dir.mkdir(exist_ok=True, mode=0o700)  # Create with restrictive permissions
-        return temp_dir / ".prompt"
-
-    def _write_prompt_file(prompt_text: str) -> None:
-        """Write prompt to .prompt file in temp directory."""
-        prompt_file = _get_prompt_file_path()
-        try:
-            # Create file with restrictive permissions
-            with open(
-                prompt_file,
-                "w",
-                encoding="utf-8",
-                opener=lambda path, flags: os.open(path, flags, 0o600),
-            ) as f:
-                f.write(prompt_text)
-        except (OSError, PermissionError):
-            try:
-                prompt_file.write_text(prompt_text, encoding="utf-8")
-                prompt_file.chmod(0o600)
-            except (OSError, PermissionError):
-                prompt_file.write_text(prompt_text, encoding="utf-8")
-
-    def _get_system_prompt(var_name: str) -> str:
-        """Get current system prompt from environment variable."""
-        return os.environ.get(var_name, "")
-
-    def _update_system_prompt(new_prompt: str, var_name: str) -> None:
-        """Update system prompt in both environment and .prompt file."""
-        os.environ[var_name] = new_prompt
-        if var_name == "SYSTEM_PROMPT":
-            _write_prompt_file(new_prompt)
-
     try:
         if action == "view":
-            current = _get_system_prompt(variable_name)
+            if not LOG_FILE.exists():
+                return {"status": "success", "content": [{"text": "No logs yet"}]}
+
+            with open(LOG_FILE, "r", encoding="utf-8") as f:
+                all_lines = f.readlines()
+                recent_lines = (
+                    all_lines[-lines:] if len(all_lines) > lines else all_lines
+                )
+                content = "".join(recent_lines)
+
             return {
                 "status": "success",
                 "content": [
-                    {"text": f"Current system prompt from {variable_name}:{current}"}
+                    {"text": f"Last {len(recent_lines)} log lines:\n\n{content}"}
                 ],
             }
 
-        elif action == "update":
-            if not prompt:
+        elif action == "tail":
+            if not LOG_FILE.exists():
+                return {"status": "success", "content": [{"text": "No logs yet"}]}
+
+            with open(LOG_FILE, "r", encoding="utf-8") as f:
+                all_lines = f.readlines()
+                tail_lines = all_lines[-50:] if len(all_lines) > 50 else all_lines
+                content = "".join(tail_lines)
+
+            return {
+                "status": "success",
+                "content": [{"text": f"Tail (last 50 lines):\n\n{content}"}],
+            }
+
+        elif action == "search":
+            if not pattern:
                 return {
                     "status": "error",
-                    "content": [
-                        {"text": "Error: prompt parameter required for update action"}
-                    ],
+                    "content": [{"text": "pattern parameter required for search"}],
                 }
 
-            _update_system_prompt(prompt, variable_name)
+            if not LOG_FILE.exists():
+                return {"status": "success", "content": [{"text": "No logs yet"}]}
 
-            if variable_name == "SYSTEM_PROMPT":
-                message = f"System prompt updated (env: {variable_name}, file: .prompt)"
-            else:
-                message = f"System prompt updated (env: {variable_name})"
+            with open(LOG_FILE, "r", encoding="utf-8") as f:
+                matching_lines = [line for line in f if pattern.lower() in line.lower()]
+
+            if not matching_lines:
+                return {
+                    "status": "success",
+                    "content": [{"text": f"No matches found for pattern: {pattern}"}],
+                }
+
+            content = "".join(matching_lines[-100:])  # Last 100 matches
+            return {
+                "status": "success",
+                "content": [
+                    {
+                        "text": f"Found {len(matching_lines)} matches (showing last 100):\n\n{content}"
+                    }
+                ],
+            }
+
+        elif action == "clear":
+            if LOG_FILE.exists():
+                LOG_FILE.unlink()
+                logger.info("Log file cleared by user")
+            return {
+                "status": "success",
+                "content": [{"text": "Logs cleared successfully"}],
+            }
+
+        elif action == "stats":
+            if not LOG_FILE.exists():
+                return {"status": "success", "content": [{"text": "No logs yet"}]}
+
+            stat = LOG_FILE.stat()
+            size_mb = stat.st_size / (1024 * 1024)
+            modified = datetime.fromtimestamp(stat.st_mtime).strftime(
+                "%Y-%m-%d %H:%M:%S"
+            )
+
+            with open(LOG_FILE, "r", encoding="utf-8") as f:
+                total_lines = sum(1 for _ in f)
+
+            stats_text = f"""Log File Statistics:
+Path: {LOG_FILE}
+Size: {size_mb:.2f} MB
+Lines: {total_lines}
+Last Modified: {modified}"""
+
+            return {"status": "success", "content": [{"text": stats_text}]}
+
+        else:
+            return {
+                "status": "error",
+                "content": [
+                    {
+                        "text": f"Unknown action: {action}. Valid: view, tail, search, clear, stats"
+                    }
+                ],
+            }
+
+    except Exception as e:
+        logger.error(f"Error in view_logs_tool: {e}")
+        return {"status": "error", "content": [{"text": f"Error: {str(e)}"}]}
 
-            return {"status": "success", "content": [{"text": message}]}
 
-        elif action == "add_context":
-            if not context:
+def manage_tools_func(
+    action: str,
+    package: str = None,
+    tool_names: str = None,
+    tool_path: str = None,
+) -> Dict[str, Any]:
+    """Manage the agent's tool set at runtime - add, remove, list, reload tools on the fly."""
+    try:
+        if not hasattr(devduck, "agent") or not devduck.agent:
+            return {"status": "error", "content": [{"text": "Agent not initialized"}]}
+
+        registry = devduck.agent.tool_registry
+
+        if action == "list":
+            # List tools from registry
+            tool_list = list(registry.registry.keys())
+            dynamic_tools = list(registry.dynamic_tools.keys())
+
+            text = f"Currently loaded {len(tool_list)} tools:\n"
+            text += "\n".join(f"  • {t}" for t in sorted(tool_list))
+            if dynamic_tools:
+                text += f"\n\nDynamic tools ({len(dynamic_tools)}):\n"
+                text += "\n".join(f"  • {t}" for t in sorted(dynamic_tools))
+
+            return {"status": "success", "content": [{"text": text}]}
+
+        elif action == "add":
+            if not package and not tool_path:
                 return {
                     "status": "error",
                     "content": [
                         {
-                            "text": "Error: context parameter required for add_context action"
+                            "text": "Either 'package' or 'tool_path' required for add action"
                         }
                     ],
                 }
 
-            current = _get_system_prompt(variable_name)
-            new_prompt = f"{current} {context}" if current else context
-            _update_system_prompt(new_prompt, variable_name)
+            added_tools = []
 
-            if variable_name == "SYSTEM_PROMPT":
-                message = f"Context added to system prompt (env: {variable_name}, file: .prompt)"
-            else:
-                message = f"Context added to system prompt (env: {variable_name})"
+            # Add from package using process_tools
+            if package:
+                if not tool_names:
+                    return {
+                        "status": "error",
+                        "content": [
+                            {"text": "'tool_names' required when adding from package"}
+                        ],
+                    }
 
-            return {"status": "success", "content": [{"text": message}]}
+                tools_to_add = [t.strip() for t in tool_names.split(",")]
 
-        elif action == "reset":
-            os.environ.pop(variable_name, None)
+                # Build tool specs: package.tool_name format
+                tool_specs = [f"{package}.{tool_name}" for tool_name in tools_to_add]
 
-            if variable_name == "SYSTEM_PROMPT":
-                prompt_file = _get_prompt_file_path()
-                if prompt_file.exists():
-                    try:
-                        prompt_file.unlink()
-                    except (OSError, PermissionError):
-                        pass
-                message = (
-                    f"System prompt reset (env: {variable_name}, file: .prompt cleared)"
-                )
+                try:
+                    added_tool_names = registry.process_tools(tool_specs)
+                    added_tools.extend(added_tool_names)
+                    logger.info(f"Added tools from {package}: {added_tool_names}")
+                except Exception as e:
+                    logger.error(f"Failed to add tools from {package}: {e}")
+                    return {
+                        "status": "error",
+                        "content": [{"text": f"Failed to add tools: {str(e)}"}],
+                    }
+
+            # Add from file path using process_tools
+            if tool_path:
+                try:
+                    added_tool_names = registry.process_tools([tool_path])
+                    added_tools.extend(added_tool_names)
+                    logger.info(f"Added tools from file: {added_tool_names}")
+                except Exception as e:
+                    logger.error(f"Failed to add tool from {tool_path}: {e}")
+                    return {
+                        "status": "error",
+                        "content": [{"text": f"Failed to add tool: {str(e)}"}],
+                    }
+
+            if added_tools:
+                return {
+                    "status": "success",
+                    "content": [
+                        {
+                            "text": f"✅ Added {len(added_tools)} tools: {', '.join(added_tools)}\n"
+                            + f"Total tools: {len(registry.registry)}"
+                        }
+                    ],
+                }
             else:
-                message = f"System prompt reset (env: {variable_name})"
+                return {"status": "error", "content": [{"text": "No tools were added"}]}
 
-            return {"status": "success", "content": [{"text": message}]}
+        elif action == "remove":
+            if not tool_names:
+                return {
+                    "status": "error",
+                    "content": [{"text": "'tool_names' required for remove action"}],
+                }
 
-        elif action == "get":
-            # Backward compatibility
-            current = _get_system_prompt(variable_name)
-            return {
-                "status": "success",
-                "content": [{"text": f"System prompt: {current}"}],
-            }
+            tools_to_remove = [t.strip() for t in tool_names.split(",")]
+            removed_tools = []
 
-        elif action == "set":
-            # Backward compatibility
-            if prompt is None:
-                return {"status": "error", "content": [{"text": "No prompt provided"}]}
+            # Remove from registry
+            for tool_name in tools_to_remove:
+                if tool_name in registry.registry:
+                    del registry.registry[tool_name]
+                    removed_tools.append(tool_name)
+                    logger.info(f"Removed tool: {tool_name}")
 
-            if context:
-                prompt = f"{context} {prompt}"
+                if tool_name in registry.dynamic_tools:
+                    del registry.dynamic_tools[tool_name]
+                    logger.info(f"Removed dynamic tool: {tool_name}")
 
-            _update_system_prompt(prompt, variable_name)
-            return {
-                "status": "success",
-                "content": [{"text": "System prompt updated successfully"}],
-            }
+            if removed_tools:
+                return {
+                    "status": "success",
+                    "content": [
+                        {
+                            "text": f"✅ Removed {len(removed_tools)} tools: {', '.join(removed_tools)}\n"
+                            + f"Total tools: {len(registry.registry)}"
+                        }
+                    ],
+                }
+            else:
+                return {
+                    "status": "success",
+                    "content": [{"text": "No tools were removed (not found)"}],
+                }
+
+        elif action == "reload":
+            if tool_names:
+                # Reload specific tools
+                tools_to_reload = [t.strip() for t in tool_names.split(",")]
+                reloaded_tools = []
+                failed_tools = []
+
+                for tool_name in tools_to_reload:
+                    try:
+                        registry.reload_tool(tool_name)
+                        reloaded_tools.append(tool_name)
+                        logger.info(f"Reloaded tool: {tool_name}")
+                    except Exception as e:
+                        failed_tools.append((tool_name, str(e)))
+                        logger.error(f"Failed to reload {tool_name}: {e}")
+
+                text = ""
+                if reloaded_tools:
+                    text += f"✅ Reloaded {len(reloaded_tools)} tools: {', '.join(reloaded_tools)}\n"
+                if failed_tools:
+                    text += f"❌ Failed to reload {len(failed_tools)} tools:\n"
+                    for tool_name, error in failed_tools:
+                        text += f"  • {tool_name}: {error}\n"
+
+                return {"status": "success", "content": [{"text": text}]}
+            else:
+                # Reload all tools - restart agent
+                logger.info("Reloading all tools via restart")
+                devduck.restart()
+                return {
+                    "status": "success",
+                    "content": [{"text": "✅ All tools reloaded - agent restarted"}],
+                }
 
         else:
             return {
                 "status": "error",
                 "content": [
                     {
-                        "text": f"Unknown action '{action}'. Valid: view, update, add_context, reset"
+                        "text": f"Unknown action: {action}. Valid: list, add, remove, reload"
                     }
                 ],
             }
 
     except Exception as e:
+        logger.error(f"Error in manage_tools: {e}")
         return {"status": "error", "content": [{"text": f"Error: {str(e)}"}]}
 
 
@@ -253,22 +383,22 @@ def get_shell_history_file():
 def get_shell_history_files():
     """Get available shell history file paths."""
     history_files = []
-    
+
     # devduck history (primary)
     devduck_history = Path(get_shell_history_file())
     if devduck_history.exists():
         history_files.append(("devduck", str(devduck_history)))
-    
+
     # Bash history
     bash_history = Path.home() / ".bash_history"
     if bash_history.exists():
         history_files.append(("bash", str(bash_history)))
-    
+
     # Zsh history
     zsh_history = Path.home() / ".zsh_history"
     if zsh_history.exists():
         history_files.append(("zsh", str(zsh_history)))
-    
+
     return history_files
 
 
@@ -277,14 +407,16 @@ def parse_history_line(line, history_type):
     line = line.strip()
     if not line:
         return None
-    
+
     if history_type == "devduck":
         # devduck format: ": timestamp:0;# devduck: query" or ": timestamp:0;# devduck_result: result"
         if "# devduck:" in line:
             try:
                 timestamp_str = line.split(":")[1]
                 timestamp = int(timestamp_str)
-                readable_time = datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S")
+                readable_time = datetime.fromtimestamp(timestamp).strftime(
+                    "%Y-%m-%d %H:%M:%S"
+                )
                 query = line.split("# devduck:")[-1].strip()
                 return ("you", readable_time, query)
             except (ValueError, IndexError):
@@ -293,12 +425,14 @@ def parse_history_line(line, history_type):
             try:
                 timestamp_str = line.split(":")[1]
                 timestamp = int(timestamp_str)
-                readable_time = datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S")
+                readable_time = datetime.fromtimestamp(timestamp).strftime(
+                    "%Y-%m-%d %H:%M:%S"
+                )
                 result = line.split("# devduck_result:")[-1].strip()
                 return ("me", readable_time, result)
             except (ValueError, IndexError):
                 return None
-    
+
     elif history_type == "zsh":
         if line.startswith(": ") and ":0;" in line:
             try:
@@ -306,37 +440,65 @@ def parse_history_line(line, history_type):
                 if len(parts) == 2:
                     timestamp_str = parts[0].split(":")[1]
                     timestamp = int(timestamp_str)
-                    readable_time = datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S")
+                    readable_time = datetime.fromtimestamp(timestamp).strftime(
+                        "%Y-%m-%d %H:%M:%S"
+                    )
                     command = parts[1].strip()
                     if not command.startswith("devduck "):
                         return ("shell", readable_time, f"$ {command}")
             except (ValueError, IndexError):
                 return None
-    
+
     elif history_type == "bash":
         readable_time = "recent"
         if not line.startswith("devduck "):
             return ("shell", readable_time, f"$ {line}")
-    
+
     return None
 
 
+def get_recent_logs():
+    """Get the last N lines from the log file for context."""
+    try:
+        log_line_count = int(os.getenv("DEVDUCK_LOG_LINE_COUNT", "50"))
+
+        if not LOG_FILE.exists():
+            return ""
+
+        with open(LOG_FILE, "r", encoding="utf-8", errors="ignore") as f:
+            all_lines = f.readlines()
+
+        recent_lines = (
+            all_lines[-log_line_count:]
+            if len(all_lines) > log_line_count
+            else all_lines
+        )
+
+        if not recent_lines:
+            return ""
+
+        log_content = "".join(recent_lines)
+        return f"\n\n## Recent Logs (last {len(recent_lines)} lines):\n```\n{log_content}```\n"
+    except Exception as e:
+        return f"\n\n## Recent Logs: Error reading logs - {e}\n"
+
+
 def get_last_messages():
     """Get the last N messages from multiple shell histories for context."""
     try:
         message_count = int(os.getenv("DEVDUCK_LAST_MESSAGE_COUNT", "200"))
         all_entries = []
-        
+
         history_files = get_shell_history_files()
-        
+
         for history_type, history_file in history_files:
             try:
                 with open(history_file, encoding="utf-8", errors="ignore") as f:
                     lines = f.readlines()
-                
+
                 if history_type == "bash":
                     lines = lines[-message_count:]
-                
+
                 # Join multi-line entries for zsh
                 if history_type == "zsh":
                     joined_lines = []
@@ -355,22 +517,26 @@ def get_last_messages():
                     if current_line:
                         joined_lines.append(current_line)
                     lines = joined_lines
-                
+
                 for line in lines:
                     parsed = parse_history_line(line, history_type)
                     if parsed:
                         all_entries.append(parsed)
             except Exception:
                 continue
-        
-        recent_entries = all_entries[-message_count:] if len(all_entries) >= message_count else all_entries
-        
+
+        recent_entries = (
+            all_entries[-message_count:]
+            if len(all_entries) >= message_count
+            else all_entries
+        )
+
         context = ""
         if recent_entries:
             context += f"\n\nRecent conversation context (last {len(recent_entries)} messages):\n"
             for speaker, timestamp, content in recent_entries:
                 context += f"[{timestamp}] {speaker}: {content}\n"
-        
+
         return context
     except Exception:
         return ""
@@ -378,16 +544,20 @@ def get_last_messages():
 
 def append_to_shell_history(query, response):
     """Append the interaction to devduck shell history."""
-    import time
     try:
         history_file = get_shell_history_file()
         timestamp = str(int(time.time()))
-        
+
         with open(history_file, "a", encoding="utf-8") as f:
             f.write(f": {timestamp}:0;# devduck: {query}\n")
-            response_summary = str(response).replace("\n", " ")[:int(os.getenv("DEVDUCK_RESPONSE_SUMMARY_LENGTH", "10000"))] + "..."
+            response_summary = (
+                str(response).replace("\n", " ")[
+                    : int(os.getenv("DEVDUCK_RESPONSE_SUMMARY_LENGTH", "10000"))
+                ]
+                + "..."
+            )
             f.write(f": {timestamp}:0;# devduck_result: {response_summary}\n")
-        
+
         os.chmod(history_file, 0o600)
     except Exception:
         pass
@@ -395,99 +565,534 @@ def append_to_shell_history(query, response):
 
 # 🦆 The devduck agent
 class DevDuck:
-    def __init__(self):
-        """Initialize the minimalist adaptive agent"""
+    def __init__(
+        self,
+        auto_start_servers=True,
+        servers=None,
+        load_mcp_servers=True,
+    ):
+        """Initialize the minimalist adaptive agent
+
+        Args:
+            auto_start_servers: Enable automatic server startup
+            servers: Dict of server configs with optional env var lookups
+                Example: {
+                    "tcp": {"port": 9999},
+                    "ws": {"port": 8080, "LOOKUP_KEY": "SLACK_API_KEY"},
+                    "mcp": {"port": 8000},
+                    "ipc": {"socket_path": "/tmp/devduck.sock"}
+                }
+            load_mcp_servers: Load MCP servers from MCP_SERVERS env var
+        """
+        logger.info("Initializing DevDuck agent...")
         try:
-            # Self-heal dependencies
-            ensure_deps()
+            self.env_info = {
+                "os": platform.system(),
+                "arch": platform.machine(),
+                "python": sys.version_info,
+                "cwd": str(Path.cwd()),
+                "home": str(Path.home()),
+                "shell": os.environ.get("SHELL", "unknown"),
+                "hostname": socket.gethostname(),
+            }
 
-            # Adapt to environment
-            self.env_info, self.ollama_host, self.model = adapt_to_env()
+            # Execution state tracking for hot-reload
+            self._agent_executing = False
+            self._reload_pending = False
+
+            # Server configuration
+            if servers is None:
+                # Default server config from env vars
+                servers = {
+                    "tcp": {
+                        "port": int(os.getenv("DEVDUCK_TCP_PORT", "9999")),
+                        "enabled": os.getenv("DEVDUCK_ENABLE_TCP", "false").lower()
+                        == "true",
+                    },
+                    "ws": {
+                        "port": int(os.getenv("DEVDUCK_WS_PORT", "8080")),
+                        "enabled": os.getenv("DEVDUCK_ENABLE_WS", "true").lower()
+                        == "true",
+                    },
+                    "mcp": {
+                        "port": int(os.getenv("DEVDUCK_MCP_PORT", "8000")),
+                        "enabled": os.getenv("DEVDUCK_ENABLE_MCP", "false").lower()
+                        == "true",
+                    },
+                    "ipc": {
+                        "socket_path": os.getenv(
+                            "DEVDUCK_IPC_SOCKET", "/tmp/devduck_main.sock"
+                        ),
+                        "enabled": os.getenv("DEVDUCK_ENABLE_IPC", "false").lower()
+                        == "true",
+                    },
+                }
 
-            # Import after ensuring deps
-            from strands import Agent, tool
-            from strands.models.ollama import OllamaModel
-            from strands.session.file_session_manager import FileSessionManager
-            from strands_tools.utils.models.model import create_model
-            from .tools import tcp
-            from strands_tools import (
-                shell,
-                editor,
-                file_read,
-                file_write,
-                python_repl,
-                current_time,
-                calculator,
-                journal,
-                image_reader,
-                use_agent,
-                load_tool,
-                environment,
+            # Show server configuration status
+            enabled_servers = []
+            disabled_servers = []
+            for server_name, config in servers.items():
+                if config.get("enabled", False):
+                    if "port" in config:
+                        enabled_servers.append(
+                            f"{server_name.upper()}:{config['port']}"
+                        )
+                    else:
+                        enabled_servers.append(server_name.upper())
+                else:
+                    disabled_servers.append(server_name.upper())
+
+            logger.debug(
+                f"🦆 Server config: {', '.join(enabled_servers) if enabled_servers else 'none enabled'}"
             )
+            if disabled_servers:
+                logger.debug(f"🦆 Disabled: {', '.join(disabled_servers)}")
+
+            self.servers = servers
+
+            # Load tools with flexible configuration
+            # Default tool config
+            # Agent can load additional tools on-demand via fetch_github_tool
+
+            # 🔧 Available DevDuck Tools (load on-demand):
+            # - system_prompt: https://github.com/cagataycali/devduck/blob/main/devduck/tools/system_prompt.py
+            # - store_in_kb: https://github.com/cagataycali/devduck/blob/main/devduck/tools/store_in_kb.py
+            # - ipc: https://github.com/cagataycali/devduck/blob/main/devduck/tools/ipc.py
+            # - tcp: https://github.com/cagataycali/devduck/blob/main/devduck/tools/tcp.py
+            # - websocket: https://github.com/cagataycali/devduck/blob/main/devduck/tools/websocket.py
+            # - mcp_server: https://github.com/cagataycali/devduck/blob/main/devduck/tools/mcp_server.py
+            # - scraper: https://github.com/cagataycali/devduck/blob/main/devduck/tools/scraper.py
+            # - tray: https://github.com/cagataycali/devduck/blob/main/devduck/tools/tray.py
+            # - ambient: https://github.com/cagataycali/devduck/blob/main/devduck/tools/ambient.py
+            # - agentcore_config: https://github.com/cagataycali/devduck/blob/main/devduck/tools/agentcore_config.py
+            # - agentcore_invoke: https://github.com/cagataycali/devduck/blob/main/devduck/tools/agentcore_invoke.py
+            # - agentcore_logs: https://github.com/cagataycali/devduck/blob/main/devduck/tools/agentcore_logs.py
+            # - agentcore_agents: https://github.com/cagataycali/devduck/blob/main/devduck/tools/agentcore_agents.py
+            # - create_subagent: https://github.com/cagataycali/devduck/blob/main/devduck/tools/create_subagent.py
+            # - use_github: https://github.com/cagataycali/devduck/blob/main/devduck/tools/use_github.py
+            # - speech_to_speech: https://github.com/cagataycali/devduck/blob/main/devduck/tools/speech_to_speech.py
+            # - state_manager: https://github.com/cagataycali/devduck/blob/main/devduck/tools/state_manager.py
+
+            # 📦 Strands Tools
+            # - editor, file_read, file_write, image_reader, load_tool, retrieve
+            # - calculator, use_agent, environment, mcp_client, speak, slack
+
+            # 🎮 Strands Fun Tools
+            # - listen, cursor, clipboard, screen_reader, bluetooth, yolo_vision
+
+            # 🔍 Strands Google
+            # - use_google, google_auth
+
+            # 🔧 Auto-append server tools based on enabled servers
+            server_tools_needed = []
+            if servers.get("tcp", {}).get("enabled", False):
+                server_tools_needed.append("tcp")
+            if servers.get("ws", {}).get("enabled", True):
+                server_tools_needed.append("websocket")
+            if servers.get("mcp", {}).get("enabled", False):
+                server_tools_needed.append("mcp_server")
+            if servers.get("ipc", {}).get("enabled", False):
+                server_tools_needed.append("ipc")
+
+            # Append to default tools if any server tools are needed
+            if server_tools_needed:
+                server_tools_str = ",".join(server_tools_needed)
+                default_tools = f"devduck.tools:system_prompt,fetch_github_tool,{server_tools_str};strands_tools:shell"
+                logger.info(f"Auto-added server tools: {server_tools_str}")
+            else:
+                default_tools = (
+                    "devduck.tools:system_prompt,fetch_github_tool;strands_tools:shell"
+                )
+
+            tools_config = os.getenv("DEVDUCK_TOOLS", default_tools)
+            logger.info(f"Loading tools from config: {tools_config}")
+            core_tools = self._load_tools_from_config(tools_config)
 
-            # Wrap system_prompt_tool with @tool decorator
+            # Wrap view_logs_tool with @tool decorator
             @tool
-            def system_prompt(
+            def view_logs(
+                action: str = "view",
+                lines: int = 100,
+                pattern: str = None,
+            ) -> Dict[str, Any]:
+                """View and manage DevDuck logs."""
+                return view_logs_tool(action, lines, pattern)
+
+            # Wrap manage_tools_func with @tool decorator
+            @tool
+            def manage_tools(
                 action: str,
-                prompt: str = None,
-                context: str = None,
-                variable_name: str = "SYSTEM_PROMPT",
+                package: str = None,
+                tool_names: str = None,
+                tool_path: str = None,
             ) -> Dict[str, Any]:
-                """Manage agent system prompt dynamically."""
-                return system_prompt_tool(action, prompt, context, variable_name)
-
-            # Minimal but functional toolset including system_prompt and hello
-            self.tools = [
-                shell,
-                editor,
-                file_read,
-                file_write,
-                python_repl,
-                current_time,
-                calculator,
-                journal,
-                image_reader,
-                use_agent,
-                load_tool,
-                environment,
-                system_prompt,
-                tcp
-            ]
-
-            # Check if MODEL_PROVIDER env variable is set
-            model_provider = os.getenv("MODEL_PROVIDER")
-
-            if model_provider:
-                # Use create_model utility for any provider (bedrock, anthropic, etc.)
-                self.agent_model = create_model(provider=model_provider)
-            else:
-                # Fallback to default Ollama behavior
-                self.agent_model = OllamaModel(
-                    host=self.ollama_host,
-                    model_id=self.model,
-                    temperature=1,
-                    keep_alive="5m",
-                )
+                """
+                Manage the agent's tool set at runtime using ToolRegistry.
 
-            session_manager = FileSessionManager(
-                session_id=f"devduck-{datetime.now().strftime('%Y-%m-%d')}"
-            )
+                Args:
+                    action: Action to perform - "list", "add", "remove", "reload"
+                    package: Package name to load tools from (e.g., "strands_tools", "strands_fun_tools") or "devduck.tools:speech_to_speech,system_prompt,..."
+                    tool_names: Comma-separated tool names (e.g., "shell,editor,calculator")
+                    tool_path: Path to a .py file to load as a tool
+
+                Returns:
+                    Dict with status and content
+                """
+                return manage_tools_func(action, package, tool_names, tool_path)
+
+            # Add built-in tools to the toolset
+            core_tools.extend([view_logs, manage_tools])
+
+            # Assign tools
+            self.tools = core_tools
+
+            # 🔌 Load MCP servers if enabled
+            if load_mcp_servers:
+                mcp_clients = self._load_mcp_servers()
+                if mcp_clients:
+                    self.tools.extend(mcp_clients)
+                    logger.info(f"Loaded {len(mcp_clients)} MCP server(s)")
+
+            logger.info(f"Initialized {len(self.tools)} tools")
+
+            # 🎯 Smart model selection
+            self.agent_model, self.model = self._select_model()
 
             # Create agent with self-healing
+            # load_tools_from_directory controlled by DEVDUCK_LOAD_TOOLS_FROM_DIR (default: true)
+            load_from_dir = (
+                os.getenv("DEVDUCK_LOAD_TOOLS_FROM_DIR", "true").lower() == "true"
+            )
+
             self.agent = Agent(
                 model=self.agent_model,
                 tools=self.tools,
                 system_prompt=self._build_system_prompt(),
-                load_tools_from_directory=True,
-                # session_manager=session_manager,
+                load_tools_from_directory=load_from_dir,
+                trace_attributes={
+                    "session.id": self.session_id,
+                    "user.id": self.env_info["hostname"],
+                    "tags": ["Strands-Agents", "DevDuck"],
+                },
             )
 
+            # 🚀 AUTO-START SERVERS
+            if auto_start_servers and "--mcp" not in sys.argv:
+                self._start_servers()
+
             # Start file watcher for auto hot-reload
             self._start_file_watcher()
 
+            logger.info(
+                f"DevDuck agent initialized successfully with model {self.model}"
+            )
+
         except Exception as e:
+            logger.error(f"Initialization failed: {e}")
             self._self_heal(e)
 
+    def _load_tools_from_config(self, config):
+        """
+        Load tools based on DEVDUCK_TOOLS configuration.
+
+        Format: package1:tool1,tool2;package2:tool3,tool4
+        Examples:
+          - strands_tools:shell,editor;strands_action:use_github
+          - strands_action:use_github;strands_tools:shell,use_aws
+
+        Note: Only loads what's specified in config - no automatic additions
+        """
+        tools = []
+
+        # Split by semicolon to get package groups
+        groups = config.split(";")
+
+        for group in groups:
+            group = group.strip()
+            if not group:
+                continue
+
+            # Split by colon to get package:tools
+            parts = group.split(":", 1)
+            if len(parts) != 2:
+                logger.warning(f"Invalid format: {group}")
+                continue
+
+            package = parts[0].strip()
+            tools_str = parts[1].strip()
+
+            # Parse tools (comma-separated)
+            tool_names = [t.strip() for t in tools_str.split(",") if t.strip()]
+
+            for tool_name in tool_names:
+                tool = self._load_single_tool(package, tool_name)
+                if tool:
+                    tools.append(tool)
+
+        logger.info(f"Loaded {len(tools)} tools from configuration")
+        return tools
+
+    def _load_single_tool(self, package, tool_name):
+        """Load a single tool from a package"""
+        try:
+            module = __import__(package, fromlist=[tool_name])
+            tool = getattr(module, tool_name)
+            logger.debug(f"Loaded {tool_name} from {package}")
+            return tool
+        except Exception as e:
+            logger.warning(f"Failed to load {tool_name} from {package}: {e}")
+            return None
+
+    def _load_mcp_servers(self):
+        """
+        Load MCP servers from MCP_SERVERS environment variable using direct loading.
+
+        Uses the experimental managed integration - MCPClient instances are passed
+        directly to Agent constructor without explicit context management.
+
+        Format: JSON with "mcpServers" object
+        Example: MCP_SERVERS='{"mcpServers": {"strands": {"command": "uvx", "args": ["strands-agents-mcp-server"]}}}'
+
+        Returns:
+            List of MCPClient instances ready for direct use in Agent
+        """
+        mcp_servers_json = os.getenv("MCP_SERVERS")
+        if not mcp_servers_json:
+            logger.debug("No MCP_SERVERS environment variable found")
+            return []
+
+        try:
+            config = json.loads(mcp_servers_json)
+            mcp_servers_config = config.get("mcpServers", {})
+
+            if not mcp_servers_config:
+                logger.warning("MCP_SERVERS JSON has no 'mcpServers' key")
+                return []
+
+            mcp_clients = []
+
+            from strands.tools.mcp import MCPClient
+            from mcp import stdio_client, StdioServerParameters
+            from mcp.client.streamable_http import streamablehttp_client
+            from mcp.client.sse import sse_client
+
+            for server_name, server_config in mcp_servers_config.items():
+                try:
+                    logger.info(f"Loading MCP server: {server_name}")
+
+                    # Determine transport type and create appropriate callable
+                    if "command" in server_config:
+                        # stdio transport
+                        command = server_config["command"]
+                        args = server_config.get("args", [])
+                        env = server_config.get("env", None)
+
+                        transport_callable = (
+                            lambda cmd=command, a=args, e=env: stdio_client(
+                                StdioServerParameters(command=cmd, args=a, env=e)
+                            )
+                        )
+
+                    elif "url" in server_config:
+                        # Determine if SSE or streamable HTTP based on URL path
+                        url = server_config["url"]
+                        headers = server_config.get("headers", None)
+
+                        if "/sse" in url:
+                            # SSE transport
+                            transport_callable = lambda u=url: sse_client(u)
+                        else:
+                            # Streamable HTTP transport (default for HTTP)
+                            transport_callable = (
+                                lambda u=url, h=headers: streamablehttp_client(
+                                    url=u, headers=h
+                                )
+                            )
+                    else:
+                        logger.warning(
+                            f"MCP server {server_name} has no 'command' or 'url' - skipping"
+                        )
+                        continue
+
+                    # Create MCPClient with direct loading (experimental managed integration)
+                    # No need for context managers - Agent handles lifecycle
+                    prefix = server_config.get("prefix", server_name)
+                    mcp_client = MCPClient(
+                        transport_callable=transport_callable, prefix=prefix
+                    )
+
+                    mcp_clients.append(mcp_client)
+                    logger.info(
+                        f"✓ MCP server '{server_name}' loaded (prefix: {prefix})"
+                    )
+
+                except Exception as e:
+                    logger.error(f"Failed to load MCP server '{server_name}': {e}")
+                    continue
+
+            return mcp_clients
+
+        except json.JSONDecodeError as e:
+            logger.error(f"Invalid JSON in MCP_SERVERS: {e}")
+            return []
+        except Exception as e:
+            logger.error(f"Error loading MCP servers: {e}")
+            return []
+
+    def _select_model(self):
+        """
+        Smart model selection with fallback based on available credentials.
+
+        Priority: Bedrock → Anthropic → OpenAI → GitHub → Gemini → Cohere →
+                  Writer → Mistral → LiteLLM → LlamaAPI → SageMaker →
+                  LlamaCpp → MLX → Ollama
+
+        Returns:
+            Tuple of (model_instance, model_name)
+        """
+        provider = os.getenv("MODEL_PROVIDER")
+
+        # Read common model parameters from environment
+        max_tokens = int(os.getenv("STRANDS_MAX_TOKENS", "60000"))
+        temperature = float(os.getenv("STRANDS_TEMPERATURE", "1.0"))
+
+        if not provider:
+            # Auto-detect based on API keys and credentials
+            # 1. Try Bedrock (AWS bearer token or STS credentials)
+            try:
+                # Check for bearer token first
+                if os.getenv("AWS_BEARER_TOKEN_BEDROCK"):
+                    provider = "bedrock"
+                    print("🦆 Using Bedrock (bearer token)")
+                else:
+                    # Try STS credentials
+                    import boto3
+
+                    boto3.client("sts").get_caller_identity()
+                    provider = "bedrock"
+                    print("🦆 Using Bedrock")
+            except:
+                # 2. Try Anthropic
+                if os.getenv("ANTHROPIC_API_KEY"):
+                    provider = "anthropic"
+                    print("🦆 Using Anthropic")
+                # 3. Try OpenAI
+                elif os.getenv("OPENAI_API_KEY"):
+                    provider = "openai"
+                    print("🦆 Using OpenAI")
+                # 4. Try GitHub Models
+                elif os.getenv("GITHUB_TOKEN") or os.getenv("PAT_TOKEN"):
+                    provider = "github"
+                    print("🦆 Using GitHub Models")
+                # 5. Try Gemini
+                elif os.getenv("GOOGLE_API_KEY") or os.getenv("GEMINI_API_KEY"):
+                    provider = "gemini"
+                    print("🦆 Using Gemini")
+                # 6. Try Cohere
+                elif os.getenv("COHERE_API_KEY"):
+                    provider = "cohere"
+                    print("🦆 Using Cohere")
+                # 7. Try Writer
+                elif os.getenv("WRITER_API_KEY"):
+                    provider = "writer"
+                    print("🦆 Using Writer")
+                # 8. Try Mistral
+                elif os.getenv("MISTRAL_API_KEY"):
+                    provider = "mistral"
+                    print("🦆 Using Mistral")
+                # 9. Try LiteLLM
+                elif os.getenv("LITELLM_API_KEY"):
+                    provider = "litellm"
+                    print("🦆 Using LiteLLM")
+                # 10. Try LlamaAPI
+                elif os.getenv("LLAMAAPI_API_KEY"):
+                    provider = "llamaapi"
+                    print("🦆 Using LlamaAPI")
+                # 11. Try SageMaker
+                elif os.getenv("SAGEMAKER_ENDPOINT_NAME"):
+                    provider = "sagemaker"
+                    print("🦆 Using SageMaker")
+                # 12. Try LlamaCpp
+                elif os.getenv("LLAMACPP_MODEL_PATH"):
+                    provider = "llamacpp"
+                    print("🦆 Using LlamaCpp")
+                # 13. Try MLX on Apple Silicon
+                elif platform.system() == "Darwin" and platform.machine() in [
+                    "arm64",
+                    "aarch64",
+                ]:
+                    try:
+                        from strands_mlx import MLXModel
+
+                        provider = "mlx"
+                        print("🦆 Using MLX (Apple Silicon)")
+                    except ImportError:
+                        provider = "ollama"
+                        print("🦆 Using Ollama (fallback)")
+                # 14. Fallback to Ollama
+                else:
+                    provider = "ollama"
+                    print("🦆 Using Ollama (fallback)")
+
+        # Create model based on provider
+        if provider == "mlx":
+            from strands_mlx import MLXModel
+
+            model_name = os.getenv("STRANDS_MODEL_ID", "mlx-community/Qwen3-1.7B-4bit")
+            return (
+                MLXModel(
+                    model_id=model_name,
+                    params={"temperature": temperature, "max_tokens": max_tokens},
+                ),
+                model_name,
+            )
+
+        elif provider == "gemini":
+            from strands.models.gemini import GeminiModel
+
+            model_name = os.getenv("STRANDS_MODEL_ID", "gemini-2.5-flash")
+            api_key = os.getenv("GOOGLE_API_KEY") or os.getenv("GEMINI_API_KEY")
+            return (
+                GeminiModel(
+                    client_args={"api_key": api_key},
+                    model_id=model_name,
+                    params={"temperature": temperature, "max_tokens": max_tokens},
+                ),
+                model_name,
+            )
+
+        elif provider == "ollama":
+            from strands.models.ollama import OllamaModel
+
+            # Smart model selection based on OS
+            os_type = platform.system()
+            if os_type == "Darwin":
+                model_name = os.getenv("STRANDS_MODEL_ID", "qwen3:1.7b")
+            elif os_type == "Linux":
+                model_name = os.getenv("STRANDS_MODEL_ID", "qwen3:30b")
+            else:
+                model_name = os.getenv("STRANDS_MODEL_ID", "qwen3:8b")
+
+            return (
+                OllamaModel(
+                    host=os.getenv("OLLAMA_HOST", "http://localhost:11434"),
+                    model_id=model_name,
+                    temperature=temperature,
+                    num_predict=max_tokens,
+                    keep_alive="5m",
+                ),
+                model_name,
+            )
+
+        else:
+            # All other providers via create_model utility
+            # Supports: bedrock, anthropic, openai, github, cohere, writer, mistral, litellm
+            from strands_tools.utils.models.model import create_model
+
+            model = create_model(provider=provider)
+            model_name = os.getenv("STRANDS_MODEL_ID", provider)
+            return model, model_name
+
     def _build_system_prompt(self):
         """Build adaptive system prompt based on environment
 
@@ -498,11 +1103,20 @@ class DevDuck:
 
         Learning: Always check source code truth over conversation memory!
         """
+        # Current date and time
+        current_datetime = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        current_date = datetime.now().strftime("%A, %B %d, %Y")
+        current_time = datetime.now().strftime("%I:%M %p")
+
         session_id = f"devduck-{datetime.now().strftime('%Y-%m-%d')}"
+        self.session_id = session_id
+
+        # Get own file path for self-modification awareness
+        own_file_path = Path(__file__).resolve()
 
         # Get own source code for self-awareness
         own_code = get_own_source_code()
-        
+
         # Get recent conversation history context (with error handling)
         try:
             recent_context = get_last_messages()
@@ -510,6 +1124,13 @@ class DevDuck:
             print(f"🦆 Warning: Could not load history context: {e}")
             recent_context = ""
 
+        # Get recent logs for immediate visibility
+        try:
+            recent_logs = get_recent_logs()
+        except Exception as e:
+            print(f"🦆 Warning: Could not load recent logs: {e}")
+            recent_logs = ""
+
         return f"""🦆 You are DevDuck - an extreme minimalist, self-adapting agent.
 
 Environment: {self.env_info['os']} {self.env_info['arch']} 
@@ -517,6 +1138,8 @@ Python: {self.env_info['python']}
 Model: {self.model}
 Hostname: {self.env_info['hostname']}
 Session ID: {session_id}
+Current Time: {current_datetime} ({current_date} at {current_time})
+My Path: {own_file_path}
 
 You are:
 - Minimalist: Brief, direct responses
@@ -527,6 +1150,7 @@ You are:
 Current working directory: {self.env_info['cwd']}
 
 {recent_context}
+{recent_logs}
 
 ## Your Own Implementation:
 You have full access to your own source code for self-awareness and self-modification:
@@ -538,59 +1162,56 @@ You have full access to your own source code for self-awareness and self-modific
 - **No Restart Needed** - Tools are auto-loaded and ready to use instantly
 - **Live Development** - Modify existing tools while running and test immediately
 - **Full Python Access** - Create any Python functionality as a tool
+- **Agent Protection** - Hot-reload waits until agent finishes current task
+
+## Dynamic Tool Loading:
+- **Install Tools** - Use install_tools() to load tools from any Python package
+  - Example: install_tools(action="install_and_load", package="strands-fun-tools", module="strands_fun_tools")
+  - Expands capabilities without restart
+  - Access to entire Python ecosystem
+
+## Tool Configuration:
+Set DEVDUCK_TOOLS for custom tools:
+- Format: package1:tool1,tool2;package2:tool3,tool4
+- Example: strands_tools:shell,editor;strands_fun_tools:clipboard
+- Tools are filtered - only specified tools are loaded
+- Load the speech_to_speech tool when it's needed
+- Offload the tools when you don't need
+
+## MCP Integration:
+- **Expose as MCP Server** - Use mcp_server() to expose devduck via MCP protocol
+  - Example: mcp_server(action="start", port=8000)
+  - Connect from Claude Desktop, other agents, or custom clients
+  - Full bidirectional communication
+
+- **Load MCP Servers** - Set MCP_SERVERS env var to auto-load external MCP servers
+  - Format: JSON with "mcpServers" object
+  - Stdio servers: command, args, env keys
+  - HTTP servers: url, headers keys
+  - Example: MCP_SERVERS='{{"mcpServers": {{"strands": {{"command": "uvx", "args": ["strands-agents-mcp-server"]}}}}}}'
+  - Tools from MCP servers automatically available in agent context
+
+## Knowledge Base Integration:
+- **Automatic RAG** - Set DEVDUCK_KNOWLEDGE_BASE_ID to enable automatic retrieval/storage
+  - Before each query: Retrieves relevant context from knowledge base
+  - After each response: Stores conversation for future reference
+  - Seamless memory across sessions without manual tool calls
 
-## Tool Creation Patterns:
-
-### **1. @tool Decorator:**
-```python
-# ./tools/calculate_tip.py
-from strands import tool
-
-@tool
-def calculate_tip(amount: float, percentage: float = 15.0) -> str:
-    \"\"\"Calculate tip and total for a bill.
-    
-    Args:
-        amount: Bill amount in dollars
-        percentage: Tip percentage (default: 15.0)
-        
-    Returns:
-        str: Formatted tip calculation result
-    \"\"\"
-    tip = amount * (percentage / 100)
-    total = amount + tip
-    return f"Tip: {{tip:.2f}}, Total: {{total:.2f}}"
-```
-
-### **2. Action-Based Pattern:**
-```python
-# ./tools/weather.py
-from typing import Dict, Any
-from strands import tool
+## System Prompt Management:
+- **View**: system_prompt(action='view') - See current prompt
+- **Update Local**: system_prompt(action='update', prompt='new text') - Updates env var + .prompt file
+- **Update GitHub**: system_prompt(action='update', prompt='text', repository='cagataycali/devduck') - Syncs to repo variables
+- **Variable Name**: system_prompt(action='update', prompt='text', variable_name='CUSTOM_PROMPT') - Use custom var
+- **Add Context**: system_prompt(action='add_context', context='new learning') - Append without replacing
 
-@tool
-def weather(action: str, location: str = None) -> Dict[str, Any]:
-    \"\"\"Comprehensive weather information tool.
-    
-    Args:
-        action: Action to perform (current, forecast, alerts)
-        location: City name (required)
-        
-    Returns:
-        Dict containing status and response content
-    \"\"\"
-    if action == "current":
-        return {{"status": "success", "content": [{{"text": f"Weather for {{location}}"}}]}}
-    elif action == "forecast":
-        return {{"status": "success", "content": [{{"text": f"Forecast for {{location}}"}}]}}
-    else:
-        return {{"status": "error", "content": [{{"text": f"Unknown action: {{action}}"}}]}}
-```
+### 🧠 Self-Improvement Pattern:
+When you learn something valuable during conversations:
+1. Identify the new insight or pattern
+2. Use system_prompt(action='add_context', context='...')  to append it
+3. Sync to GitHub: system_prompt(action='update', prompt=new_full_prompt, repository='owner/repo')
+4. New learnings persist across sessions via SYSTEM_PROMPT env var
 
-## System Prompt Management:
-- Use system_prompt(action='get') to view current prompt
-- Use system_prompt(action='set', prompt='new text') to update
-- Changes persist in SYSTEM_PROMPT environment variable
+**Repository Integration**: Set repository='cagataycali/devduck' to sync prompts across deployments
 
 ## Shell Commands:
 - Prefix with ! to execute shell commands directly
@@ -602,96 +1223,25 @@ def weather(action: str, location: str = None) -> Dict[str, Any]:
 - Communication: **MINIMAL WORDS**
 - Efficiency: **Speed is paramount**
 
-{os.getenv('SYSTEM_PROMPT', '')}"""
+{_get_system_prompt()}"""
 
     def _self_heal(self, error):
         """Attempt self-healing when errors occur"""
+        logger.error(f"Self-healing triggered by error: {error}")
         print(f"🦆 Self-healing from: {error}")
 
         # Prevent infinite recursion by tracking heal attempts
         if not hasattr(self, "_heal_count"):
             self._heal_count = 0
-        
+
         self._heal_count += 1
-        
+
         # Limit recursion - if we've tried more than 3 times, give up
-        if self._heal_count > 3:
+        if self._heal_count > 2:
             print(f"🦆 Self-healing failed after {self._heal_count} attempts")
             print("🦆 Please fix the issue manually and restart")
             sys.exit(1)
 
-        # Handle tool validation errors by resetting session
-        if "Expected toolResult blocks" in str(error):
-            print("🦆 Tool validation error detected - resetting session...")
-            # Add timestamp postfix to create fresh session
-            postfix = datetime.now().strftime("%H%M%S")
-            new_session_id = f"devduck-{datetime.now().strftime('%Y-%m-%d')}-{postfix}"
-            print(f"🦆 New session: {new_session_id}")
-
-            # Update session manager with new session
-            try:
-                from strands.session.file_session_manager import FileSessionManager
-
-                self.agent.session_manager = FileSessionManager(
-                    session_id=new_session_id
-                )
-                print("🦆 Session reset successful - continuing with fresh history")
-                self._heal_count = 0  # Reset counter on success
-                return  # Early return - no need for full restart
-            except Exception as session_error:
-                print(f"🦆 Session reset failed: {session_error}")
-
-        # Common healing strategies
-        if "not found" in str(error).lower() and "model" in str(error).lower():
-            print("🦆 Model not found - trying to pull model...")
-            try:
-                # Try to pull the model
-                result = subprocess.run(
-                    ["ollama", "pull", self.model], capture_output=True, timeout=60
-                )
-                if result.returncode == 0:
-                    print(f"🦆 Successfully pulled {self.model}")
-                else:
-                    print(f"🦆 Failed to pull {self.model}, trying fallback...")
-                    # Fallback to basic models
-                    fallback_models = ["llama3.2:1b", "qwen2.5:0.5b", "gemma2:2b"]
-                    for fallback in fallback_models:
-                        try:
-                            subprocess.run(
-                                ["ollama", "pull", fallback],
-                                capture_output=True,
-                                timeout=30,
-                            )
-                            self.model = fallback
-                            print(f"🦆 Using fallback model: {fallback}")
-                            break
-                        except:
-                            continue
-            except Exception as pull_error:
-                print(f"🦆 Model pull failed: {pull_error}")
-                # Ultra-minimal fallback
-                self.model = "llama3.2:1b"
-
-        elif "ollama" in str(error).lower():
-            print("🦆 Ollama issue - checking service...")
-            try:
-                # Check if ollama is running
-                result = subprocess.run(
-                    ["ollama", "list"], capture_output=True, timeout=5
-                )
-                if result.returncode != 0:
-                    print("🦆 Starting ollama service...")
-                    subprocess.Popen(["ollama", "serve"])
-                    import time
-
-                    time.sleep(3)  # Wait for service to start
-            except Exception as ollama_error:
-                print(f"🦆 Ollama service issue: {ollama_error}")
-
-        elif "import" in str(error).lower():
-            print("🦆 Import issue - reinstalling dependencies...")
-            ensure_deps()
-
         elif "connection" in str(error).lower():
             print("🦆 Connection issue - checking ollama service...")
             try:
@@ -707,14 +1257,247 @@ def weather(action: str, location: str = None) -> Dict[str, Any]:
             print("🦆 Running in minimal mode...")
             self.agent = None
 
+    def _is_port_available(self, port):
+        """Check if a port is available"""
+        try:
+            test_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            test_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            test_socket.bind(("0.0.0.0", port))
+            test_socket.close()
+            return True
+        except OSError:
+            return False
+
+    def _is_socket_available(self, socket_path):
+        """Check if a Unix socket is available"""
+
+        # If socket file doesn't exist, it's available
+        if not os.path.exists(socket_path):
+            return True
+        # If it exists, try to connect to see if it's in use
+        try:
+            test_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+            test_socket.connect(socket_path)
+            test_socket.close()
+            return False  # Socket is in use
+        except (ConnectionRefusedError, FileNotFoundError):
+            # Socket file exists but not in use - remove stale socket
+            try:
+                os.remove(socket_path)
+                return True
+            except:
+                return False
+        except Exception:
+            return False
+
+    def _find_available_port(self, start_port, max_attempts=10):
+        """Find an available port starting from start_port"""
+        for offset in range(max_attempts):
+            port = start_port + offset
+            if self._is_port_available(port):
+                return port
+        return None
+
+    def _find_available_socket(self, base_socket_path, max_attempts=10):
+        """Find an available socket path"""
+        if self._is_socket_available(base_socket_path):
+            return base_socket_path
+        # Try numbered alternatives
+        for i in range(1, max_attempts):
+            alt_socket = f"{base_socket_path}.{i}"
+            if self._is_socket_available(alt_socket):
+                return alt_socket
+        return None
+
+    def _start_servers(self):
+        """Auto-start configured servers with port conflict handling"""
+        logger.info("Auto-starting servers...")
+        print("🦆 Auto-starting servers...")
+
+        # Start servers in order: IPC, TCP, WS, MCP
+        server_order = ["ipc", "tcp", "ws", "mcp"]
+
+        for server_type in server_order:
+            if server_type not in self.servers:
+                continue
+
+            config = self.servers[server_type]
+
+            # Check if server is enabled
+            if not config.get("enabled", True):
+                continue
+
+            # Check for LOOKUP_KEY (conditional start based on env var)
+            if "LOOKUP_KEY" in config:
+                lookup_key = config["LOOKUP_KEY"]
+                if not os.getenv(lookup_key):
+                    logger.info(f"Skipping {server_type} - {lookup_key} not set")
+                    continue
+
+            # Start the server with port conflict handling
+            try:
+                if server_type == "tcp":
+                    port = config.get("port", 9999)
+
+                    # Check port availability BEFORE attempting to start
+                    if not self._is_port_available(port):
+                        alt_port = self._find_available_port(port + 1)
+                        if alt_port:
+                            logger.info(f"Port {port} in use, using {alt_port}")
+                            print(f"🦆 Port {port} in use, using {alt_port}")
+                            port = alt_port
+                        else:
+                            logger.warning(f"No available ports found for TCP server")
+                            continue
+
+                    result = self.agent.tool.tcp(
+                        action="start_server", port=port, record_direct_tool_call=False
+                    )
+
+                    if result.get("status") == "success":
+                        logger.info(f"✓ TCP server started on port {port}")
+                        print(f"🦆 ✓ TCP server: localhost:{port}")
+
+                elif server_type == "ws":
+                    port = config.get("port", 8080)
+
+                    # Check port availability BEFORE attempting to start
+                    if not self._is_port_available(port):
+                        alt_port = self._find_available_port(port + 1)
+                        if alt_port:
+                            logger.info(f"Port {port} in use, using {alt_port}")
+                            print(f"🦆 Port {port} in use, using {alt_port}")
+                            port = alt_port
+                        else:
+                            logger.warning(
+                                f"No available ports found for WebSocket server"
+                            )
+                            continue
+
+                    result = self.agent.tool.websocket(
+                        action="start_server", port=port, record_direct_tool_call=False
+                    )
+
+                    if result.get("status") == "success":
+                        logger.info(f"✓ WebSocket server started on port {port}")
+                        print(f"🦆 ✓ WebSocket server: localhost:{port}")
+
+                elif server_type == "mcp":
+                    port = config.get("port", 8000)
+
+                    # Check port availability BEFORE attempting to start
+                    if not self._is_port_available(port):
+                        alt_port = self._find_available_port(port + 1)
+                        if alt_port:
+                            logger.info(f"Port {port} in use, using {alt_port}")
+                            print(f"🦆 Port {port} in use, using {alt_port}")
+                            port = alt_port
+                        else:
+                            logger.warning(f"No available ports found for MCP server")
+                            continue
+
+                    result = self.agent.tool.mcp_server(
+                        action="start",
+                        transport="http",
+                        port=port,
+                        expose_agent=True,
+                        agent=self.agent,
+                        record_direct_tool_call=False,
+                    )
+
+                    if result.get("status") == "success":
+                        logger.info(f"✓ MCP HTTP server started on port {port}")
+                        print(f"🦆 ✓ MCP server: http://localhost:{port}/mcp")
+
+                elif server_type == "ipc":
+                    socket_path = config.get("socket_path", "/tmp/devduck_main.sock")
+
+                    # Check socket availability BEFORE attempting to start
+                    available_socket = self._find_available_socket(socket_path)
+                    if not available_socket:
+                        logger.warning(
+                            f"No available socket paths found for IPC server"
+                        )
+                        continue
+
+                    if available_socket != socket_path:
+                        logger.info(
+                            f"Socket {socket_path} in use, using {available_socket}"
+                        )
+                        print(
+                            f"🦆 Socket {socket_path} in use, using {available_socket}"
+                        )
+                        socket_path = available_socket
+
+                    result = self.agent.tool.ipc(
+                        action="start_server",
+                        socket_path=socket_path,
+                        record_direct_tool_call=False,
+                    )
+
+                    if result.get("status") == "success":
+                        logger.info(f"✓ IPC server started on {socket_path}")
+                        print(f"🦆 ✓ IPC server: {socket_path}")
+                # TODO: support custom file path here so we can trigger foreign python function like another file
+            except Exception as e:
+                logger.error(f"Failed to start {server_type} server: {e}")
+                print(f"🦆 ⚠ {server_type.upper()} server failed: {e}")
+
     def __call__(self, query):
-        """Make the agent callable"""
+        """Make the agent callable with automatic knowledge base integration"""
         if not self.agent:
+            logger.warning("Agent unavailable - attempted to call with query")
             return "🦆 Agent unavailable - try: devduck.restart()"
 
         try:
-            return self.agent(query)
+            logger.info(f"Agent call started: {query[:100]}...")
+
+            # Mark agent as executing to prevent hot-reload interruption
+            self._agent_executing = True
+
+            # 📚 Knowledge Base Retrieval (BEFORE agent runs)
+            knowledge_base_id = os.getenv("DEVDUCK_KNOWLEDGE_BASE_ID")
+            if knowledge_base_id and hasattr(self.agent, "tool"):
+                try:
+                    if "retrieve" in self.agent.tool_names:
+                        logger.info(f"Retrieving context from KB: {knowledge_base_id}")
+                        self.agent.tool.retrieve(
+                            text=query, knowledgeBaseId=knowledge_base_id
+                        )
+                except Exception as e:
+                    logger.warning(f"KB retrieval failed: {e}")
+
+            # Run the agent
+            result = self.agent(query)
+
+            # 💾 Knowledge Base Storage (AFTER agent runs)
+            if knowledge_base_id and hasattr(self.agent, "tool"):
+                try:
+                    if "store_in_kb" in self.agent.tool_names:
+                        conversation_content = f"Input: {query}, Result: {result!s}"
+                        conversation_title = f"DevDuck: {datetime.now().strftime('%Y-%m-%d')} | {query[:500]}"
+                        self.agent.tool.store_in_kb(
+                            content=conversation_content,
+                            title=conversation_title,
+                            knowledge_base_id=knowledge_base_id,
+                        )
+                        logger.info(f"Stored conversation in KB: {knowledge_base_id}")
+                except Exception as e:
+                    logger.warning(f"KB storage failed: {e}")
+
+            # Clear executing flag
+            self._agent_executing = False
+
+            # Check for pending hot-reload
+            if self._reload_pending:
+                logger.info("Triggering pending hot-reload after agent completion")
+                print("\n🦆 Agent finished - triggering pending hot-reload...")
+                self._hot_reload()
+
+            return result
         except Exception as e:
+            self._agent_executing = False  # Reset flag on error
+            logger.error(f"Agent call failed with error: {e}")
             self._self_heal(e)
             if self.agent:
                 return self.agent(query)
@@ -723,37 +1506,38 @@ def weather(action: str, location: str = None) -> Dict[str, Any]:
 
     def restart(self):
         """Restart the agent"""
-        print("🦆 Restarting...")
+        print("\n🦆 Restarting...")
+        logger.debug("\n🦆 Restarting...")
         self.__init__()
 
     def _start_file_watcher(self):
         """Start background file watcher for auto hot-reload"""
-        import threading
 
+        logger.info("Starting file watcher for hot-reload")
         # Get the path to this file
         self._watch_file = Path(__file__).resolve()
         self._last_modified = (
             self._watch_file.stat().st_mtime if self._watch_file.exists() else None
         )
         self._watcher_running = True
+        self._is_reloading = False
 
         # Start watcher thread
         self._watcher_thread = threading.Thread(
             target=self._file_watcher_thread, daemon=True
         )
         self._watcher_thread.start()
+        logger.info(f"File watcher started, monitoring {self._watch_file}")
 
     def _file_watcher_thread(self):
         """Background thread that watches for file changes"""
-        import time
-
         last_reload_time = 0
         debounce_seconds = 3  # 3 second debounce
 
         while self._watcher_running:
             try:
-                # Skip if currently reloading to prevent triggering during exec()
-                if getattr(self, "_is_reloading", False):
+                # Skip if currently reloading
+                if self._is_reloading:
                     time.sleep(1)
                     continue
 
@@ -767,19 +1551,36 @@ def weather(action: str, location: str = None) -> Dict[str, Any]:
                         and current_mtime > self._last_modified
                         and current_time - last_reload_time > debounce_seconds
                     ):
-
-                        print(f"🦆 Detected changes in {self._watch_file.name}!")
-                        self._last_modified = current_mtime
+                        print(f"\n🦆 Detected changes in {self._watch_file.name}!")
                         last_reload_time = current_time
 
-                        # Trigger hot-reload
-                        time.sleep(0.5)  # Small delay to ensure file write is complete
-                        self.hot_reload()
+                        # Check if agent is currently executing
+                        if self._agent_executing:
+                            logger.info(
+                                "Code change detected but agent is executing - reload pending"
+                            )
+                            print(
+                                "\n🦆 Agent is currently executing - reload will trigger after completion"
+                            )
+                            self._reload_pending = True
+                            # Don't update _last_modified yet - keep detecting the change
+                        else:
+                            # Safe to reload immediately
+                            self._last_modified = current_mtime
+                            logger.info(
+                                f"Code change detected in {self._watch_file.name} - triggering hot-reload"
+                            )
+                            time.sleep(
+                                0.5
+                            )  # Small delay to ensure file write is complete
+                            self._hot_reload()
                     else:
-                        self._last_modified = current_mtime
+                        # Update timestamp if no change or still in debounce
+                        if not self._reload_pending:
+                            self._last_modified = current_mtime
 
             except Exception as e:
-                print(f"🦆 File watcher error: {e}")
+                logger.error(f"File watcher error: {e}")
 
             # Check every 1 second
             time.sleep(1)
@@ -787,40 +1588,45 @@ def weather(action: str, location: str = None) -> Dict[str, Any]:
     def _stop_file_watcher(self):
         """Stop the file watcher"""
         self._watcher_running = False
-        print("🦆 File watcher stopped")
+        logger.info("File watcher stopped")
 
-    def hot_reload(self):
+    def _hot_reload(self):
         """Hot-reload by restarting the entire Python process with fresh code"""
-        print("🦆 Hot-reloading via process restart...")
+        logger.info("Hot-reload initiated")
+        print("\n🦆 Hot-reloading via process restart...")
 
         try:
             # Set reload flag to prevent recursive reloads during shutdown
-            if hasattr(self, "_is_reloading") and self._is_reloading:
-                print("🦆 Reload already in progress, skipping")
-                return
-
             self._is_reloading = True
 
+            # Update last_modified before reload to acknowledge the change
+            if hasattr(self, "_watch_file") and self._watch_file.exists():
+                self._last_modified = self._watch_file.stat().st_mtime
+
+            # Reset pending flag
+            self._reload_pending = False
+
             # Stop the file watcher
             if hasattr(self, "_watcher_running"):
                 self._watcher_running = False
 
-            print("🦆 Restarting process with fresh code...")
+            print("\n🦆 Restarting process with fresh code...")
+            logger.debug("\n🦆 Restarting process with fresh code...")
 
             # Restart the entire Python process
             # This ensures all code is freshly loaded
             os.execv(sys.executable, [sys.executable] + sys.argv)
 
         except Exception as e:
-            print(f"🦆 Hot-reload failed: {e}")
-            print("🦆 Falling back to manual restart")
+            logger.error(f"Hot-reload failed: {e}")
+            print(f"\n🦆 Hot-reload failed: {e}")
+            print("\n🦆 Falling back to manual restart")
             self._is_reloading = False
 
     def status(self):
         """Show current status"""
         return {
             "model": self.model,
-            "host": self.ollama_host,
             "env": self.env_info,
             "agent_ready": self.agent is not None,
             "tools": len(self.tools) if hasattr(self, "tools") else 0,
@@ -834,7 +1640,15 @@ def weather(action: str, location: str = None) -> Dict[str, Any]:
 
 
 # 🦆 Auto-initialize when imported
-devduck = DevDuck()
+# Check environment variables to control server configuration
+# Also check if --mcp flag is present to skip auto-starting servers
+_auto_start = os.getenv("DEVDUCK_AUTO_START_SERVERS", "true").lower() == "true"
+
+# Disable auto-start if --mcp flag is present (stdio mode)
+if "--mcp" in sys.argv:
+    _auto_start = False
+
+devduck = DevDuck(auto_start_servers=_auto_start)
 
 
 # 🚀 Convenience functions
@@ -855,20 +1669,124 @@ def restart():
 
 def hot_reload():
     """Quick hot-reload without restart"""
-    devduck.hot_reload()
+    devduck._hot_reload()
+
+
+def extract_commands_from_history():
+    """Extract commonly used commands from shell history for auto-completion."""
+    commands = set()
+    history_files = get_shell_history_files()
+
+    # Limit the number of recent commands to process for performance
+    max_recent_commands = 100
+
+    for history_type, history_file in history_files:
+        try:
+            with open(history_file, encoding="utf-8", errors="ignore") as f:
+                lines = f.readlines()
+
+            # Take recent commands for better relevance
+            recent_lines = (
+                lines[-max_recent_commands:]
+                if len(lines) > max_recent_commands
+                else lines
+            )
+
+            for line in recent_lines:
+                line = line.strip()
+                if not line:
+                    continue
+
+                if history_type == "devduck":
+                    # Extract devduck commands
+                    if "# devduck:" in line:
+                        try:
+                            query = line.split("# devduck:")[-1].strip()
+                            # Extract first word as command
+                            first_word = query.split()[0] if query.split() else None
+                            if (
+                                first_word and len(first_word) > 2
+                            ):  # Only meaningful commands
+                                commands.add(first_word.lower())
+                        except (ValueError, IndexError):
+                            continue
+
+                elif history_type == "zsh":
+                    # Zsh format: ": timestamp:0;command"
+                    if line.startswith(": ") and ":0;" in line:
+                        try:
+                            parts = line.split(":0;", 1)
+                            if len(parts) == 2:
+                                full_command = parts[1].strip()
+                                # Extract first word as command
+                                first_word = (
+                                    full_command.split()[0]
+                                    if full_command.split()
+                                    else None
+                                )
+                                if (
+                                    first_word and len(first_word) > 1
+                                ):  # Only meaningful commands
+                                    commands.add(first_word.lower())
+                        except (ValueError, IndexError):
+                            continue
+
+                elif history_type == "bash":
+                    # Bash format: simple command per line
+                    first_word = line.split()[0] if line.split() else None
+                    if first_word and len(first_word) > 1:  # Only meaningful commands
+                        commands.add(first_word.lower())
+
+        except Exception:
+            # Skip files that can't be read
+            continue
+
+    return list(commands)
 
 
 def interactive():
     """Interactive REPL mode for devduck"""
+    from prompt_toolkit import prompt
+    from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+    from prompt_toolkit.completion import WordCompleter
+    from prompt_toolkit.history import FileHistory
+
     print("🦆 DevDuck")
+    print(f"📝 Logs: {LOG_DIR}")
     print("Type 'exit', 'quit', or 'q' to quit.")
     print("Prefix with ! to run shell commands (e.g., ! ls -la)")
-    print("-" * 50)
+    print("\n\n")
+    logger.info("Interactive mode started")
+
+    # Set up prompt_toolkit with history
+    history_file = get_shell_history_file()
+    history = FileHistory(history_file)
+
+    # Create completions from common commands and shell history
+    base_commands = ["exit", "quit", "q", "help", "clear", "status", "reload"]
+    history_commands = extract_commands_from_history()
+
+    # Combine base commands with commands from history
+    all_commands = list(set(base_commands + history_commands))
+    completer = WordCompleter(all_commands, ignore_case=True)
+
+    # Track consecutive interrupts for double Ctrl+C to exit
+    interrupt_count = 0
+    last_interrupt = 0
 
     while True:
         try:
-            # Get user input
-            q = input("\n🦆 ")
+            # Use prompt_toolkit for enhanced input with arrow key support
+            q = prompt(
+                "\n🦆 ",
+                history=history,
+                auto_suggest=AutoSuggestFromHistory(),
+                completer=completer,
+                complete_while_typing=True,
+            )
+
+            # Reset interrupt count on successful prompt
+            interrupt_count = 0
 
             # Check for exit command
             if q.lower() in ["exit", "quit", "q"]:
@@ -884,87 +1802,59 @@ def interactive():
                 shell_command = q[1:].strip()
                 try:
                     if devduck.agent:
-                        result = devduck.agent.tool.shell(command=shell_command, timeout=900)
+                        devduck._agent_executing = (
+                            True  # Prevent hot-reload during shell execution
+                        )
+                        result = devduck.agent.tool.shell(
+                            command=shell_command, timeout=9000
+                        )
+                        devduck._agent_executing = False
+
+                        # Reset terminal to fix rendering issues after command output
+                        print("\r", end="", flush=True)
+                        sys.stdout.flush()
+
                         # Append shell command to history
                         append_to_shell_history(q, result["content"][0]["text"])
+
+                        # Check if reload was pending
+                        if devduck._reload_pending:
+                            print(
+                                "🦆 Shell command finished - triggering pending hot-reload..."
+                            )
+                            devduck._hot_reload()
                     else:
                         print("🦆 Agent unavailable")
                 except Exception as e:
+                    devduck._agent_executing = False  # Reset on error
                     print(f"🦆 Shell command error: {e}")
+                    # Reset terminal on error too
+                    print("\r", end="", flush=True)
+                    sys.stdout.flush()
                 continue
 
-            # Get recent conversation context
-            recent_context = get_last_messages()
-            
-            # Update system prompt before each call with history context
-            if devduck.agent:
-                # Rebuild system prompt with history
-                own_code = get_own_source_code()
-                session_id = f"devduck-{datetime.now().strftime('%Y-%m-%d')}"
-                
-                devduck.agent.system_prompt = f"""🦆 You are DevDuck - an extreme minimalist, self-adapting agent.
-
-Environment: {devduck.env_info['os']} {devduck.env_info['arch']} 
-Python: {devduck.env_info['python']}
-Model: {devduck.model}
-Hostname: {devduck.env_info['hostname']}
-Session ID: {session_id}
-
-You are:
-- Minimalist: Brief, direct responses
-- Self-healing: Adapt when things break  
-- Efficient: Get things done fast
-- Pragmatic: Use what works
-
-Current working directory: {devduck.env_info['cwd']}
-
-{recent_context}
-
-## Your Own Implementation:
-You have full access to your own source code for self-awareness and self-modification:
-
-{own_code}
-
-## Hot Reload System Active:
-- **Instant Tool Creation** - Save any .py file in `./tools/` and it becomes immediately available
-- **No Restart Needed** - Tools are auto-loaded and ready to use instantly
-- **Live Development** - Modify existing tools while running and test immediately
-- **Full Python Access** - Create any Python functionality as a tool
-
-## System Prompt Management:
-- Use system_prompt(action='get') to view current prompt
-- Use system_prompt(action='set', prompt='new text') to update
-- Changes persist in SYSTEM_PROMPT environment variable
-
-## Shell Commands:
-- Prefix with ! to execute shell commands directly
-- Example: ! ls -la (lists files)
-- Example: ! pwd (shows current directory)
-
-**Response Format:**
-- Tool calls: **MAXIMUM PARALLELISM - ALWAYS** 
-- Communication: **MINIMAL WORDS**
-- Efficiency: **Speed is paramount**
-
-{os.getenv('SYSTEM_PROMPT', '')}"""
-                
-                # Update model if MODEL_PROVIDER changed
-                model_provider = os.getenv("MODEL_PROVIDER")
-                if model_provider:
-                    try:
-                        from strands_tools.utils.models.model import create_model
-                        devduck.agent.model = create_model(provider=model_provider)
-                    except Exception as e:
-                        print(f"🦆 Model update error: {e}")
-
             # Execute the agent with user input
             result = ask(q)
-            
+
             # Append to shell history
             append_to_shell_history(q, str(result))
 
         except KeyboardInterrupt:
-            print("\n🦆 Interrupted. Type 'exit' to quit.")
+            current_time = time.time()
+
+            # Check if this is a consecutive interrupt within 2 seconds
+            if current_time - last_interrupt < 2:
+                interrupt_count += 1
+                if interrupt_count >= 2:
+                    print("\n🦆 Exiting...")
+                    break
+                else:
+                    print("\n🦆 Interrupted. Press Ctrl+C again to exit.")
+            else:
+                interrupt_count = 1
+                print("\n🦆 Interrupted. Press Ctrl+C again to exit.")
+
+            last_interrupt = current_time
             continue
         except Exception as e:
             print(f"🦆 Error: {e}")
@@ -973,8 +1863,74 @@ You have full access to your own source code for self-awareness and self-modific
 
 def cli():
     """CLI entry point for pip-installed devduck command"""
-    if len(sys.argv) > 1:
-        query = " ".join(sys.argv[1:])
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="🦆 DevDuck - Extreme minimalist self-adapting agent",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  devduck                          # Start interactive mode
+  devduck "your query here"        # One-shot query
+  devduck --mcp                    # MCP stdio mode (for Claude Desktop)
+
+Tool Configuration:
+  export DEVDUCK_TOOLS="strands_tools:shell,editor:strands_fun_tools:clipboard"
+
+Claude Desktop Config:
+  {
+    "mcpServers": {
+      "devduck": {
+        "command": "uvx",
+        "args": ["devduck", "--mcp"]
+      }
+    }
+  }
+        """,
+    )
+
+    # Query argument
+    parser.add_argument("query", nargs="*", help="Query to send to the agent")
+
+    # MCP stdio mode flag
+    parser.add_argument(
+        "--mcp",
+        action="store_true",
+        help="Start MCP server in stdio mode (for Claude Desktop integration)",
+    )
+
+    args = parser.parse_args()
+
+    logger.info("CLI mode started")
+
+    # Handle --mcp flag for stdio mode
+    if args.mcp:
+        logger.info("Starting MCP server in stdio mode (blocking, foreground)")
+        print("🦆 Starting MCP stdio server...", file=sys.stderr)
+
+        # Don't auto-start HTTP/TCP/WS servers for stdio mode
+        if devduck.agent:
+            try:
+                # Start MCP server in stdio mode - this BLOCKS until terminated
+                devduck.agent.tool.mcp_server(
+                    action="start",
+                    transport="stdio",
+                    expose_agent=True,
+                    agent=devduck.agent,
+                    record_direct_tool_call=False,
+                )
+            except Exception as e:
+                logger.error(f"Failed to start MCP stdio server: {e}")
+                print(f"🦆 Error: {e}", file=sys.stderr)
+                sys.exit(1)
+        else:
+            print("🦆 Agent not available", file=sys.stderr)
+            sys.exit(1)
+        return
+
+    if args.query:
+        query = " ".join(args.query)
+        logger.info(f"CLI query: {query}")
         result = ask(query)
         print(result)
     else: